From af10d06e9a2ab5a1eafac6f5296004d2c34c6d79 Mon Sep 17 00:00:00 2001
From: Blake Regalia <blake.regalia@gmail.com>
Date: Fri, 2 Oct 2026 15:58:06 -0700
Subject: [PATCH] chore(release): v0.10.0

---
 .github/workflows/ci.yml                      |    39 +-
 CBOR.md                                       |    31 +-
 CHANGELOG.md                                  |   121 +
 CLI.md                                        |    77 +-
 Cargo.lock                                    |    28 +-
 Cargo.toml                                    |    19 +-
 IDS.md                                        |    83 +-
 INTEROP.md                                    |    58 +-
 LICENSE                                       |     2 +-
 README.md                                     |    21 +-
 SDK.md                                        |     6 +-
 crates/sysmlv2-cbor/Cargo.toml                |     2 +-
 crates/sysmlv2-cbor/src/decode.rs             |    67 +-
 crates/sysmlv2-cbor/src/delta.rs              |    45 +-
 crates/sysmlv2-cbor/src/describe.rs           |     6 +-
 crates/sysmlv2-cbor/src/encode.rs             |    96 +-
 crates/sysmlv2-cbor/src/lib.rs                |    17 +-
 crates/sysmlv2-cbor/src/resolver.rs           |    12 +-
 .../tests/canonical_constructors.rs           |   153 +
 .../sysmlv2-cbor/tests/conditional_graph.rs   |   288 +
 .../tests/connector_end_defaults.rs           |    71 +
 crates/sysmlv2-cbor/tests/delta.rs            |    39 +-
 crates/sysmlv2-cbor/tests/determinism.rs      |     4 +-
 crates/sysmlv2-cbor/tests/elide.rs            |    29 +-
 crates/sysmlv2-cbor/tests/owned_results.rs    |   110 +
 crates/sysmlv2-cbor/tests/resolver.rs         |     6 +
 crates/sysmlv2-cli/Cargo.toml                 |     2 +-
 crates/sysmlv2-cli/src/lib.rs                 |   422 +-
 crates/sysmlv2-cli/tests/cli.rs               |   117 +-
 crates/sysmlv2-cli/tests/inprocess.rs         |    17 +-
 crates/sysmlv2-lint/Cargo.toml                |     4 +-
 crates/sysmlv2-lint/src/lib.rs                |    83 +
 crates/sysmlv2-lint/tests/lint.rs             |   284 +-
 crates/sysmlv2-lsp/src/accept.rs              |   488 +
 crates/sysmlv2-lsp/src/autofix.rs             |   311 +-
 crates/sysmlv2-lsp/src/autoimport.rs          |   611 +-
 crates/sysmlv2-lsp/src/kinds.rs               |  1162 +
 crates/sysmlv2-lsp/src/lib.rs                 |   198 +-
 crates/sysmlv2-lsp/src/nav.rs                 |  4039 +++-
 crates/sysmlv2-lsp/src/nav/namespaces.rs      |  1381 ++
 crates/sysmlv2-lsp/src/outline.rs             |   241 +-
 crates/sysmlv2-lsp/src/push.rs                |  7680 ++++++-
 crates/sysmlv2-lsp/src/receiver.rs            |   401 +
 crates/sysmlv2-lsp/src/reuse.rs               |  1440 ++
 crates/sysmlv2-lsp/src/salvage.rs             |  1337 ++
 crates/sysmlv2-lsp/src/signature.rs           |   587 +
 crates/sysmlv2-lsp/src/site.rs                |  3461 +++
 crates/sysmlv2-lsp/src/tokens.rs              |    16 +-
 crates/sysmlv2-lsp/src/units.rs               |   993 +
 crates/sysmlv2-lsp/tests/extras.rs            |    59 +-
 .../sysmlv2-lsp/tests/library_signatures.rs   |   198 +
 crates/sysmlv2-lsp/tests/nav.rs               |    32 +-
 crates/sysmlv2-lsp/tests/tokens_corpus.rs     |    43 +-
 crates/sysmlv2-lsp/tests/unit_typing.rs       |  1318 +-
 crates/sysmlv2-model/Cargo.toml               |     3 +-
 crates/sysmlv2-model/src/ambient.rs           |    67 +-
 crates/sysmlv2-model/src/cache_codec.rs       |   278 +-
 crates/sysmlv2-model/src/check.rs             |    73 +-
 crates/sysmlv2-model/src/check/actions.rs     |    16 +-
 crates/sysmlv2-model/src/check/chains.rs      |     5 +-
 crates/sysmlv2-model/src/check/dimensions.rs  |    42 +
 crates/sysmlv2-model/src/check/directions.rs  |   443 +
 .../src/check/distinguishability.rs           |    85 +-
 crates/sysmlv2-model/src/check/expressions.rs |   118 +-
 crates/sysmlv2-model/src/check/facts.rs       |   209 +-
 crates/sysmlv2-model/src/check/invocations.rs |    85 +-
 .../sysmlv2-model/src/check/multiplicities.rs |   127 +-
 .../src/check/multiplicity_domains.rs         |   496 +
 .../sysmlv2-model/src/check/relationships.rs  |    12 +-
 crates/sysmlv2-model/src/check/scalars.rs     |    33 +-
 .../sysmlv2-model/src/check/specialization.rs |   171 +-
 crates/sysmlv2-model/src/check/structural.rs  |    51 +-
 crates/sysmlv2-model/src/check/values.rs      |   101 +-
 crates/sysmlv2-model/src/eval.rs              |  2603 ++-
 crates/sysmlv2-model/src/eval/report.rs       |   387 +
 crates/sysmlv2-model/src/full.rs              |   642 +-
 crates/sysmlv2-model/src/ids.rs               |    62 +-
 crates/sysmlv2-model/src/json.rs              |  5511 ++++-
 crates/sysmlv2-model/src/json/behavior.rs     |    94 +-
 .../sysmlv2-model/src/json/callable_bodies.rs |   190 +
 crates/sysmlv2-model/src/json/cardinality.rs  |  1612 ++
 crates/sysmlv2-model/src/json/closures.rs     |    51 +-
 .../src/json/constructor_bindings.rs          |  1449 ++
 crates/sysmlv2-model/src/json/derived.rs      |   269 +-
 .../src/json/derived_compositions.rs          |     8 +-
 .../sysmlv2-model/src/json/direction_proof.rs |   366 +
 .../sysmlv2-model/src/json/dynamic_graph.rs   |  1166 +
 .../src/json/dynamic_invocations.rs           |  1535 ++
 .../sysmlv2-model/src/json/end_constancy.rs   |   553 +
 crates/sysmlv2-model/src/json/exposure.rs     |   190 +
 .../src/json/feature_type_projection.rs       |   426 +
 .../json/feature_type_projection/adapter.rs   |   534 +
 .../readiness_tests.rs                        |   319 +
 .../json/feature_type_projection/report.rs    |   196 +
 .../repository_tests.rs                       |   272 +
 ...function_specialization_readiness_tests.rs |    40 +
 .../src/json/generated_defaults.rs            |   238 +
 .../src/json/identity_tables_tests.rs         |   163 +
 crates/sysmlv2-model/src/json/implied.rs      |  6035 ++++-
 .../src/json/import_memberships.rs            |   363 +
 .../src/json/invocation_bindings.rs           |  1074 +
 .../src/json/literal_inheritance.rs           |   502 +
 .../sysmlv2-model/src/json/local_featuring.rs |   597 +
 .../src/json/membership_context.rs            |   558 +
 .../src/json/membership_evidence.rs           |   525 +
 .../src/json/membership_projection.rs         |   406 +
 .../src/json/metadata_associations.rs         |   368 +
 .../src/json/model_level_evaluability.rs      |   559 +
 .../json/model_level_evaluability/adapter.rs  |  1355 ++
 .../src/json/named_argument_index_tests.rs    |   249 +
 crates/sysmlv2-model/src/json/naming.rs       |   130 +-
 crates/sysmlv2-model/src/json/operations.rs   |   874 +
 .../src/json/operations/namespaces.rs         |   941 +
 .../src/json/operations/namespaces/imports.rs |   992 +
 .../namespaces/imports/depth_tests.rs         |   263 +
 .../namespaces/recursive_features.rs          |   354 +
 .../json/operations/namespaces/resolution.rs  |   294 +
 .../operations/namespaces/type_memberships.rs |   373 +
 .../sysmlv2-model/src/json/owned_results.rs   |   783 +
 .../src/json/parameter_context.rs             |   463 +
 crates/sysmlv2-model/src/json/parameters.rs   |  1586 ++
 crates/sysmlv2-model/src/json/positional.rs   |  2296 ++
 .../src/json/positional_delta.rs              |   194 +
 .../src/json/provider_completeness.rs         |  1046 +
 .../json/provider_completeness/mixed_tests.rs |   244 +
 .../json/provider_completeness/recursive.rs   |   519 +
 .../recursive/qualified.rs                    |   122 +
 .../provider_completeness/recursive_tests.rs  |   495 +
 crates/sysmlv2-model/src/json/publication.rs  |   124 +
 .../sysmlv2-model/src/json/recorded_lookup.rs |  1232 ++
 .../src/json/redefinition_provenance.rs       |   145 +
 .../src/json/replay_dependencies_tests.rs     |   413 +
 .../src/json/result_redefinition.rs           |  1213 +
 .../sysmlv2-model/src/json/runtime_frames.rs  |   259 +
 crates/sysmlv2-model/src/json/scope_table.rs  |     6 +-
 crates/sysmlv2-model/src/json/semantic.rs     |   520 +
 .../src/json/semantic/certified_types.rs      |  1507 ++
 .../json/semantic/definition_usage_tests.rs   |   163 +
 .../sysmlv2-model/src/json/semantic/export.rs |   505 +
 .../src/json/semantic/type_fidelity_tests.rs  |   120 +
 .../sysmlv2-model/src/json/semantic_batch.rs  |    52 +
 .../src/json/semantic_ownership.rs            |   400 +
 crates/sysmlv2-model/src/json/settled.rs      |   448 +
 .../src/json/structural_index.rs              |  2334 ++
 .../src/json/succession_endpoints.rs          |   251 +
 .../src/json/supertypes_checked_tests.rs      |   236 +
 .../sysmlv2-model/src/json/type_features.rs   |   564 +
 crates/sysmlv2-model/src/json/type_inputs.rs  |  1686 ++
 .../json/type_inputs/authored_dependencies.rs |   177 +
 .../json/type_inputs/import_dependencies.rs   |   257 +
 .../type_inputs/parameter_dependencies.rs     |   279 +
 .../json/type_inputs/visible_dependencies.rs  |   233 +
 .../sysmlv2-model/src/json/type_relations.rs  |  2893 +++
 crates/sysmlv2-model/src/json/typeops.rs      |   332 +-
 .../src/json/usage_variability.rs             |   708 +
 .../sysmlv2-model/src/json/value_context.rs   |   381 +
 crates/sysmlv2-model/src/layered.rs           |   208 +-
 crates/sysmlv2-model/src/lib.rs               |     5 +-
 crates/sysmlv2-model/src/libcache.rs          |    50 +-
 crates/sysmlv2-model/src/lift.rs              |   397 +-
 crates/sysmlv2-model/src/loader.rs            |   810 +-
 crates/sysmlv2-model/src/metamodel.rs         |   139 +
 crates/sysmlv2-model/src/migration.rs         |  1819 ++
 crates/sysmlv2-model/src/model.rs             |   327 +-
 crates/sysmlv2-model/src/operation_catalog.rs |   414 +
 crates/sysmlv2-model/src/prepared.rs          |   396 +-
 crates/sysmlv2-model/src/properties.rs        |   101 +-
 crates/sysmlv2-model/src/quantity.rs          |    67 +-
 crates/sysmlv2-model/src/render.rs            |   767 -
 crates/sysmlv2-model/src/semantic_catalog.rs  | 14132 ++++++++++++
 crates/sysmlv2-parser/Cargo.toml              |     6 +-
 crates/sysmlv2-parser/examples/bench.rs       |     2 +-
 .../examples/derived_correspondence.rs        |     2 +-
 crates/sysmlv2-parser/examples/evalstats.rs   |     5 +-
 crates/sysmlv2-parser/examples/fullcheck.rs   |     2 +-
 .../examples/implied_reachability_bench.rs    |    64 +
 crates/sysmlv2-parser/examples/modelcheck.rs  |     2 +-
 crates/sysmlv2-parser/examples/modelcheck2.rs |     2 +-
 crates/sysmlv2-parser/examples/refreport.rs   |     2 +-
 crates/sysmlv2-parser/examples/semstats.rs    |     5 +-
 crates/sysmlv2-parser/examples/verifystats.rs |     5 +-
 crates/sysmlv2-parser/src/lib.rs              |     4 +-
 .../tests/annotation_precision.rs             |    45 +
 .../tests/binary_connection_bases.rs          |   184 +
 .../sysmlv2-parser/tests/cardinality_body.rs  |   667 +
 .../tests/cardinality_context.rs              |   422 +
 .../tests/cardinality_subject.rs              |   163 +
 .../tests/certified_type_properties.rs        |   265 +
 crates/sysmlv2-parser/tests/check.rs          |   272 +-
 .../tests/checked_authored_prerequisites.rs   |   303 +
 .../tests/checked_cardinality.rs              |   179 +
 .../tests/checked_constructors.rs             |   203 +
 .../tests/checked_definition_usage.rs         |    70 +
 .../tests/checked_end_contexts.rs             |   127 +
 .../tests/checked_import_planning.rs          |   250 +
 .../tests/checked_owned_relationships.rs      |    86 +
 .../tests/checked_parameter_prerequisites.rs  |   301 +
 .../tests/checked_positional_prerequisites.rs |   237 +
 .../tests/checked_recursive_providers.rs      |   352 +
 .../tests/checked_structural_members.rs       |    57 +
 .../tests/checked_type_imports.rs             |   307 +
 .../tests/checked_type_memberships.rs         |   168 +
 .../tests/checked_usage_typing.rs             |   406 +
 .../tests/checked_visible_prerequisites.rs    |   255 +
 .../sysmlv2-parser/tests/checker_identity.rs  |   872 +
 crates/sysmlv2-parser/tests/closure_policy.rs |    39 +-
 .../tests/connector_bound_scopes.rs           |    78 +
 .../tests/connector_end_bindings.rs           |   138 +
 .../tests/connector_relationship_ends.rs      |   346 +
 .../tests/constructor_static_evaluation.rs    |    85 +
 .../sysmlv2-parser/tests/corpus_identity.rs   |    45 +
 .../tests/cross_feature_scopes.rs             |   157 +
 .../tests/default_featuring_identity.rs       |   151 +
 crates/sysmlv2-parser/tests/derived_api.rs    |   308 +-
 .../tests/distinguishability.rs               |    58 +-
 .../tests/dynamic_invocations.rs              |    91 +
 crates/sysmlv2-parser/tests/eval.rs           |   745 +-
 .../sysmlv2-parser/tests/exposure_context.rs  |   204 +
 .../tests/exposure_memberships.rs             |   233 +
 .../tests/expression_fixed_roles.rs           |   157 +
 .../tests/expression_static_ancestry.rs       |   193 +
 .../tests/feature_chain_static_typing.rs      |   108 +
 .../tests/feature_library_bases.rs            |   229 +
 .../tests/feature_type_report.rs              |   119 +
 .../sysmlv2-parser/tests/filter_identity.rs   |   247 +
 .../tests/fixtures/full-form-baseline.tsv     |  4558 ++--
 .../fixtures/opensysml/baseline-library.json  |    86 +-
 .../tests/fixtures/opensysml/baseline.json    |    76 +-
 crates/sysmlv2-parser/tests/full_baseline.rs  |     2 +-
 crates/sysmlv2-parser/tests/full_json.rs      |   175 +-
 crates/sysmlv2-parser/tests/grammar_edge.rs   |     9 -
 .../tests/import_memberships.rs               |   704 +
 .../tests/inherited_base_context.rs           |    97 +
 .../sysmlv2-parser/tests/inherited_battery.rs |    31 +-
 .../tests/inherited_default_report.rs         |   486 +
 .../sysmlv2-parser/tests/inherited_lookup.rs  |   888 +
 .../tests/inherited_lookup_provenance.rs      |    47 +
 crates/sysmlv2-parser/tests/kerml.rs          |    38 +
 crates/sysmlv2-parser/tests/libcache.rs       |   265 +-
 .../sysmlv2-parser/tests/literal_results.rs   |   587 +
 crates/sysmlv2-parser/tests/metadata_about.rs |   192 +
 .../sysmlv2-parser/tests/metadata_results.rs  |   299 +
 crates/sysmlv2-parser/tests/model.rs          |   282 +-
 .../tests/model_level_evaluability.rs         |   180 +
 .../tests/model_level_function_identity.rs    |   293 +
 .../tests/multiplicity_validation.rs          |   931 +
 .../tests/negative/cstyle_operators.sysml     |     4 +-
 .../tests/negative/expressions.sysml          |     2 +-
 .../tests/negative/imports.sysml              |     2 +-
 .../tests/negative/missing_expressions.kerml  |    18 +
 .../tests/negative/missing_expressions.sysml  |    45 +
 .../tests/negative/pilot_era.sysml            |     2 +-
 .../tests/negative/result_terminators.kerml   |    10 +
 .../tests/negative/result_terminators.sysml   |    37 +
 crates/sysmlv2-parser/tests/operations.rs     |   337 +
 .../tests/owned_result_featuring.rs           |    98 +
 .../tests/owned_result_redefinition.rs        |    71 +
 crates/sysmlv2-parser/tests/owned_results.rs  |   509 +
 crates/sysmlv2-parser/tests/parser.rs         |   142 +
 .../tests/positional_alias_memberships.rs     |   194 +
 .../tests/positional_members.rs               |   190 +
 .../tests/positional_redefinitions.rs         |   654 +
 .../tests/qualified_positional_slots.rs       |   218 +
 crates/sysmlv2-parser/tests/query.rs          |    61 +-
 .../tests/recorded_alias_paths.rs             |   173 +
 .../tests/recorded_lookup_effects.rs          |   168 +
 .../tests/redefinition_direction.rs           |   279 +
 .../tests/reference_bindings.rs               |   456 +
 crates/sysmlv2-parser/tests/roundtrip.rs      |   272 +-
 .../tests/sdk_semantic_regressions.rs         |   286 +
 .../tests/semantic_names_reporting.rs         |   272 +
 crates/sysmlv2-parser/tests/semantic_reads.rs |   231 +
 .../tests/shared_implied_plan.rs              |   159 +
 crates/sysmlv2-parser/tests/static_rules.rs   |    30 +
 .../tests/supertypes_operation.rs             |   165 +
 .../tests/sysml_assertion_roles.rs            |   210 +
 crates/sysmlv2-parser/tests/xmi_audit.rs      |     5 +-
 crates/sysmlv2-py/Cargo.toml                  |    10 +-
 crates/sysmlv2-py/src/lib.rs                  |    27 +
 .../sysmlv2-py/tests/implied_conformance.py   |    25 +
 crates/sysmlv2-py/tests/smoke.py              |     4 +-
 crates/sysmlv2-solve/Cargo.toml               |     4 +-
 crates/sysmlv2-solve/examples/solvestats.rs   |     5 +-
 crates/sysmlv2-solve/examples/unknowns.rs     |     5 +-
 crates/sysmlv2-solve/src/lib.rs               |   123 +-
 crates/sysmlv2-solve/src/translate.rs         |  1210 +-
 crates/sysmlv2-solve/tests/apollo.rs          |     9 +-
 .../tests/common/collection_identity.rs       |   217 +
 crates/sysmlv2-solve/tests/corpus.rs          |    22 +-
 .../tests/environment_identity.rs             |   794 +
 crates/sysmlv2-solve/tests/propagate.rs       |   450 +-
 .../tests/propagation_approximation.rs        |   339 +
 .../tests/runtime_frame_visibility.rs         |   470 +
 crates/sysmlv2-solve/tests/solve.rs           |   283 +-
 crates/sysmlv2-solve/tests/source_identity.rs |   187 +
 .../tests/source_identity_chains.rs           |   190 +
 .../tests/value_receiver_identity.rs          |   442 +
 crates/sysmlv2-syntax/src/ast.rs              |     3 -
 crates/sysmlv2-syntax/src/check.rs            |   116 +-
 crates/sysmlv2-syntax/src/parser.rs           |   122 +-
 crates/sysmlv2-syntax/src/print.rs            |     1 -
 crates/sysmlv2-syntax/src/visit.rs            |     2 +-
 crates/sysmlv2-testkit/src/lib.rs             |    72 +
 crates/sysmlv2-transform/Cargo.toml           |     6 +-
 .../examples/sessionbench.rs                  |   298 +
 crates/sysmlv2-transform/src/lib.rs           |   826 +-
 .../tests/cardinality_identity.rs             |   148 +
 .../tests/exposure_roundtrip.rs               |    76 +
 .../tests/format_transport_adversarial.rs     |   232 +
 .../sysmlv2-transform/tests/graph_format.rs   |   377 +
 .../tests/inherited_lookup_provenance.rs      |    72 +
 .../tests/library_reference_spelling.rs       |   552 +
 .../sysmlv2-transform/tests/payload_loader.rs |   517 +-
 .../tests/settled_outcomes.rs                 |   129 +
 .../tests/text_reference_spelling.rs          |   207 +
 crates/sysmlv2-transform/tests/transform.rs   |     2 +-
 crates/sysmlv2-transform/tests/type_inputs.rs |    55 +
 crates/sysmlv2-viz/Cargo.toml                 |     4 +-
 crates/sysmlv2-viz/README.md                  |     2 +-
 crates/sysmlv2-viz/src/lib.rs                 |   165 +-
 crates/sysmlv2-viz/tests/viz.rs               |   170 +-
 crates/sysmlv2-wasm/Cargo.toml                |     4 +
 crates/sysmlv2-wasm/README.md                 |    25 +-
 crates/sysmlv2-wasm/npm/build.mjs             |   165 +-
 crates/sysmlv2-wasm/npm/cli_smoke.mjs         |    21 +-
 crates/sysmlv2-wasm/npm/smoke.mjs             |    95 +
 .../sysmlv2-wasm/src/bin/gen_stdlib_bundle.rs |    33 +-
 crates/sysmlv2-wasm/src/lib.rs                |   201 +-
 crates/sysmlv2-wasm/tests/api.rs              |   494 +-
 .../sysmlv2-wasm/tests/implied_conformance.rs |    17 +
 crates/sysmlv2-wasm/tests/prepared_library.rs |   126 +-
 crates/sysmlv2-wasm/tests/settled.rs          |   309 +
 local-packages/README.md                      |    28 +-
 local-packages/Svelte.provenance.json         |   802 -
 local-packages/Svelte.sysml                   |   147 -
 local-packages/SvelteKit.provenance.json      |   227 -
 local-packages/SvelteKit.sysml                |    69 -
 local-packages/Template.provenance.json       |   612 -
 local-packages/Template.sysml                 |   129 -
 local-packages/Web.provenance.json            | 18337 ----------------
 local-packages/Web.sysml                      |  2753 ---
 local-packages/WebApp.provenance.json         |   131 -
 local-packages/WebApp.sysml                   |    41 -
 spec-refs/README.md                           |    14 +-
 spec-refs/derived-correspondence.json         |  5352 ++---
 spec-refs/derived-properties.json             |   630 +-
 spec-refs/derived-properties.md               |   204 +-
 tools/derived_census.py                       |    42 +-
 tools/operation_catalog.py                    |    79 +
 tools/semantic_catalog.py                     |   140 +
 tools/test_derived_compositions.py            |    31 +
 351 files changed, 142703 insertions(+), 34350 deletions(-)
 create mode 100644 crates/sysmlv2-cbor/tests/canonical_constructors.rs
 create mode 100644 crates/sysmlv2-cbor/tests/conditional_graph.rs
 create mode 100644 crates/sysmlv2-cbor/tests/connector_end_defaults.rs
 create mode 100644 crates/sysmlv2-cbor/tests/owned_results.rs
 create mode 100644 crates/sysmlv2-lsp/src/accept.rs
 create mode 100644 crates/sysmlv2-lsp/src/kinds.rs
 create mode 100644 crates/sysmlv2-lsp/src/nav/namespaces.rs
 create mode 100644 crates/sysmlv2-lsp/src/receiver.rs
 create mode 100644 crates/sysmlv2-lsp/src/reuse.rs
 create mode 100644 crates/sysmlv2-lsp/src/salvage.rs
 create mode 100644 crates/sysmlv2-lsp/src/signature.rs
 create mode 100644 crates/sysmlv2-lsp/src/site.rs
 create mode 100644 crates/sysmlv2-lsp/src/units.rs
 create mode 100644 crates/sysmlv2-lsp/tests/library_signatures.rs
 create mode 100644 crates/sysmlv2-model/src/check/directions.rs
 create mode 100644 crates/sysmlv2-model/src/check/multiplicity_domains.rs
 create mode 100644 crates/sysmlv2-model/src/eval/report.rs
 create mode 100644 crates/sysmlv2-model/src/json/callable_bodies.rs
 create mode 100644 crates/sysmlv2-model/src/json/cardinality.rs
 create mode 100644 crates/sysmlv2-model/src/json/constructor_bindings.rs
 create mode 100644 crates/sysmlv2-model/src/json/direction_proof.rs
 create mode 100644 crates/sysmlv2-model/src/json/dynamic_graph.rs
 create mode 100644 crates/sysmlv2-model/src/json/dynamic_invocations.rs
 create mode 100644 crates/sysmlv2-model/src/json/end_constancy.rs
 create mode 100644 crates/sysmlv2-model/src/json/exposure.rs
 create mode 100644 crates/sysmlv2-model/src/json/feature_type_projection.rs
 create mode 100644 crates/sysmlv2-model/src/json/feature_type_projection/adapter.rs
 create mode 100644 crates/sysmlv2-model/src/json/feature_type_projection/readiness_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/feature_type_projection/report.rs
 create mode 100644 crates/sysmlv2-model/src/json/feature_type_projection/repository_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/function_specialization_readiness_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/generated_defaults.rs
 create mode 100644 crates/sysmlv2-model/src/json/identity_tables_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/import_memberships.rs
 create mode 100644 crates/sysmlv2-model/src/json/invocation_bindings.rs
 create mode 100644 crates/sysmlv2-model/src/json/literal_inheritance.rs
 create mode 100644 crates/sysmlv2-model/src/json/local_featuring.rs
 create mode 100644 crates/sysmlv2-model/src/json/membership_context.rs
 create mode 100644 crates/sysmlv2-model/src/json/membership_evidence.rs
 create mode 100644 crates/sysmlv2-model/src/json/membership_projection.rs
 create mode 100644 crates/sysmlv2-model/src/json/metadata_associations.rs
 create mode 100644 crates/sysmlv2-model/src/json/model_level_evaluability.rs
 create mode 100644 crates/sysmlv2-model/src/json/model_level_evaluability/adapter.rs
 create mode 100644 crates/sysmlv2-model/src/json/named_argument_index_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces/imports.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces/imports/depth_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces/recursive_features.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces/resolution.rs
 create mode 100644 crates/sysmlv2-model/src/json/operations/namespaces/type_memberships.rs
 create mode 100644 crates/sysmlv2-model/src/json/owned_results.rs
 create mode 100644 crates/sysmlv2-model/src/json/parameter_context.rs
 create mode 100644 crates/sysmlv2-model/src/json/parameters.rs
 create mode 100644 crates/sysmlv2-model/src/json/positional.rs
 create mode 100644 crates/sysmlv2-model/src/json/positional_delta.rs
 create mode 100644 crates/sysmlv2-model/src/json/provider_completeness.rs
 create mode 100644 crates/sysmlv2-model/src/json/provider_completeness/mixed_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/provider_completeness/recursive.rs
 create mode 100644 crates/sysmlv2-model/src/json/provider_completeness/recursive/qualified.rs
 create mode 100644 crates/sysmlv2-model/src/json/provider_completeness/recursive_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/publication.rs
 create mode 100644 crates/sysmlv2-model/src/json/recorded_lookup.rs
 create mode 100644 crates/sysmlv2-model/src/json/redefinition_provenance.rs
 create mode 100644 crates/sysmlv2-model/src/json/replay_dependencies_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/result_redefinition.rs
 create mode 100644 crates/sysmlv2-model/src/json/runtime_frames.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic/certified_types.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic/definition_usage_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic/export.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic/type_fidelity_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic_batch.rs
 create mode 100644 crates/sysmlv2-model/src/json/semantic_ownership.rs
 create mode 100644 crates/sysmlv2-model/src/json/settled.rs
 create mode 100644 crates/sysmlv2-model/src/json/structural_index.rs
 create mode 100644 crates/sysmlv2-model/src/json/succession_endpoints.rs
 create mode 100644 crates/sysmlv2-model/src/json/supertypes_checked_tests.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_features.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_inputs.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_inputs/authored_dependencies.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_inputs/import_dependencies.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_inputs/parameter_dependencies.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_inputs/visible_dependencies.rs
 create mode 100644 crates/sysmlv2-model/src/json/type_relations.rs
 create mode 100644 crates/sysmlv2-model/src/json/usage_variability.rs
 create mode 100644 crates/sysmlv2-model/src/json/value_context.rs
 create mode 100644 crates/sysmlv2-model/src/metamodel.rs
 create mode 100644 crates/sysmlv2-model/src/migration.rs
 create mode 100644 crates/sysmlv2-model/src/operation_catalog.rs
 delete mode 100644 crates/sysmlv2-model/src/render.rs
 create mode 100644 crates/sysmlv2-model/src/semantic_catalog.rs
 create mode 100644 crates/sysmlv2-parser/examples/implied_reachability_bench.rs
 create mode 100644 crates/sysmlv2-parser/tests/annotation_precision.rs
 create mode 100644 crates/sysmlv2-parser/tests/binary_connection_bases.rs
 create mode 100644 crates/sysmlv2-parser/tests/cardinality_body.rs
 create mode 100644 crates/sysmlv2-parser/tests/cardinality_context.rs
 create mode 100644 crates/sysmlv2-parser/tests/cardinality_subject.rs
 create mode 100644 crates/sysmlv2-parser/tests/certified_type_properties.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_authored_prerequisites.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_cardinality.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_constructors.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_definition_usage.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_end_contexts.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_import_planning.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_owned_relationships.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_parameter_prerequisites.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_positional_prerequisites.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_recursive_providers.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_structural_members.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_type_imports.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_type_memberships.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_usage_typing.rs
 create mode 100644 crates/sysmlv2-parser/tests/checked_visible_prerequisites.rs
 create mode 100644 crates/sysmlv2-parser/tests/checker_identity.rs
 create mode 100644 crates/sysmlv2-parser/tests/connector_bound_scopes.rs
 create mode 100644 crates/sysmlv2-parser/tests/connector_end_bindings.rs
 create mode 100644 crates/sysmlv2-parser/tests/connector_relationship_ends.rs
 create mode 100644 crates/sysmlv2-parser/tests/constructor_static_evaluation.rs
 create mode 100644 crates/sysmlv2-parser/tests/corpus_identity.rs
 create mode 100644 crates/sysmlv2-parser/tests/cross_feature_scopes.rs
 create mode 100644 crates/sysmlv2-parser/tests/default_featuring_identity.rs
 create mode 100644 crates/sysmlv2-parser/tests/dynamic_invocations.rs
 create mode 100644 crates/sysmlv2-parser/tests/exposure_context.rs
 create mode 100644 crates/sysmlv2-parser/tests/exposure_memberships.rs
 create mode 100644 crates/sysmlv2-parser/tests/expression_fixed_roles.rs
 create mode 100644 crates/sysmlv2-parser/tests/expression_static_ancestry.rs
 create mode 100644 crates/sysmlv2-parser/tests/feature_chain_static_typing.rs
 create mode 100644 crates/sysmlv2-parser/tests/feature_library_bases.rs
 create mode 100644 crates/sysmlv2-parser/tests/feature_type_report.rs
 create mode 100644 crates/sysmlv2-parser/tests/filter_identity.rs
 create mode 100644 crates/sysmlv2-parser/tests/import_memberships.rs
 create mode 100644 crates/sysmlv2-parser/tests/inherited_base_context.rs
 create mode 100644 crates/sysmlv2-parser/tests/inherited_default_report.rs
 create mode 100644 crates/sysmlv2-parser/tests/inherited_lookup.rs
 create mode 100644 crates/sysmlv2-parser/tests/inherited_lookup_provenance.rs
 create mode 100644 crates/sysmlv2-parser/tests/literal_results.rs
 create mode 100644 crates/sysmlv2-parser/tests/metadata_about.rs
 create mode 100644 crates/sysmlv2-parser/tests/metadata_results.rs
 create mode 100644 crates/sysmlv2-parser/tests/model_level_evaluability.rs
 create mode 100644 crates/sysmlv2-parser/tests/model_level_function_identity.rs
 create mode 100644 crates/sysmlv2-parser/tests/multiplicity_validation.rs
 create mode 100644 crates/sysmlv2-parser/tests/negative/missing_expressions.kerml
 create mode 100644 crates/sysmlv2-parser/tests/negative/missing_expressions.sysml
 create mode 100644 crates/sysmlv2-parser/tests/negative/result_terminators.kerml
 create mode 100644 crates/sysmlv2-parser/tests/negative/result_terminators.sysml
 create mode 100644 crates/sysmlv2-parser/tests/operations.rs
 create mode 100644 crates/sysmlv2-parser/tests/owned_result_featuring.rs
 create mode 100644 crates/sysmlv2-parser/tests/owned_result_redefinition.rs
 create mode 100644 crates/sysmlv2-parser/tests/owned_results.rs
 create mode 100644 crates/sysmlv2-parser/tests/positional_alias_memberships.rs
 create mode 100644 crates/sysmlv2-parser/tests/positional_members.rs
 create mode 100644 crates/sysmlv2-parser/tests/positional_redefinitions.rs
 create mode 100644 crates/sysmlv2-parser/tests/qualified_positional_slots.rs
 create mode 100644 crates/sysmlv2-parser/tests/recorded_alias_paths.rs
 create mode 100644 crates/sysmlv2-parser/tests/recorded_lookup_effects.rs
 create mode 100644 crates/sysmlv2-parser/tests/redefinition_direction.rs
 create mode 100644 crates/sysmlv2-parser/tests/reference_bindings.rs
 create mode 100644 crates/sysmlv2-parser/tests/sdk_semantic_regressions.rs
 create mode 100644 crates/sysmlv2-parser/tests/semantic_names_reporting.rs
 create mode 100644 crates/sysmlv2-parser/tests/semantic_reads.rs
 create mode 100644 crates/sysmlv2-parser/tests/shared_implied_plan.rs
 create mode 100644 crates/sysmlv2-parser/tests/supertypes_operation.rs
 create mode 100644 crates/sysmlv2-parser/tests/sysml_assertion_roles.rs
 create mode 100644 crates/sysmlv2-py/tests/implied_conformance.py
 create mode 100644 crates/sysmlv2-solve/tests/common/collection_identity.rs
 create mode 100644 crates/sysmlv2-solve/tests/environment_identity.rs
 create mode 100644 crates/sysmlv2-solve/tests/propagation_approximation.rs
 create mode 100644 crates/sysmlv2-solve/tests/runtime_frame_visibility.rs
 create mode 100644 crates/sysmlv2-solve/tests/source_identity.rs
 create mode 100644 crates/sysmlv2-solve/tests/source_identity_chains.rs
 create mode 100644 crates/sysmlv2-solve/tests/value_receiver_identity.rs
 create mode 100644 crates/sysmlv2-transform/examples/sessionbench.rs
 create mode 100644 crates/sysmlv2-transform/tests/cardinality_identity.rs
 create mode 100644 crates/sysmlv2-transform/tests/exposure_roundtrip.rs
 create mode 100644 crates/sysmlv2-transform/tests/format_transport_adversarial.rs
 create mode 100644 crates/sysmlv2-transform/tests/graph_format.rs
 create mode 100644 crates/sysmlv2-transform/tests/inherited_lookup_provenance.rs
 create mode 100644 crates/sysmlv2-transform/tests/library_reference_spelling.rs
 create mode 100644 crates/sysmlv2-transform/tests/settled_outcomes.rs
 create mode 100644 crates/sysmlv2-transform/tests/text_reference_spelling.rs
 create mode 100644 crates/sysmlv2-transform/tests/type_inputs.rs
 create mode 100644 crates/sysmlv2-wasm/tests/implied_conformance.rs
 create mode 100644 crates/sysmlv2-wasm/tests/settled.rs
 delete mode 100644 local-packages/Svelte.provenance.json
 delete mode 100644 local-packages/Svelte.sysml
 delete mode 100644 local-packages/SvelteKit.provenance.json
 delete mode 100644 local-packages/SvelteKit.sysml
 delete mode 100644 local-packages/Template.provenance.json
 delete mode 100644 local-packages/Template.sysml
 delete mode 100644 local-packages/Web.provenance.json
 delete mode 100644 local-packages/Web.sysml
 delete mode 100644 local-packages/WebApp.provenance.json
 delete mode 100644 local-packages/WebApp.sysml
 create mode 100644 tools/operation_catalog.py
 create mode 100644 tools/semantic_catalog.py
 create mode 100644 tools/test_derived_compositions.py

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 14316e6..5be8b71 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,7 +20,7 @@
 # only if a variant's delta ever grows past caring about. The test job
 # clippy-checks the slim variant so it cannot rot between releases.
 #
-# The wasm job gates the browser face: clippy for
+# The wasm job gates the browser face: clippy for the wasi CLI and for
 # wasm32-unknown-unknown, then the real pipeline — wasm-pack build, the
 # stdlib bundle + sealed-snapshot generation, and a node smoke test that
 # loads the built module and asserts snapshot replay is engaged. On tags
@@ -67,7 +67,8 @@ env:
 jobs:
   test:
     name: test (full corpus gates)
-    timeout-minutes: 45
+    # The full corpus plus lint/docs outgrew 45 minutes on a cold runner.
+    timeout-minutes: 90
     # Release PRs (release/* -> main, opened and admin-merged by
     # tools/release.sh in one step) run these gates like any other PR.
     # Skipping them costs less than it looks: the tag is pushed by the
@@ -98,6 +99,10 @@ jobs:
           rustup show active-toolchain
       - name: Formatting
         run: cargo fmt --all -- --check
+      - name: Generated semantic catalogs
+        run: |
+          python3 tools/semantic_catalog.py --check
+          python3 tools/operation_catalog.py --check
       - name: Run the full test suite
         run: cargo test --release
       - name: Clippy
@@ -108,17 +113,12 @@ jobs:
         env:
           RUSTDOCFLAGS: -D warnings
         run: cargo doc --no-deps
-      - name: Generated libraries (strict check against the stdlib, canonical formatting)
-        # The committed files are checked as candidates: SYSMLV2_AMBIENT=off
-        # keeps the toolkit's built-in copies out so they cannot collide.
-        run: |
-          SYSMLV2_AMBIENT=off cargo run --release -p sysmlv2-cli -- check --strict --lib spec-refs/SysML-v2-Release/sysml.library local-packages/Web.sysml local-packages/Template.sysml local-packages/Svelte.sysml local-packages/WebApp.sysml local-packages/SvelteKit.sysml
-          cargo run --release -p sysmlv2-cli -- fmt --check local-packages/Web.sysml local-packages/Template.sysml local-packages/Svelte.sysml local-packages/WebApp.sysml local-packages/SvelteKit.sysml
-      - name: Ambient libraries resolve without naming files
+      - name: Ambient library (strict candidate check; resolves without naming its file)
+        # SYSMLV2_AMBIENT=off keeps the built-in copy out of the candidate
+        # check so the two cannot collide.
         run: |
-          # Qualified element kinds: an `Elements::*` import would bring the
-          # `<template>` element kind into scope and shadow the `Template` package.
-          printf 'package V { part shell : Web::HTML::Elements::Div { :>> id = "app"; } part t : Template::Text; part k : Svelte::KeyBlock; part a : WebApp::Application; part r : SvelteKit::RouteSegment; }\n' > /tmp/ambient.sysml
+          SYSMLV2_AMBIENT=off cargo run --release -p sysmlv2-cli -- check --strict --lib spec-refs/SysML-v2-Release/sysml.library local-packages/TransformMeta.sysml
+          printf 'package V {\n    #TransformMeta::Generated part def G;\n}\n' > /tmp/ambient.sysml
           cargo run --release -p sysmlv2-cli -- check --strict --lib spec-refs/SysML-v2-Release/sysml.library /tmp/ambient.sysml
 
   msrv:
@@ -166,14 +166,23 @@ jobs:
           rustup show active-toolchain
       - name: Clippy (wasm32)
         run: cargo clippy --release -p sysmlv2-wasm --target wasm32-unknown-unknown -- -D warnings
+      # The CLI's wasi branches compile for no other target, so the
+      # native clippy runs never see them. The features are the ones
+      # build.mjs ships the CLI with; change the two together.
+      - name: Clippy (wasi CLI — the features build.mjs ships)
+        run: cargo clippy --release -p sysmlv2-cli --no-default-features --features solve,viz --target wasm32-wasip1 -- -D warnings
       - name: Install wasm-pack
         # Pinned release binary. The rustwasm.github.io installer script
         # is stale (the project moved to drager/wasm-pack) and serves
-        # 0.13.1 forever; old release URLs redirect to the new repo.
+        # 0.13.1 forever; old release URLs redirect to the new repo. Its
+        # pin also pins the optimizer: the binaryen release it fetches to
+        # optimize the module is the wasm-opt build.mjs runs on the CLI.
         run: |
           v=0.15.0
-          curl -sSfL "https://github.com/rustwasm/wasm-pack/releases/download/v${v}/wasm-pack-v${v}-x86_64-unknown-linux-musl.tar.gz" | tar xz
-          mv "wasm-pack-v${v}-x86_64-unknown-linux-musl/wasm-pack" "$HOME/.cargo/bin/"
+          tool_dir=$(mktemp -d)
+          trap 'rm -rf "$tool_dir"' EXIT
+          curl -sSfL "https://github.com/rustwasm/wasm-pack/releases/download/v${v}/wasm-pack-v${v}-x86_64-unknown-linux-musl.tar.gz" | tar xz -C "$tool_dir"
+          mv "$tool_dir/wasm-pack-v${v}-x86_64-unknown-linux-musl/wasm-pack" "$HOME/.cargo/bin/"
           wasm-pack --version
       # The runtime the smokes run under is pinned, not inherited. The
       # image's own Node 22 on x86_64 faults inside its WASI host on this
diff --git a/CBOR.md b/CBOR.md
index 14e7908..fe8ae41 100644
--- a/CBOR.md
+++ b/CBOR.md
@@ -35,6 +35,35 @@ Which payload kind it is lives in the body's own header flags, never in the name
 
   The type is unregistered vendor-tree for now; register it (and the application tag) before any public service exposes them.
 
+## Selecting a graph contract
+
+Existing codec functions continue to stamp scheme 2. For canonical compact
+snapshots use `to_compact_cbor_with_format`,
+`to_compact_cbor_explicit_with_format`, or
+`to_compact_cbor_elided_with_format`; use `to_full_cbor_with_format` for full
+emit views. Full encoding carries the caller's declared format and does not
+certify semantic conformance.
+
+`from_cbor_with_format` returns a compact document, unit paths, and its format.
+`graph_format` reads header metadata without walking the payload; it is not a
+payload validator. `assert_graph_format` checks a receiver's selected contract.
+Legacy explicit-ID stamps retain historical compatibility; unknown elided stamps
+are refused. A resolver artifact must pass `assert_compatible_with_format` before
+use with the selected contract.
+
+Deltas select the contract with `DeltaOptions::with_graph_format`; base and target
+must already use that contract. Deltas are not an identity migration. Retain the
+header's format alongside the returned JSON when using the generic apply APIs.
+Sessions select the header automatically when encoding and reject incoming
+snapshots or deltas whose header format differs from their library context.
+Explicitly format-aware sessions also enforce conditional and constructor JSON shapes at their
+boundaries. Historical legacy constructors and scheme-2 snapshot loading retain
+their foreign-graph recovery/warning policy. Opening a compact
+snapshot with `Session::from_compact_cbor` restores its recorded format. Scheme 2
+does not serialize the stricter JSON-boundary policy selected by an explicit
+LegacyV2 constructor; reopening it uses historical legacy recovery. JSON-only
+consumers must pass the format explicitly when rebuilding a session.
+
 ## Layout
 
 ```
@@ -77,7 +106,7 @@ Where the bytes go, relative to compact JSON:
 
 - **layout (u8)** — the array shapes, presence encoding, reference index spaces, and delta framing. Refused unconditionally on mismatch.
 - **tables (u16)** — the generated metamodel tables (type codes, field ordinals, kinds, defaults; currently from the 20250201 normative release). Refused on any decode, since every element record reads through them — but independently of layout, so a tables-only regeneration is diagnosable as exactly that.
-- **scheme (u8)** — the id-derivation scheme (`IDS.md`; wire scheme 1 is that document's graph-derived derivation). Consulted **only** where derivation is in play (id-elided payloads, snapshot or delta): explicit-id payloads decode regardless of it. Digest failures on matched-scheme payloads therefore come pre-diagnosed: not a scheme skew, so library skew or corruption.
+- **scheme (u8)** — the lowering/identity contract (`IDS.md`): 2 is the default legacy graph; 3 is opt-in canonical lowering. Both use graph-derived identities. Elided snapshots and deltas accept these supported schemes; scheme 3 compact snapshots and applied deltas also validate their authored conditional and constructor shapes. Generic explicit-ID decoders retain historical scheme compatibility, but format-aware sessions require their selected contract. Digest failures on matched schemes indicate a different library context or corruption.
 
 **Flags.** `elideIds` (1), `fullForm` (2), `delta` (4), `deltaPortable` (8), `unitPaths` (16), `impliedOwners` (32), and `explicitIds` (64): a compact snapshot whose ids are not all the graph derivation of `IDS.md` — a session that loaded a document from another producer, or under other unit names, keeps the ids it was given and marks the payload so a receiver never re-derives them; such a session refuses id elision. Informational for decoders, which always read the id table; `describe` reports it as `explicitIds`.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c628350..5fb00d6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,126 @@
 # Changelog
 
+## v0.10.0
+
+### Added
+
+- Checked property access in Rust, Python, and WebAssembly, with consistent scalar and collection shapes, defaults, enumeration values, and reference types. Rust `derived_exact` rejects approximate or unavailable answers instead of presenting them as exact.
+- Generated property and operation declaration catalogs for SDK generators, including declaration identities, overrides, parameter types, and multiplicities. Rust can invoke supported operations by declaration identity.
+- Strict full-form JSON export in Rust, Python, and WebAssembly, with checks for property fidelity, unique element IDs, and local-reference closure. Missing semantic evidence reports an error instead of producing placeholder values.
+- Checked Rust reports for type features, inputs and memberships, specialization, featuring, variability, end constancy, model-level evaluability, and collection cardinality. Unsupported or incomplete cases remain explicitly qualified.
+- Checked `Definition.usage` and `Definition.directedUsage` include supported inherited usages. Checked Usage typing now covers ordinary noncomposite usages and composite occurrence, item, and part usages in supported structural and nested usage contexts; nested compositions require a complete owner type proof. Missing specialization paths, cycles, unsupported contexts, and exhausted budgets still report incomplete evidence.
+- Evaluation reports that retain failures suppressed by inherited-default fallback, including the declaration, receiver, and underlying cause. Existing result-only evaluation remains available.
+- Opt-in `CanonicalV3` graphs in Rust, with owned conditional operands, constructor results, and supported expression bindings, typing, and implied relationships. Format-aware sessions, prepared libraries, snapshots, resolvers, and deltas preserve the selected graph contract; an explicit migration API reports changed identities.
+- Editor member completion after indexed values, invocations, qualified and global receivers, conjugated port types, and quoted names after a dot. Member completion follows the source dialect and offers the `metadata` keyword after eligible receivers.
+- Editor completion on `[` in unit positions, with units compatible with the declared quantity listed first. Names can also be completed inside multiplicity bounds and filters.
+- Editor completion after a qualifier lists what the namespace re-exports, so `ISQ::` offers `MassValue`. Import paths offer `*` and `**` after a qualifier and rank packages ahead of their members.
+- Editor signature help for calculation, function, and constraint invocations, including calls on a feature chain (`vehicle.ke(`), with standard-library types spelled where the call is read and the active parameter chosen by position or by name, and a quick fix that removes a stray `;`.
+- Editor completion that follows the position being typed. A typing offers the definitions its usage kind admits, a specialization offers its own kind first, redefinitions and successions offer the enclosing element's features first (including a library base's `start` and `done`), metadata positions offer metadata definitions, a Boolean value offers `true` and `false` first, and units rank first where the declared type is a unit type. Shorter names rank first within a group. The enclosing element's features carry their documentation and their own kind, as the same names do everywhere else.
+- WebAssembly `LspServer.withPreparedLibrary` and Rust `PushServer::with_library` build a language server on a prepared library, so a session normally reuses the library's prepared resolution instead of re-parsing the library's sources and rebuilding its graph.
+- The npm package includes `stdlib/sysml-library.prepared.gz`, a prepared standard-library graph. WebAssembly `PreparedLibrary.fromSnapshot` and Rust `Library::prepared_snapshot` load it without resolving the library at startup or retaining its parsed syntax trees. Incompatible snapshots are rejected so the caller can prepare from source.
+- WebAssembly `PreparedLibrary.fromSnapshotStream` reads a snapshot from the host's `Uint8Array` in chunks instead of copying the whole snapshot into module memory. Rust `PreparedLibrary::from_chunks` and `Library::prepared_snapshot_chunks` expose the same chunked loading, including checksum verification.
+- WebAssembly `Session.settledOutcomes` and `Session.fromSourcesSettled` start a session on a prepared library from the outcomes a previous session settled on, as the language server's sessions do after every edit: a unit that resolves as it did is confirmed in one pass. The outcomes are a handle of their own, so a host frees the previous session before building the next, and the session answers as one built without.
+- Text reports from `check`, `lint`, and parse errors mark each finding's span with carets on the line below its source line.
+- Rust `LibraryCache::graph_format` reports the graph format a library resolution recording was made for.
+- Constraint verification names a usage that is a collection only by the implicit default (an attribute, item or port a package owns, written without a multiplicity, subsetting or redefinition) and says to declare `[1]` for one value, instead of reporting a non-scalar or unknown cardinality. A parameter, connector end, reference usage or explicitly open multiplicity keeps the cardinality wording.
+
+### Fixed
+
+- A view-directed diagram (`viz --element` naming a view, or the WebAssembly `toGraph` and `toPlantuml` given one) no longer draws the members a view exposes through inheritance as nodes of their own. A part's exposed members include the ones it inherits, so `expose rig::**;` over `part amp : Amp;` also exposes the ports `Amp` declares; they render once, on `amp`'s box, rather than again as standalone port boxes. Likewise, `expose rig::*;` no longer draws a node for every feature `rig` inherits from the standard library.
+- Intrinsic evaluation dispatches by resolved standard-library identity. Aliases work, while user declarations, inaccessible functions, and unrelated names no longer acquire intrinsic behavior by spelling alone.
+- ID-bound references participate consistently in semantic queries, evaluation, checks, filters, and solving. Source-document and declaration identities survive lookup, replay, and symbolic translation.
+- Imported and inherited members retain their membership identities, order, visibility, and alias provenance. Import distinguishability, redefinition hiding, and recursive package lookup respect the lookup context; bounded queries report incomplete expansion instead of silently truncating it.
+- A parameter, end or result inherits the members of the feature its position pairs it with in its owner's generals, as the redefinition KerML implies reads: `in q;` declared first under `action def Swapped :> A { in q; in p; }` offers the members of `A`'s first parameter, `in x;` under a specialization whose general names it `p` offers them too, `return s;` offers those of the general's result, and `end f1;` those of the general's first end. A directed parameter used to take the members of the *same-named* feature its owner inherits — and, where no general declared one, of any element of that name in an enclosing package, an imported one, or the root namespace — while a renamed parameter, a result and an end inherited nothing. The derived `type` of a feature redefined only by position follows that redefinition when its target is a user feature (`Swapped::q` is typed as `A::p` is); implied redefinitions of library features stay out of `type`, with the implied library subsettings.
+- A build that replays a library resolution snapshot resolves again every library reference that a workspace's root names can change, including one that reached a missing root name only through what resolving another reference computed: a type's specialization bases, a namespace's imports, or that reference's own outcome. Such a reference used to keep its recorded outcome, so an inherited member's type could stay unresolved after the workspace imported the base that declares it.
+- A namespace's imports and a type's specialization bases resolve the same way whichever reference first needs them. A namespace import whose target is visible only through a sibling membership import (`import X::*; private import Other::X;`) could stay unresolved, together with the names it imports.
+- A redefinition in a type with explicit generals resolves in those generals, in the order they are written, in every model. Without a library it used to resolve in the declaring type unless other content in the model enabled that rule, so redefining a general's private feature was reported as a blocked reference and a feature found in two generals as ambiguous.
+- A build that replays a library resolution snapshot, or builds on a prepared library, resolves library references as a cold build does when the workspace adds a root import, or when only the workspace's content makes resolution consult redefinition headers and inherited members in later passes. Such a build could keep outcomes from resolving the library alone, such as a redefinition of a sibling feature instead of the general's.
+- Required implied specialization paths remain reachable. Supported generated relationships and positional end, parameter, and result redefinitions are published consistently across semantic queries and export, with prerequisites checked before publication.
+- Feature, Step, and Metaclass lookup follows their required standard-library bases, exposing inherited members such as `that` and `annotatedElement`. Step and binary connection roles require unique, correctly typed canonical library identities; unrelated declarations or duplicate identities cannot supply them.
+- Connection and interface definitions with exactly two owned ends inherit their binary library members during lookup, so end redefinitions resolve `source` and `target` and unnamed ends recover their inherited names. Inherited ends alone do not trigger an additional binary base.
+- KerML flows and successions use their own required library bases instead of SysML usage bases; the more specific flow bases are added only when their owned-end conditions hold. Composite usages retain the required subobject, suboccurrence, subitem, and subpart specialization paths in supported owning contexts.
+- Literal, null, metadata-access, reference, and invocation results use the appropriate library and declaration identities. Generated feature defaults, result bindings, and local featuring no longer depend on placeholder relationships.
+- Connector end names resolve in their owning scope. Generic relationship endpoints agree with connector-specific properties, ordered repeated endpoints are preserved, and authored featuring and end-constant defaults retain their meaning.
+- Connector-end multiplicity bounds resolve declarations in the connector body without changing the scope of end targets. An owned cross feature's specialization and multiplicity references resolve in its owning end's scope, including members inherited through that end's type; missing or ambiguous members remain unresolved.
+- Explicit metadata `about` associations participate in annotations, reflection, and filters alongside prefix metadata. Exposures preserve their membership and filter identities.
+- Anonymous feature chains no longer take the final target's name. Contextual naming follows the semantic declaration.
+- Semantic namespace lookup excludes anonymous reconstruction locators, so they cannot hide or conflict with declared members. Unresolved-reference reports now include ambiguous references as well as missing ones, with their source spans.
+- Full-form export preserves semantic reference targets and fills absent owned scalar properties from their declared defaults, while retaining explicitly supplied values and computed end flags. `ConjugatedPortTyping.portDefinition` returns the original port definition as a single reference. Structural ownership reads follow published relationships consistently in both graph formats.
+- Interchange round trips and edits preserve owned expression graphs, anonymous payload identities, source dialects, supplied IDs, and lexical references that resemble UUIDs. Edits that cannot preserve semantic identity fail without changing the session.
+- Cardinality uses exact integer bounds from headers, body and named multiplicities, and inherited declarations in the receiver's context. Implicit usage multiplicities are honored; conflicting, cyclic, or unsupported bounds remain unknown.
+- Collection size, emptiness, and indexing preserve the distinction between known cardinality and known values. Unknown members and positions remain unknown through chains, tuples, casts, and solver translation.
+- Runtime arguments bind to parameter identities. Defaults and nested calls retain the correct receiver and visibility instead of capturing unrelated caller parameters with the same name.
+- Invoking a calculation that specializes another binds the arguments to the parameters it declares, then to the inherited parameters none of its own redefine, in the order its generals are written. Only the nearest type declaring parameters used to supply them: with `calc def Diff { in a; in b; return r = a - b; }` and `calc def Sub :> Diff { in x; }`, `Sub(10, 3)` was rejected as having too many arguments and now evaluates to `7`. A calculation with no result of its own evaluates the nearest result its written heritage declares instead of evaluating as indeterminate, while a function-typed parameter still stands for an unknown calculation. As KerML requires, a parameter that explicitly redefines another also redefines the general's parameter at its own position, so `calc def Swap :> Diff { in :>> b; }` takes one argument, which both `a` and `b` stand for; a parameter that merely reuses an inherited name at another position hides nothing, so `calc def Partial :> Diff { in b; }` has two parameters of one name, which the namespace-distinguishability check now reports, no invocation can bind by name, and a name finding both inside a specialization leaves ambiguous rather than shadowed. A general's parameters are its own, then those it inherits after them, so a specialization's parameters pair with inherited ones too: `calc def C :> B { in s; in t; }` over `calc def B :> A { in r; }` and `calc def A { in p; in q; }` has the two parameters `s` and `t`, `t` standing for `q` (it used to have three, `q` still inherited), and `do 'sense temperature' { out temp; }` under an action usage that declares no parameters of its own redefines the one its definition declares. A parameter that redefines one feature by name and another by position (`calc def KE3 :> KineticEnergy { in speed redefines v; }`, whose `speed` also stands for the first parameter, `m`) inherits two measurement references; the unit bracket of an argument binding it measures the quantity the written redefinition spells. The invocation arity check and editor signature help read the same parameters, and Rust `ResolvedModel::callable_parameters` lists them, inherited through written generals, reference subsettings, and the implied library bases alike, without the model-wide positional plan: a requirement without a subject of its own lists its library base's, and a performed action the parameters of what it performs.
+- Solving and interval propagation inline a calculation's inherited result as evaluation does: a calculation that declares none takes the nearest one its written heritage declares, read in its own context, so a constraint on `Sub(y, 3)` with `calc def Sub :> Diff { in x; }` constrains `y` instead of staying unknown. Rust `ResolvedModel::callable_body` answers which result an invocation evaluates and which callable declares it.
+- A calculation whose generals, equally near, each declare a result evaluates to their common value: every inherited result binds the one result. It used to be unsupported outright; results that differ remain unsupported.
+- Multiplicity checks compare bounds without precision loss and diagnose ranges invalidated by receiver values. Solver propagation requires sound evidence before reporting a positive result when definitions are approximate.
+- Redefinition diagnostics require complete provenance, explain targets outside the inheritance chain, and distinguish fixed binding overrides from defaults. Queries through an untyped redefining part use that part's value rather than its owned parts.
+- Views inherit their rendering from their definition or specialized views, with an owned rendering taking precedence and inherited choices following heritage order. In-place and chained renderings are reported by Rust, WebAssembly `viewInfo`, and view-directed diagrams.
+- Qualification minimization handles feature-chain member references and no longer shortens a member import through its own target.
+- A `;` where an expression belongs is reported as the missing expression, at the `;`, and still ends the declaration: `attribute x = ;` is reported at its `;` rather than at the next token, and `attribute x = ;;` is no longer accepted with the first `;` taken as an empty value. This applies after `=`, `:=`, and `default`, to an operand, and to a collect, select, or `->` body. SysML no longer reads a bare `;` as an expression body, which KerML never did, so a stray `;` just before a closing `}` is reported by the parser as well: it used to parse as an empty result expression, which only the body-context check rejected, and which a calculation body took as its result.
+- Editor completion recovers usable declarations from incomplete sources, including missing terminators and unmatched closers. An unresolved member-access receiver no longer produces unrelated global suggestions. Import memberships are omitted from completion and workspace symbol search; operator functions are omitted from unqualified completion but remain available after a qualifier. Workspace symbol search no longer lists anonymous members by their outline placeholders (`«part»`, `«subject»`), and still finds the named members inside them.
+- A member that cannot be read no longer takes its whole document out of editor completion. Recovery blanks only that member, including a value left out, a line that ends mid-expression, and a declaration cut off at the end of the text, so member access and inherited members keep working while an unrelated statement is broken.
+- Accepting an editor completion no longer appends a statement terminator. Insert and replace ranges cover whole words and quoted names while preserving bracket repairs; multi-word matching handles Unicode and incomplete quotes without keeping stale suggestions open after a space.
+- Editor automatic imports and import quick fixes name the conventional re-exporting package (`ISQ::MassValue` rather than `ISQBase::MassValue`) and are omitted when an existing import already provides the name through a re-export. Ambiguous, filtered, and private re-exports are never offered or imported through, so inserted imports resolve, and a workspace's private members are offered only where they are visible. Aliases complete with the kind of the element they name, and metadata definitions no longer complete as keywords.
+- A `;` after the result expression of a calculation, constraint, case, or function body is reported at the `;`, and the expression stays the body's result. A conditional result followed by `;`, previously read as a second, empty result, is now reported.
+- Editor completion offers nothing inside comments, strings, and numbers, and only keywords where a declaration's own name is typed. Each document gets only its own dialect's keywords. Statement boundaries are read from tokens, so a `;`, `{`, or `}` in a comment or string no longer splits a statement, and completion and signature help cut the same statement.
+- Unit completion and inferred attribute typing use token-aware context, including comments, user-defined quantity types, parameters, and reference units. A unit infers an attribute's type only when it qualifies the whole value, and an untyped attribute's name is not mistaken for a keyword.
+- Editor hover on a standard-library callable shows its parameter and return types instead of bare parameter names, and every callable's signature shows a declared multiplicity other than one (`sum(collection: Real[0..*]) → Real`).
+- Editor signature help and hover list a callable's inherited parameters after its own — for a definition specializing a callable, or a usage typed by one — with a redefined parameter replaced by its redefinition and each parameter shown with its written type.
+- Editor signature help and unit brackets read an invocation's arguments as its inputs, in order, as evaluation binds them: an output declared among the parameters takes no argument's place, so `f(1, |` for `calc def f { out o; in x; in y; }` highlights `y`, and naming an output highlights nothing.
+- Editor hover, go-to-definition, and document highlights answer while a document has a syntax error, reading the workspace with its broken members recovered the way editor completion reads it. References, rename, code actions, and refactorings still wait until every document parses.
+- Recovery of incomplete sources ends a string, quoted name, comment, or note left open at its own line, telling the literal left open from those written across lines, so the members after it stay usable. A declaration whose header does not parse (`package Fo}o {`, `part def X :> {`) keeps its body's members.
+- Editor unit completion ranks units by the quantity the bracket's context names wherever it names one: a comparison or arithmetic operand (`mass <= 1500 [`), the unit another operand carries (`1200 [kg] + 300 [`, including a model's own units), and the parameter a call argument binds, declared or inherited (`KineticEnergy(1500 [`). An operand read on a measurement scale names no quantity for the difference compared with it or added to it (`t1 + 5 [`). The bracket's statement is read where completion starts it, so a body passed as an argument no longer ends the statement, and signature help finds a call typed below a quote left open on an earlier line.
+- Editor completion offers a member of a type wherever its simple name finds it: inside the elements its owner types or specializes, at any depth and innermost first, and where an import, a re-exporting package, or a recursive import brings it in. It is no longer offered by that name where the name finds nothing or another element, and a statement is not offered the names it declares ahead of the cursor.
+- Editor completion follows the namespace rules for imports and names. An alias whose target another document or the library declares completes and ranks as that element. `import all` brings in every member. A private or protected member no longer hides what a namespace's public imports bring in for its clients, and a member of a private namespace is offered only where it resolves. A scope's imports are judged together, so a name two imports make ambiguous comes with an import that settles it. A usage without a name of its own is found by the name of what it redefines or references.
+- Editor automatic imports no longer take a name from references already in the document: where a name finds an element, that element is offered without an import. An inserted import whose first segment another element takes at the insertion point is written from the root (`private import $::Requirements::requirementChecks;`), and restricted names are quoted in the import's annotation.
+- Editor unit completion keeps a document's own units, and accepting one declares its quantity type, when another open document declares a package of the same name.
+- Editor completion classifies a qualified name by the position it stands in: `attribute x : ISQ::` lists definitions first, and `[SI::` in a unit bracket lists only units, ranked by the declared quantity and without import edits.
+- Editor completion offers `then` after an accept in an action body and after an accept's payload type. After a payload it also offers the port (`via`) and, in a transition or a state body, the guard and the effect not yet written. At redefinitions, subsettings, and references the statement's own kind ranks ahead of the kinds specializing it, which stay offered (an individual item redefinition is offered the part its definition declares). A compound keyword (`perform action`, `exhibit state`, `include use case`, `satisfy requirement`, `assert constraint`, `event occurrence`) counts as its specific kind at a redefinition, while subsettings and references rank the plain kind first.
+- Corrected copyright and third-party license notices. The npm package includes the bundled standard library's license and notices.
+- Text reports show at most 160 characters of a finding's line, taken around the finding with `…` at each cut, instead of the whole line. A model written on one long line used to produce a report the size of its findings times its line: 960 findings on a 12 KB line wrote 12 MB of text, and now write 0.3 MB.
+- A build that rejects a stale library resolution snapshot records a fresh one in the same build, where it used to leave that to the next build.
+- Overriding a prepared library element's ID rebuilds the identity indexes that previously retained its old ID. Shared structural indexes also account for workspace rows that claim library rows or satisfy previously unresolved library references.
+- Shipped WebAssembly and WASI modules remap build-machine checkout and Cargo-home paths, keeping absolute local paths out of panic locations and debug paths.
+
+### Performance
+
+- Reused revision-bound identity and structural indexes, inherited lookup snapshots, and positional traversal storage to reduce repeated graph scans and allocations. Interchange lifting reuses its validated identity index.
+- Structural and implied-relationship proofs reuse complete sparse candidate lists instead of scanning unrelated rows repeatedly, keeping large-library checks within the existing work budget while preserving ownership and stale-evidence checks.
+- Editor completion parses each source unit once and resolves once per session build. Unit classification and request-level token, bracket, quote, and repair scans are reused.
+- Editor completion caches import routes per namespace, rebuilds only the edited document's symbols, and lists re-exported members without their documentation.
+- Editor completion answers each position with its own candidates instead of the whole vocabulary, and caches an element's inherited members by the text around its body.
+- Editor member access, unit brackets, and signature help reuse a model already built for other text when nothing they read has changed, so starting a new statement no longer rebuilds the model.
+- Editor completion resolves an alias's target one name at a time when first needed, judges names at the cursor without copying their paths, and asks once per top-level name whether an import starts at the root. Signature help lexes the text ahead of a call once.
+- Reference properties are written as references and the enumeration-valued strings the builder writes most are shared, instead of each being built as an interchange object and parsed back on insert: Apollo session builds 82 → 78 ms cold and 59 → 55 warm, the Vehicle example 48 → 45 cold.
+- Session builds on a prepared standard library keep its lookup graph across resolution passes, and builds with a sealed library snapshot take the recorded library targets in every pass instead of resolving the library again. Library resolution snapshots record whether they hold the library's converged resolution (snapshot format 8).
+- A root-level import of a user namespace no longer forces the standard library to be resolved together with the workspace when that namespace's own imports are private or protected.
+- The structural index behind metadata associations and the structural checks is no longer rebuilt over a prepared library's rows for every reference-resolution pass: the library's rows are scanned once when it is prepared, and a build on it scans only its own rows. A five-unit Vehicle example workspace with metadata annotations builds about 30% faster on a prepared standard library; a 252-unit corpus workspace about 11%.
+- Reference resolution keeps the lookup graph its confirming pass read instead of recomputing the metadata associations and building the graph once more after it: a one-file session on a sources-plus-snapshot standard library builds about 10% faster, prepared-library sessions up to 3%.
+- A session on a prepared standard library no longer tables the library's rows to assign its own elements' identities: a one-file session builds in about a tenth of the time, a five-unit Vehicle example workspace about 12% faster.
+- A session built over the units a previous session resolved starts from the outcomes that session settled on (`Session::from_sources_settled`, `Session::settled_outcomes`), as the language server's sessions now do after every edit: where the edit changed no outcome the build confirms them in one pass instead of resolving from nothing, and otherwise carries the edit's consequences through as many passes as they take. A five-unit Vehicle example workspace rebuilds in 37 ms instead of 56 after a comment, a 252-unit corpus workspace in 194 instead of 539. Answers are those of a session built without.
+- A build keeps its element index by id across its resolution passes and, on a prepared standard library, tables only its own rows into it, and the library name tables its identity assignment may read are made once per prepared library: session builds about 7% faster on a five-unit workspace, 5% on the 252-unit corpus workspace.
+- Name lookups hash their tables by a cheaper fold, share a scope's cached import list instead of copying it per lookup, and keep a recursive import's sub-scope lists for a pass: session builds about 13% faster on a five-unit workspace, 14% on the 252-unit corpus workspace, 16% on the Apollo model.
+- A library prepared from in-memory sources keeps the resolution snapshot it was prepared with, or records one while preparing when the snapshot is unusable, so a session that must resolve the library together with its workspace takes that recording: a workspace root name that completes a library miss replays the library's recorded resolution instead of resolving the library again, and a root filter keeps the recording's element identities while resolving the library's references again.
+- `check` locates its findings in one pass over the model's ownership, so its time no longer grows with the square of how deeply an expression nests.
+- A model build keeps each element's ownership path, and the hashing that derives the element's identity from it, incremental over its owner's, so the time and memory of a build no longer grow with the square of its nesting depth. Element identities are unchanged. Checking one value spelled as a 960-term `and` chain took 2.7 s and 365 MB and now takes 0.05 s and 29 MB.
+
+### Removed
+
+- Rust `ResolvedModel::calc_params`, which listed only the input names a calculation declares itself. `calc_parameter_bindings` lists every input an invocation binds, inherited ones included, with its declaration.
+- The `render` command, view template renderer, and WebAssembly `renderView` method. View information and view-directed diagrams remain available.
+- The ambient `Web`, `Template`, `Svelte`, `WebApp`, and `SvelteKit` libraries, and the generator-only `pkg-node/stdlib-core` npm build artifact. User packages with those names are no longer shadowed; `TransformMeta` remains ambient.
+- Evaluation of Web DOM navigation members and template slots over imported documents.
+
+### Upgrade notes
+
+- `LegacyV2` remains the default graph format. `CanonicalV3` is opt-in and has been revised in place; regenerate earlier canonical artifacts from source. The migration API converts complete legacy graphs with graph-derived IDs. Regenerate library snapshots and resolvers when changing formats; deltas do not migrate element identities.
+- The default ID scheme changes from 1 to 2, changing freshly derived IDs for affected features and their descendants; persisted explicit IDs are preserved. Regenerate standard-library resolver artifacts. Scheme 1 ID-elided snapshots and deltas are no longer accepted; use an earlier toolkit to export explicit IDs before upgrading. CBOR scheme 3 carries canonical graphs, and format-aware readers reject incompatible artifacts.
+- Checked properties, operations, and strict export cover supported semantic cases, not every specification derivation. Type-dependent properties no longer claim exact fidelity without complete evidence. Callers must handle typed refusals; best-effort readers remain available, and strict export is not a whole-model conformance check.
+- The syntax tree's `ExprKind::BodyTerminator` variant is removed. The parser no longer reads a bare `;` as an expression body, so nothing produced it; drop matches on it. An empty expression body is `ExprKind::Body` with no members.
+- Evaluation no longer takes every feature to be single-valued. A feature without a declared multiplicity takes the bounds shared by the features it subsets or redefines (a parameter or connector end also those it redefines by position; a bound that cannot be determined leaves it unknown). Failing those, attribute, item, part, and port usages owned by a definition or usage are `[1]`, and every other feature is `[0..*]`: usages a package owns, reference usages (including parameters written without a keyword, `in x : Real;`), and action, occurrence, requirement, and connection usages. A tuple containing such a feature, or a chain through one, now evaluates as indeterminate; declare `[1]` where a single value is intended for evaluation or solving.
+- Text reports add a caret line under each finding's source line. Tools that read findings should use `--format json` rather than parse the text.
+
 ## v0.9.1
 
 - Added summary mode for large tree graphs: collapsed containers report hidden element counts, references to hidden elements are grouped with counts, and excess notes are counted on their targets.
diff --git a/CLI.md b/CLI.md
index 868e309..1e64e7c 100644
--- a/CLI.md
+++ b/CLI.md
@@ -92,36 +92,43 @@ error: an import must declare an explicit visibility (`public`, `private`, or `p
   --> broken.sysml:2:5
    |
    |     import Definitions::*;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: a transition usage is not allowed in a definition or usage body
   --> broken.sysml:5:9
    |
    |         transition first parked then driving;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: validateSubjectMembershipOwningType: a `subject` member is not allowed in a definition or usage body
   --> broken.sysml:6:9
    |
    |         subject v;
+   |         ^^^^^^^^^^
 
 error: a `variant` member is only allowed in the body of a `variation` definition or usage
   --> broken.sysml:9:9
    |
    |         variant part manual;
+   |         ^^^^^^^^^^^^^^^^^^^^
 
 warning: unresolved reference `Definitions`
   --> broken.sysml:2:12
    |
    |     import Definitions::*;
+   |            ^^^^^^^^^^^
 
 warning: unresolved reference `parked`
   --> broken.sysml:5:26
    |
    |         transition first parked then driving;
+   |                          ^^^^^^
 
 warning: unresolved reference `driving`
   --> broken.sysml:5:38
    |
    |         transition first parked then driving;
+   |                                      ^^^^^^^
 
 3 warning(s)
 4 error(s)
@@ -129,6 +136,8 @@ $ echo $?
 1
 ```
 
+Each finding shows its line with carets under the span it reports. A line longer than 160 characters shows 160 of them, up to a third before the finding, with `…` where it was cut, so a model written on one line reports at a bounded cost per finding. The location keeps the finding's column in the whole line.
+
 The legality matrix is transcribed from the normative Xtext grammars' `*BodyItem` rules and is gated at zero false positives over all 345 corpus files (`tests/check.rs`).
 
 ### Referential checks (`--lib`)
@@ -156,26 +165,31 @@ warning: unresolved reference `Missing`
   --> refs.sysml:3:20
    |
    |     private import Missing::*;
+   |                    ^^^^^^^
 
 warning: unresolved reference `Vel`
   --> refs.sysml:7:27
    |
    |         attribute speed : Vel;
+   |                           ^^^
 
 warning: alias target `Vehicel` does not resolve
   --> refs.sysml:9:17
    |
    |     alias v for Vehicel;
+   |                 ^^^^^^^
 
 warning: circular namespace import: `B` transitively imports this namespace back
   --> refs.sysml:10:31
    |
    |     package A { public import B::*; }
+   |                               ^
 
 warning: circular namespace import: `A` transitively imports this namespace back
   --> refs.sysml:11:31
    |
    |     package B { public import A::*; }
+   |                               ^
 
 5 warning(s)
 $ echo $?
@@ -201,11 +215,13 @@ warning: root package `Requirements` shadows the standard library package `Requi
   --> shadow.sysml:1:9
    |
    | package Requirements {
+   |         ^^^^^^^^^^^^
 
 warning: unresolved reference `Requirements::Speed`
   --> shadow.sysml:5:21
    |
    |     requirement s : Requirements::Speed;
+   |                     ^^^^^^^^^^^^^^^^^^^
 
 2 warning(s)
 ```
@@ -235,31 +251,37 @@ error: `Cyclic` cannot specialize itself
   --> sem.sysml:3:24
    |
    |     part def Cyclic :> Cyclic;
+   |                        ^^^^^^
 
 error: circular specialization: this definition transitively specializes itself
   --> sem.sysml:4:19
    |
    |     part def A :> B;
+   |                   ^
 
 error: circular specialization: this definition transitively specializes itself
   --> sem.sysml:5:19
    |
    |     part def B :> A;
+   |                   ^
 
 warning: duplicate specialization of `Wheel`
   --> sem.sysml:6:29
    |
    |     part def Cart :> Wheel, Wheel;
+   |                             ^^^^^
 
 error: multiplicity lower bound 5 exceeds upper bound 2
   --> sem.sysml:8:25
    |
    |     part wheels : Wheel [5..2];
+   |                         ^^^^^^
 
 error: multiplicity upper bound is negative
   --> sem.sysml:9:24
    |
    |     part spare : Wheel [spares];
+   |                        ^^^^^^^^
 
 1 warning(s)
 5 error(s)
@@ -354,6 +376,7 @@ warning: definition name `spare_wheel` should be PascalCase [naming-convention]
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 1 warning(s)
 $ echo $?
@@ -368,21 +391,25 @@ warning: definition name `spare_wheel` should be PascalCase [naming-convention]
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: `spare_wheel` is never referenced in these units (closed world: outside consumers are not visible to lint) [unused-definition]
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: `Torque` is never referenced in these units (closed world: outside consumers are not visible to lint) [unused-definition]
   --> rig.sysml:5:14
    |
    |     calc def Torque {
+   |              ^^^^^^
 
 warning: input parameter `radius` of `Torque` is never used [unused-parameter]
   --> rig.sysml:7:12
    |
    |         in radius : Real;
+   |            ^^^^^^
 
 4 warning(s)
 ```
@@ -406,11 +433,13 @@ warning: `spare_wheel` is never referenced in these units (closed world: outside
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: input parameter `radius` of `Torque` is never used [unused-parameter]
   --> rig.sysml:7:12
    |
    |         in radius : Real;
+   |            ^^^^^^
 
 2 warning(s)
 ```
@@ -424,8 +453,15 @@ warning: `spare_wheel` is never referenced in these units (closed world: outside
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
-2 warning(s)
+warning: input parameter `radius` of `Torque` is never used [unused-parameter]
+  --> rig.sysml:7:12
+   |
+   |         in radius : Real;
+   |            ^^^^^^
+
+3 warning(s)
 ```
 
 Warnings exit 0; `error`-level findings exit 1, and `--strict` fails on any finding at all (infos and hints included):
@@ -436,11 +472,13 @@ warning: `spare_wheel` is never referenced in these units (closed world: outside
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: input parameter `radius` of `Torque` is never used [unused-parameter]
   --> rig.sysml:7:12
    |
    |         in radius : Real;
+   |            ^^^^^^
 
 2 warning(s)
 --strict: warnings are failures
@@ -458,11 +496,13 @@ warning: `spare_wheel` is never referenced in these units (closed world: outside
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: input parameter `radius` of `Torque` is never used [unused-parameter]
   --> rig.sysml:7:12
    |
    |         in radius : Real;
+   |            ^^^^^^
 
 1 deletion fix(es) available but not applied — deleting model text needs --fix --fix-deletes
 2 warning(s)
@@ -471,11 +511,13 @@ warning: `spare_wheel` is never referenced in these units (closed world: outside
   --> rig.sysml:3:14
    |
    |     part def spare_wheel;
+   |              ^^^^^^^^^^^
 
 warning: input parameter `radius` of `Torque` is never used [unused-parameter]
   --> rig.sysml:7:12
    |
    |         in radius : Real;
+   |            ^^^^^^
 
 fixed: rig.sysml
 2 warning(s)
@@ -574,6 +616,7 @@ rig.sysml:7:12 warn unused-parameter
 | `unused-parameter` | off | an input parameter of a calc / constraint / action definition never used in its body | deletes the parameter (`--fix-deletes`) |
 | `import-visibility` | info | an import without a visibility keyword — the syntax check reports the error, this finding carries the fix | declares the visibility its dependents need; the other keywords as alternatives |
 | `visibility-blocked-reference` | warn | an unresolved reference that names a member reachable only by ignoring visibility | widens the member to `public` (`--fix-semantic`) |
+| `redefinition-outside-inheritance` | warn | a bare redefinition resolving through an enclosing namespace instead of a member of its selected general; reports the actual target and, when unique, a possible nested part feature | — |
 | `usage-kind-mismatch` | info | a usage typed by a definition of another kind — the semantic check reports the error, this finding carries the fix | rewrites the usage keyword (`--fix-semantic`) |
 | `port-member-referential` | info | a composite non-port usage inside a port body | inserts `ref` |
 | `unqualified-enum-literal` | warn | an unresolved simple name matching exactly one enumeration literal | qualifies it |
@@ -588,6 +631,9 @@ rig.sysml:7:12 warn unused-parameter
 
 `--lib` supplies resolution context only (`dimensional-consistency` stays silent without the standard library's quantity types); library elements are never linted.
 
+`redefinition-outside-inheritance` is an authoring heuristic for owners with complete recorded explicit general contexts. It preserves intentionally imported or aliased members of the general, and skips qualified, unresolved and identity-spelled references. For example, `attribute :>> mass` can resolve to an imported quantity feature when the inherited vehicle has only `chassis.mass`. The warning names the target; it does not change the reference or insert `default`. To allow replacement of an inherited binding, `default` belongs on the earlier declaration that supplies that binding, not on the attempted override.
+
+
 ---
 
 ## 3. `fmt` — canonical formatting
@@ -707,16 +753,14 @@ Native directory loading saves a build- and content-identified `.prepared` snaps
 
 ### Ambient libraries
 
-Whenever a library loads, the toolkit's generated libraries load with it: `Web` (`Web::DOM`, `Web::HTML`, `Web::HTML::Elements` — the Web platform from the standards' WebIDL), `Template` and `Svelte` (the template metamodel and its engine overlay), `WebApp` and `SvelteKit` (the application and route/SSR layers) and `TransformMeta`. A model can reference them without naming their files:
+Whenever a library loads, the toolkit's ambient library loads with it: `TransformMeta`, the metadata vocabulary that generated elements and their provenance records are annotated with. A model can reference it without naming its file:
 
 ```console
-$ printf 'package V { private import Web::HTML::Elements::*; part shell : Div { :>> id = "app"; } }\n' > v.sysml
+$ printf 'package V {\n    #TransformMeta::Generated part def Beam;\n}\n' > v.sysml
 $ $sysmlv2 check --strict --lib "$lib" v.sysml
-$ $sysmlv2 query --lib "$lib" v.sysml 'V::shell.localName'
-"div"
 ```
 
-Their sources are `local-packages/*.sysml` in the repository; see `local-packages/README.md` for their contents, provenance, and local validation commands.
+Its source is `local-packages/TransformMeta.sysml` in the repository; see `local-packages/README.md`. `SYSMLV2_AMBIENT=off` leaves it out.
 
 ---
 
@@ -987,19 +1031,6 @@ $ $sysmlv2 query "$vehicle" "size(ownedFeature($vb))"
 40
 ```
 
-## 11a. `render` — evaluate a view's component template
-
-A component template represented as a `rendering def` plus a `view def` can be evaluated over a model. A `view` usage of that definition exposes a model slice, and `render` evaluates the template over it — each blocks iterate the exposed elements, expression tags evaluate their translated KerML — printing the rendered node tree as JSON, or HTML with `--html`. The model is not modified.
-
-```console
-$ $sysmlv2 render --lib "$lib" --html PackagesView.sysml fleet.sysml Site::packagesView
-<h3 id="packages-heading">Vehicles</h3><filterable-list>…</filterable-list>
-```
-
-Expressions the importer could not translate render as their opaque source (`{expr}`) or as an `<!-- error: … -->` marker, so a view always renders.
-
----
-
 ## 12. `verify` — constraint verdicts, witnesses, proofs
 
 `verify` evaluates every constraint, requirement, and invariant body that carries its own result expression to a verdict — satisfied, VIOLATED (exit 1), or undecided with the reason:
@@ -1086,7 +1117,7 @@ The wagon's 950 kg is inside the 1000 kg laden cap (satisfied) but over the 900
 
 ### `--ranges` — interval propagation (no solver)
 
-With `--ranges`, every unbound feature gets an interval domain that the asserted constraints contract by bidirectional propagation. There is no external solver — it is ~300 lines of interval arithmetic in `sysmlv2-solve`. The result is a **finite range per feature** plus verdict upgrades that are definitive (a range holds for *every* consistent assignment): a body that is true over the whole narrowed domain is satisfied, one that is false everywhere is VIOLATED, and a domain that contracts to empty (`∅`) proves the constraint unsatisfiable.
+With `--ranges`, every unbound feature gets an interval domain that the asserted constraints contract by bidirectional propagation. There is no external solver — it is ~300 lines of interval arithmetic in `sysmlv2-solve`. The result is a **finite range per feature** plus verdict upgrades that are definitive (a range holds for *every* consistent assignment): a body that is true over the whole narrowed domain is satisfied, one that is false everywhere is VIOLATED, and a domain that contracts to empty (`∅`) proves the constraint unsatisfiable. If a feature definition is outside the supported fragment, narrowed ranges remain useful, but a positive propagation verdict must also hold over the original declaration domains. Otherwise propagation reports the approximation and leaves verification to the solver.
 
 ```sysml
 package Demo {
@@ -1138,7 +1169,7 @@ tank.sysml:7:30  fits (AssertConstraintUsage): undecided (result is indeterminat
 0 satisfied, 0 violated, 1 undecided
 ```
 
-What stays undecided is honestly undecided — a contingent constraint reports a witness instead of a guess, constructs outside the decidable fragment (sequences, strings, quantity brackets…) say so, and a feature whose definition can't be encoded is over-approximated in a way that keeps `VIOLATED`/`satisfied` upgrades definitive. Across the corpus, 43 of the 80 evaluator-undecided constraints get witnesses this way, and none are unsatisfiable (`crates/sysmlv2-solve/tests/corpus.rs` gates exactly that). The solving layer lives in the dependency-free `sysmlv2-solve` crate — Z3 runs as a subprocess, nothing links libz3.
+What stays undecided is honestly undecided — a contingent constraint reports a witness instead of a guess, constructs outside the decidable fragment (sequences, strings, quantity brackets…) say so, and a feature whose definition can't be encoded is treated as free. Refutations remain definitive; propagation withholds satisfaction that depends on narrowing through such an approximation, and Z3 reports an approximate witness as unknown. Across the corpus, 43 of the 80 evaluator-undecided constraints get witnesses this way, and none are unsatisfiable (`crates/sysmlv2-solve/tests/corpus.rs` gates exactly that). The solving layer lives in the dependency-free `sysmlv2-solve` crate — Z3 runs as a subprocess, nothing links libz3.
 
 ## 13. `viz` — PlantUML diagrams
 
@@ -1253,7 +1284,7 @@ Every non-library corpus file emits a balanced diagram for every view (`sysmlv2-
 
 ### View-directed diagrams
 
-A *view usage* carries its own diagram definition: `expose` picks the elements (with the model's `filter` conditions applied through the same machinery that governs import visibility), and `render` picks the style. Pointing `--element` at a view renders exactly that slice — `--view` is only needed to override the view's own choice:
+A *view usage* carries its own diagram definition: `expose` picks the elements (with the model's `filter` conditions applied through the same machinery that governs import visibility), and `render` picks the style. A view without a `render` member of its own takes the rendering it inherits, so `view wiring : Wiring;` over `view def Wiring { render Views::asInterconnectionDiagram; }` draws an interconnection diagram, and its own `render` member would win over the inherited one. Pointing `--element` at a view renders exactly that slice — `--view` is only needed to override the view's own choice:
 
 ```sysml
 package Stage {
@@ -1465,7 +1496,7 @@ $ $sysmlv2 payload --tables -o s2c-tables.json
 $ jq '{magic, versions, flags}' s2c-tables.json
 {
   "magic": "d9d9f7da24533243",
-  "versions": { "layout": 1, "scheme": 1, "tables": 1 },
+  "versions": { "layout": 1, "scheme": 2, "tables": 1 },
   "flags": { "delta": 4, "deltaPortable": 8, "elideIds": 1, "explicitIds": 64, "fullForm": 2, "impliedOwners": 32, "unitPaths": 16 }
 }
 $ jq '.metaclasses[] | select(.name == "AcceptActionUsage") | .fields[15]' s2c-tables.json
diff --git a/Cargo.lock b/Cargo.lock
index a611e06..0a5a115 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1711,7 +1711,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-cbor"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "miniz_oxide",
  "serde_json",
@@ -1723,7 +1723,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-cli"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "clap",
  "miniz_oxide",
@@ -1743,7 +1743,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-lint"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "regex-lite",
  "serde_json",
@@ -1755,7 +1755,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-lsp"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "crossbeam-channel",
  "lsp-server",
@@ -1771,7 +1771,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-model"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "num-bigint",
  "num-integer",
@@ -1779,13 +1779,14 @@ dependencies = [
  "num-traits",
  "serde",
  "serde_json",
+ "sha1_smol",
  "sysmlv2-syntax",
  "uuid",
 ]
 
 [[package]]
 name = "sysmlv2-parser"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "jsonschema",
  "serde_json",
@@ -1797,7 +1798,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-py"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "pyo3",
  "serde_json",
@@ -1810,7 +1811,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-solve"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "sysmlv2-model",
  "sysmlv2-syntax",
@@ -1819,18 +1820,18 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-syntax"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "sysmlv2-testkit"
-version = "0.9.1"
+version = "0.10.0"
 
 [[package]]
 name = "sysmlv2-transform"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "serde_json",
  "sysmlv2-cbor",
@@ -1843,7 +1844,7 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-viz"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -1854,8 +1855,9 @@ dependencies = [
 
 [[package]]
 name = "sysmlv2-wasm"
-version = "0.9.1"
+version = "0.10.0"
 dependencies = [
+ "js-sys",
  "miniz_oxide",
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index f657545..2e77b17 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,21 +44,21 @@ default-members = [
 ]
 
 [workspace.package]
-version = "0.9.1"
+version = "0.10.0"
 edition = "2021"
 rust-version = "1.97"
 license = "Apache-2.0"
 repository = "https://github.com/Open-MBEE/sysml-toolkit"
 
 [workspace.dependencies]
-sysmlv2-parser = { path = "crates/sysmlv2-parser", version = "0.9.1" }
-sysmlv2-cbor = { path = "crates/sysmlv2-cbor", version = "0.9.1" }
-sysmlv2-solve = { path = "crates/sysmlv2-solve", version = "0.9.1" }
-sysmlv2-lint = { path = "crates/sysmlv2-lint", version = "0.9.1" }
+sysmlv2-parser = { path = "crates/sysmlv2-parser", version = "0.10.0" }
+sysmlv2-cbor = { path = "crates/sysmlv2-cbor", version = "0.10.0" }
+sysmlv2-solve = { path = "crates/sysmlv2-solve", version = "0.10.0" }
+sysmlv2-lint = { path = "crates/sysmlv2-lint", version = "0.10.0" }
 sysmlv2-testkit = { path = "crates/sysmlv2-testkit" }
-sysmlv2-transform = { path = "crates/sysmlv2-transform", version = "0.9.1" }
-sysmlv2-viz = { path = "crates/sysmlv2-viz", version = "0.9.1" }
-sysmlv2-lsp = { path = "crates/sysmlv2-lsp", version = "0.9.1" }
+sysmlv2-transform = { path = "crates/sysmlv2-transform", version = "0.10.0" }
+sysmlv2-viz = { path = "crates/sysmlv2-viz", version = "0.10.0" }
+sysmlv2-lsp = { path = "crates/sysmlv2-lsp", version = "0.10.0" }
 lsp-server = "0.10"
 lsp-types = "0.97"
 crossbeam-channel = "0.5"
@@ -69,6 +69,9 @@ serde = { version = "1", features = ["derive"] }
 # can land 1 ULP off (e.g. "1e-28"), silently splitting digests.
 serde_json = { version = "1", features = ["float_roundtrip"] }
 uuid = { version = "1", features = ["v4", "v5", "js"] }
+# The SHA-1 behind version-5 identities, used directly to extend an
+# owner's hash state by a child's path segment.
+sha1_smol = "1"
 clap = { version = "4", features = ["derive", "wrap_help", "env"] }
 jsonschema = "0.56"
 miniz_oxide = "0.9"
diff --git a/IDS.md b/IDS.md
index 8928f8f..33f87d8 100644
--- a/IDS.md
+++ b/IDS.md
@@ -1,13 +1,71 @@
-# Element identity: graph-derived ids (id scheme 1)
+# Element identity: versioned graph-derived ids
 
 How this toolkit assigns `@id`s to **user-model** elements. The scheme makes every user element's id a **pure function of the interchange graph**, so a consumer holding a compact element array can recompute every id from structure + names alone (the enabler for CBOR id elision) — and so ids survive edits: renaming or inserting a member never shifts unrelated siblings, and named members chain **past their membership's ordinal**, so a mid-body insertion re-derives none of the named siblings after it and an insertion-sized edit stays an insertion-sized delta.
 
-On the wire, this derivation is stamped as **id-scheme 1** in the payload header of the binary interchange form (`CBOR.md`): id-elided payloads (snapshot or delta) refuse a scheme they don't carry, while explicit-id payloads ignore the stamp entirely.
-
-Standard-library elements are unaffected: named library elements keep their normative KerML 9.1 name-based UUIDs, unnamed library elements keep their deterministic toolkit-local path ids.
+On the wire, legacy lowering uses **scheme 2** and opt-in canonical lowering uses **scheme 3** (`CBOR.md`). Both use the derivation below; their authored graph shapes differ. ID-elided snapshots and deltas refuse unsupported schemes. Generic explicit-ID decoding retains historical scheme compatibility, while scheme 3 compact payloads additionally validate their conditional and constructor graph shapes.
+
+Named standard-library elements keep their normative KerML 9.1 name-based UUIDs. Anonymous library path IDs depend on the selected lowering contract; regenerate library snapshots and resolvers when changing it.
+
+## Opt-in canonical graphs
+
+Existing constructors retain `GraphFormat::LegacyV2`. Rust clients can choose
+`Model::with_graph_format(GraphFormat::CanonicalV3)` or
+`Session::from_sources_with_graph_format(sources, library, format)` before loading
+sources. Prepared libraries must use the same format; cache entries are separated.
+Sessions retain the choice through edits and library reloads.
+
+Canonical lowering inserts an authored `FeatureReferenceExpression` and its
+`FeatureMembership` between each lazy operand's `FeatureValue` and expression.
+This covers the right operand of `and`, `or`, `implies`, and `??`, and both
+branches of `if`. Expression evaluation keeps its short-circuit behavior.
+The graph-derived identity of the new wrapper can equal the former operand ID;
+the operand and its descendants acquire new IDs. Graph walkers must follow the
+owned membership to reach the original expression.
+
+Canonical constructors own one `ReturnParameterMembership` containing an `out`
+result Feature. Their argument ParameterMemberships belong to that result, with
+named Redefinitions and FeatureValues retained on the argument Features. The
+result membership uses the dedicated `result` identity segment and its Feature
+uses `e0`; these identities cannot capture the old first argument's `r1/e0`
+identity. Argument subtrees acquire new identities under the result. This is an
+in-place revision of the unused experimental V3 contract; regenerate earlier V3
+artifacts from source.
+
+To migrate a complete graph-derived user document, call
+`sysmlv2_model::migration::migrate_conditional_graph(document, external_name)`.
+It returns a new compact document, every old-to-new ID mapping, added IDs, and
+old-to-new row indices for updating unit-root tables. It refuses malformed or
+already-canonical conditional or constructor structures and input IDs inconsistent with legacy
+graph derivation. Decode old elided CBOR first. Regenerate normative library
+snapshots from source under the target format. Foreign explicit-ID documents
+remain loadable under their original contract; this migration does not guess
+how their producers assign identities.
+
+Include every document whose inbound references should be migrated in the same
+call. Apply the returned mapping **simultaneously** to external inbound references;
+sequential replacement is unsafe because old IDs can be reused by wrappers.
+External library targets remain external and require the corresponding target
+library/resolver version. Migration does not silently rewrite a separate library.
+
+JSON has no format header. Retain the choice alongside the document and use
+`load_document_with_format` or
+`Session::from_interchange_json_with_graph_format` for replay. These reject a
+conditional or constructor shape inconsistent with the selected contract. Existing unversioned
+JSON loaders retain their warning/recovery behavior for foreign graphs; unmatched
+identities can be lost there, so use the format-aware API to preserve canonical
+structure and identities. Format validation is not a general
+lossless-import or whole-model conformance certificate. Ordinary constructors continue to load legacy explicit-ID documents. Changing the default requires a
+separate release migration; the opt-in is currently exposed through the Rust APIs.
 
 ## The derivation
 
+Source-origin end Usage constancy is completed only when checked variability
+evidence proves the required value. Imported flags retain their explicit values
+and normative absent defaults. The graph migration preserves those flags; it does
+not reinterpret an interchange document as source text. Checked reads qualify
+unsupported evidence, while compatibility JSON output can retain syntax defaults
+in those cases and is not a conformance certificate.
+
 Every user element's id chains from its owner:
 
 ```
@@ -17,8 +75,21 @@ id(child)    = uuid5(id(parent), segment(child))
 
 `uuid5` is RFC 4122 v5 (SHA-1) with the parent id as the namespace. The root Namespace has no name in the payload (it stands for the source unit), so its id stays assigned, not derived; everything below it derives.
 
+**Source names anchor documents.** When building a multi-source `Model`, the
+text builder seeds each user document root from `"$root/" + source_name` in
+its fixed toolkit UUID namespace. `Model::add_source` uses the supplied name
+verbatim; it does not make duplicate names unique or normalize paths. Give
+distinct documents distinct stable names, preferably project-relative paths
+such as `examples/model.sysml` and `validation/model.sysml`, rather than only
+`model.sysml`. Reusing a name can create duplicate root and descendant IDs.
+Changing a name changes that document's freshly derived IDs; moving a checkout
+need not change them if its relative source names stay the same. This is the
+multi-source text-builder contract, not a change to explicit root IDs retained
+in interchange payloads or standard-library name-based IDs.
+
 **Segments.** For a relationship `rel` at position `i` of its owner's `ownedRelationship` array:
 
+- a constructor's **ReturnParameterMembership owning one Feature** takes `"result"` under the constructor, and the Feature takes `"e0"` under that membership, regardless of effective names;
 - a **single-member membership whose member has an id-name** chains past the membership: the member `k` takes `"::" + escape_name(idName(k))` **directly under the owner**, and `rel` takes `"m"` **under the member** (`id(rel) = uuid5(id(k), "m")`) — the shape of the normative library rule, where an element's owning membership derives from the element, not from a position. Neither id references the ordinal `i`;
 - an **alias membership** — a bare `Membership` that owns no element and carries `memberName`/`memberShortName` — takes `"::" + escapedName` (the alias is a *named relationship*);
 - every other relationship takes `"r{i}"`.
@@ -28,7 +99,9 @@ For an element `k` at position `j` of `rel.ownedRelatedElement`, when the first
 - if `rel` is a `*Membership` and `k` has an **id-name**, the segment is `"::" + escape_name(idName(k))` under `rel`;
 - otherwise `"e{j}"` (elements under non-membership relationships are positional regardless of naming, mirroring the normative library rule).
 
-**Id-name.** `declaredName`, else `declaredShortName`, else the **graph-effective name** (KerML 8.2.3.5): the name of the first `Redefinition`/`ReferenceSubsetting` target among `k`'s owned relationships, in `ownedRelationship` order — resolved *through the graph*, iterated to fixpoint (a member may take its name from another effectively named member). A target outside the document resolves through the library name table; a hermetic `{"@ref": name}` target *is* the name. No resolvable name → positional segment.
+**Id-name.** Scheme 2 retains a historical identity label independently of the semantic `name` property. For compatibility, its final fallback includes a generic ReferenceSubsetting target label even when the language gives that Feature no name. This does not confer a normative semantic name. Syntax replay can retain the resolver’s existing locator spelling independently. Changing this fallback would require a new ID scheme and explicit migration. The remaining precedence is `declaredName`, else `declaredShortName`, else the **versioned graph identity label**: the name of the first `Redefinition` target, or the referenced feature under the applicable SysML naming rule — resolved *through the graph*, iterated to fixpoint (a member may take its name from another effectively named member). A target outside the document resolves through the library name table; a hermetic `{"@ref": name}` target *is* the name. No resolvable name → positional segment. An anonymous feature chain does not take the last link's name. Performed actions (including exhibited states and included use cases) and required/assumed constraints name through the referenced feature's `featureTarget`; variants use the reference itself. These specialized reference rules take precedence over an explicit redefinition.
+
+The transition from scheme 1 to scheme 2 changed freshly derived ids for affected features and their descendants. Semantic naming fixes within scheme 2 preserve this versioned identity algorithm. Persisted payloads with explicit ids retain those ids. Scheme 2 stamps the corrected naming rules. Scheme 1 ID-elided snapshots and deltas are refused; decode them with their original toolkit and export explicit-id JSON/CBOR before upgrading. Regenerate standard-library resolver artifacts for scheme 2.
 
 **Collisions.** Named segments claim **owner scope**, first-come in `ownedRelationship` order — member names and alias names share one spelling space under an owner (positional labels live in a disjoint one). A later claimant of a taken segment falls back positional; for a member that means the member **and its membership** both revert to the positional chain (`r{i}`, `e{j}`), keeping the pair consistent. Deterministic in array order.
 
diff --git a/INTEROP.md b/INTEROP.md
index 2a5096f..1692719 100644
--- a/INTEROP.md
+++ b/INTEROP.md
@@ -4,7 +4,9 @@ How this toolkit's interchange JSON relates to the normative sources — the OMG
 
 ## Conformance level of the full form
 
-Full-form output validates against the published 20250201 JSON schemas, with one documented departure: the value of a numeric literal that no JSON number denotes exactly is emitted as the literal's own text, where the schema declares `LiteralInteger.value` an integer or null and `LiteralRational.value` a number or null (see *Numeric literal values* below for why, and `crates/sysmlv2-parser/tests/full_json.rs`, where the schema check's expectations live, for the exception itself). Compact output contains owned properties and deliberately omits derived properties required by those schemas; it is checked separately against the XMI property inventory. The full form computes every derived property the derivation layer answers (API.md §7) and, by default, emits the inheritance/import closures as type-correct empty values and the inheritance-aware properties over the owned side — the API's "passthrough" level — so payload size stays proportional to the model. Under the closure policy (`EmissionPolicy::closures`, `sysmlv2 convert --to full-json` keeps the passthrough level) the four closure names — `inheritedMembership`, `inheritedFeature`, `importedMembership`, `featuringType` — are written and the inheritance-aware properties carry their specification values over the inherited and imported memberships, with or without the implied library heritage. Measured on the standard corpus (251 files, library loaded): the closure form over the written heritage is 1.25× the passthrough payload, and 2.31× with the implied heritage (every part listing the members of `Parts::Part` and its bases). Both forms are schema-valid and this toolkit reads either; a model whose heritage is deeper than the resolver's depth budget (24 levels) is refused under the closure policy rather than written with a truncated closure.
+Full-form output validates against the published 20250201 JSON schemas, with one documented departure: the value of a numeric literal that no JSON number denotes exactly is emitted as the literal's own text, where the schema declares `LiteralInteger.value` an integer or null and `LiteralRational.value` a number or null (see *Numeric literal values* below for why, and `crates/sysmlv2-parser/tests/full_json.rs`, where the schema check's expectations live, for the exception itself). Compact output contains owned properties and deliberately omits derived properties required by those schemas; it is checked separately against the XMI property inventory. The full form computes every derived property the derivation layer answers and, by default, emits the inheritance/import closures as type-correct empty values and the inheritance-aware properties over the owned side — the API's "passthrough" level — so payload size stays proportional to the model. Under the closure policy (`EmissionPolicy::closures`, `sysmlv2 convert --to full-json` keeps the passthrough level) the four closure names — `inheritedMembership`, `inheritedFeature`, `importedMembership`, `featuringType` — are written and the inheritance-aware properties carry their computed values over the inherited and imported memberships (these remain approximations where semantic dependencies are incomplete), with or without the implied library heritage. Measured on the standard corpus (251 files, library loaded): the closure form over the written heritage is 1.28× the passthrough payload, and 2.69× with the implied heritage (every part listing the members of `Parts::Part` and its bases). Both forms are schema-valid and this toolkit reads either; acyclic inheritance is evaluated iteratively without a depth cap. An actual import-walk or cyclic-fallback depth cut is refused under the closure policy. Known unsupported positional dependencies, cycles and failure to stabilize named selection within its pass budget are reported separately by `inheritance_incomplete`; compatibility emission remains qualified, while checked reads and strict export retain their conservative refusal behavior.
+
+Full-form scalar completion uses the effective metamodel declaration's owned default when no stored value is present; for example, a non-individual part definition exports `isIndividual: false`. Retained values, including invalid values, remain available for validation. A conjugated port typing's `portDefinition` references the original port definition. An operator expression with a loaded library Function and an available return parameter exports that parameter as its `result`, including at the passthrough level. These corrections do not make incomplete checked expression reads exact: strict export still refuses unavailable properties, while compatibility export retains placeholders when required references cannot be computed.
 
 ## Representation rules (per the pilot)
 
@@ -22,7 +24,12 @@ Full-form output validates against the published 20250201 JSON schemas, with one
 - Variations (and enum definitions) are implicitly abstract; exposes force `isImportAll`; chain/index/collect/select expressions carry their fixed `operator`; multi-step chain expressions flatten to a single FeatureChainExpression + OwnedFeatureChain member.
 - Every SysML port definition owns its implicit `~P` ConjugatedPortDefinition (OwningMembership, declaredName `~P`) with the PortConjugation pointing back at the original.
 - Satisfy `by` targets bind per the pilot's `SatisfactionFeatureValue`; named invocation/constructor arguments own the pilot's `ParameterRedefinition` of the callee's parameter; positional arguments take the callee's `in` parameter names (in-document callees); binding connector ends take the `Links::SelfLink` positional names `thisThing`/`sameThing`.
-- Implied relationships are emitted when resolving against `--lib`, following the pilot's anti-redundancy rule.
+- Supported implied library and variation specializations are emitted when their targets are known. A required edge is omitted only when another specialization path still reaches its target; cycles retain enough edges to satisfy every requirement. Supported positional end, non-return parameter and result Redefinitions are materialized; imported positional sequences and other implied families remain incomplete.
+- A named import retains the selected Membership's identity, including an alias reached through another import. Its `importedElement` still references that Membership's member element. Imported membership collections retain declaration order and apply visibility, filters and ancestor exclusions. The Namespace imported-membership projection deduplicates identity and removes known name/metaclass collisions before Package filters; visibility-specific re-exports are separate operations. External or specialized inferred names and complete inheritance/import composition remain qualified.
+- Declared connector-end names resolve in the connector's body through the connected feature, for binary and non-binary connectors. Binary `source`/`target` lookup aliases remain available after declared-name lookup.
+
+- Shorthand successions can materialize source/target ReferenceSubsettings from checked neighboring occurrences and supported transition entries. Missing source evidence does not shift a known target into the source role. Broader transition feature chains remain qualified.
+- Generic ReferenceSubsetting does not confer a semantic name. Existing replay name-map helpers and `resolve_qualified` retain historical syntax locators, and user ID scheme 2 retains its identity labels; neither is a normative name authority. `resolve_semantic_qualified` excludes those locators while preserving named aliases. Namespace imports exclude unnamed reference locators before merging candidates, so multiple anonymous references do not hide a declared or inherited name.
 
 ## Library element IDs (KerML 9.1)
 
@@ -32,8 +39,11 @@ Top-level standard-library packages get `uuid5(NameSpace_URL, prefix + escapedNa
 
 The complete derived-property census — every `isDerived` name with its class (structural, inheritance-aware, closure) and whether the emitter derives it — is generated into [`spec-refs/derived-properties.md`](spec-refs/derived-properties.md) by `tools/derived_census.py`; the bullets below are the hand-maintained notes that the census does not express.
 
-- Implied end-**Redefinition elements** for binary connector ends are not emitted (the positional *names* are derived, the relationships are not).
-- `mayTimeVary`/SysML `isVariable` are set for variation/enum cases recognized structurally; complete derivation through library conformance remains limited.
+- Supported positional end, non-return parameter and result Redefinitions are materialized, including relationships owned by library features. Nonrecursive imports from leaf providers can contribute inherited FeatureMembership slots; directly imported features and alias Memberships are not the importing type's feature slots. CanonicalV3 positional planning additionally supports recursive/transitive plain-package import selection and direct Type-owned Membership imports with certified dependency order. Checked Type reads additionally certify recursive imports with explicit global targets into named plain-package trees and aliases to explicit global declarations. Qualified paths through named plain packages require exact direct public declaration bindings at every segment after the global root; short names are supported. Membership import targets, namespace cache targets and alias targets retain their distinct resolver depth limits. Acyclic internal imports and mixed recursive/ordinary import sets are supported when every target has that same checked global declaration path and all raw import entries, mirrors and caches agree. Package aliases reuse the same checked target proof. Unnamed Namespace children, owned Type namespaces, filters, local aliases on other importing owners, lexical targets and cyclic provider paths remain qualified. The shared Membership selector counts namespace import and recursive containment edges against its depth bound; helper calls within the same namespace consume no additional depth. Selection beyond the bound is refused rather than returned as a truncated collection. Supported foreign ordinary end Features under Class owners and parameter/result Features under Behavior/Function owners use separate planning prerequisites, so their relationships are computed before import reduction without inheriting unrelated members. Ordinary parameters pair with direct-base owned parameters; results pair with the effective result, including inherited results. Acyclic authored positional chains into strict actual ancestors are supported; their existing authored paths prevent duplicate implied edges. Supported public/protected imports inside those foreign owners reuse the shared visibility selectors and complete source proof. They add no inheritance to a consumer merely because the foreign owner is scheduled; actual descendants retain the imported Memberships. Other external positional dependencies, same-owner or unrelated-owner positional chains, nested imports needing additional foreign positional owners, recursive Type traversal, metadata filters, some implicit binary KerML bases, and other implied relationship families remain incomplete. LegacyV2 keeps its prior publication behavior, including a known declaration-order limitation for aliases to foreign positional Features; checked reads refuse those uncertified dependencies in both formats.
+- Checked `Definition.usage` and `directedUsage` use complete inherited feature sequences for supported structural definitions, retaining order and redefinition removal. Their success does not certify each member's internal semantics or complete implied-relationship coverage.
+- Compatibility export still computes some parameter/result properties independently of the shared semantic reader and can emit required-reference recovery placeholders. The checked property reader and strict export refuse unavailable semantics; complete expression graphs and export convergence remain unfinished.
+- Inherited non-owning aliases of Features participate in redefinition removal. Distinct Memberships of the same Feature suppress each other through its reflexive redefinition closure; repeated paths to one Membership are deduplicated. This filtering also governs inherited positional slots. For supported explicit KerML inheritance with named, in-model memberships, lookup selects surviving Memberships before matching names. Stored reference endpoints use the same selection, including after library replay. Explicit bases may be bound through imports in enclosing namespaces: those import walks belong to the specialization reference sites and do not propagate to inherited member accesses. Redefinition headers try complete stored explicit generals in declaration order, including when each starting context requires contextual lookup; unsupported no-result cases remain qualified. Derived inheritance applies the same header context so a redefinition does not lose the members of its suppressed target. Alias targets enter recorded selection only when their complete spelling can be structurally certified without an import walk, including supported aliases, effective bindings and filtered explicit inheritance. Imports in the type itself, uncertified alias paths, filters, chains, unnamed effective-name inference, SysML Usage/Definition contexts and potential positional redefinitions retain the contextual resolver; lookup is not fully aligned in those cases.
+- Checked Usage `mayTimeVary` and its effective `isVariable` alias use bounded shared ownership and specialization evidence under implied closure. Supported ordinary Usage contexts and independent exclusions can be certified. Positive ordinary end proofs require complete ordered end and redefinition evidence; unsupported contextual inheritance, metadata, Association/Connector and cross-feature contexts refuse. LegacyV2 compatibility export retains its existing defaults. CanonicalV3 source-origin end constancy and export share this evidence; imported owned flags remain explicit. Canonical export no longer forces every end Usage to be variable and constant. Incomplete end-specialization evidence still qualifies completion; compatibility JSON can retain uncertified syntax defaults, while checked reads and strict export report the gap.
 - The compact owner-side `conjugatedPortDefinition` property remains an explicit XMI-audit omission. The implicit `~P` element and full-form property are emitted; this is a property-coverage gap, not absence of the conjugated element.
 
 ## Diagnostics philosophy: errors vs. warnings
@@ -44,10 +54,46 @@ Errors are reserved for what is *provably* wrong (syntax, illegal body context,
 
 The binary form (`CBOR.md`) is a byte-level re-encoding of the compact interchange element array — schema-equivalent by construction, since decoding reproduces the exact compact JSON `Value` before any consumer sees it. It adds no conformance surface of its own: everything above about representation rules, library element IDs, and partial models applies unchanged. The payload header carries the generated-table version; a decoder refuses a version it does not carry rather than silently mis-indexing, and the reserved id-elision flag bit is likewise refused by decoders that predate it.
 
-## Element ids (scheme 1)
+## Element ids (scheme 2)
 
 User-element `@id`s are graph-derived (see `IDS.md`): chained UUIDv5 from the document root through ownership, with name-based segments for membership-owned named elements — chained past the membership's ordinal, so a named member and its membership derive from the owner and the member's name alone — and positional segments otherwise. Consequence for interchange consumers: every non-root id of a compact payload is recomputable from structure + names (`ids::derive_ids`), and re-emitting a model from text is id-stable under edits that do not move or rename the element's own ancestry — including inserting members before it. Payloads that carry explicit ids lift verbatim. Library element ids are unchanged (normative KerML 9.1 where named).
 
 ## Anonymous redefinition targets
 
-Sibling anonymous redefinitions such as `ref :>> items = a;` and `ref :>> items = b;` resolve their target against the inherited feature, including an inherited override. Their inferred local names cannot resolve each other's `redefinedFeature`. Each occurrence remains a distinct feature; compact JSON and navigation reference sites point at the same intended base target. Declared local targets remain available, and missing or genuinely ambiguous inherited targets still produce findings.
+Sibling anonymous redefinitions such as `ref :>> items = a;` and `ref :>> items = b;` resolve their target against the inherited feature, including an inherited override. Their inferred local names cannot resolve each other's `redefinedFeature`. Each occurrence remains a distinct feature; compact JSON and navigation reference sites point at the same intended base target. For the supported explicit KerML cases, a Redefinition target starts in each direct general Type in declaration order, including for a globally qualified target. The declaring Type's local members do not supply that target. With no direct general Type, the reference stays unresolved. Qualifier reference sites retain the selected base context so rename can preserve the binding. Broader contextual cases remain qualified. If recorded selection cannot stabilize within its bounded replay, the model restores the complete initial contextual result and reports `inheritance_incomplete`; it does not expose a mixture of replayed endpoints and diagnostics.
+
+CanonicalV3 constructor expressions own their argument carriers through an explicit
+result Feature. `constructor_selection_report` certifies the first type selector
+and sole result; `constructor_binding_report` orders supplied named and supported
+positional arguments by the complete public instantiated-Type feature sequence,
+including undirected and output features. Positional mappings require current
+published redefinition witnesses. Duplicate assignments and incomplete mappings
+refuse. `constructor_default_report` selects omitted-feature defaults, including
+inherited and private features; conflicting or cyclic inheritance refuses.
+`constructor_result_report` checks result specialization and the default
+BindingConnectors installed under the result by the shared publisher. Constructor
+model-level evaluability uses the same checked supplied arguments. These reports
+do not certify unrelated whole-model constraints. LegacyV2 keeps its existing
+shape and defaults. See [IDS.md](IDS.md) for the explicit migration and identity contract.
+
+Checked cardinality reports expose exact supported intervals and their source
+identities. Inherited constraints intersect, incompatible constraints are errors,
+and symbolic collections retain their bounds instead of counting as one item.
+Bound references can select a unique receiver redefinition and certify its current
+local valuation through complete Type feature evidence. Runtime parameters,
+metadata-dependent values and incomplete receiver projections remain qualified.
+Unknown receiver members remain qualified because the current value representation
+does not retain their receiver cardinality. CanonicalV3 numeric bound formulas
+use current graph operands and shared published bindings to exact loaded library
+functions. Unsupported providers and stale generated evidence refuse. Compatibility
+cardinality helpers also reject contradictory ownership and stale generated edges.
+LegacyV2 remains the default graph format and retains its publication shape.
+
+CanonicalV3 also supplies the owned FeatureTyping obligations for Features typed by
+Structure, Class or DataType: subsetting `Objects::objects`,
+`Occurrences::occurrences` or `Base::dataValues`, respectively. Multiple applicable
+obligations enter the shared specialization planner before redundant-edge reduction.
+Targets require unique loaded library identities and reciprocal owned typing
+evidence. LegacyV2 retains its existing edges. Ordinary typed reference ends under
+supported OccurrenceDefinition owners can therefore complete checked constancy;
+owners whose inherited Usage families lack a complete provider still qualify.
diff --git a/LICENSE b/LICENSE
index 7739fc1..4e1ad6d 100644
--- a/LICENSE
+++ b/LICENSE
@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2026 Open-MBEE
+   Copyright 2026 Planetary Utilities
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/README.md b/README.md
index f716e3d..7138d31 100644
--- a/README.md
+++ b/README.md
@@ -71,12 +71,14 @@ Two environment variables control it:
 
 ### Ambient libraries and model context
 
-Every model that loads a library also sees the generated Web platform libraries under [local-packages/](local-packages/) (`Web::DOM`, `Web::HTML::Elements`, `Template`, `Svelte`, `WebApp`, `SvelteKit`, `TransformMeta`) without naming their files; `SYSMLV2_AMBIENT=off` switches them off. `SYSMLV2_MODEL_DIR` and `SYSMLV2_LIB_DIR` supply inputs and the library for verbs invoked without file arguments.
+Every model that loads a library also sees `TransformMeta` ([local-packages/](local-packages/)), the metadata vocabulary for generated elements, without naming its file; `SYSMLV2_AMBIENT=off` switches it off. `SYSMLV2_MODEL_DIR` and `SYSMLV2_LIB_DIR` supply inputs and the library for verbs invoked without file arguments.
 
 ### Calculation and static-analysis boundaries
 
 Calculations with expression results, local feature values, and positional or named inputs can be evaluated. Duplicate bindings and missing required inputs fail explicitly; omitted inputs use their own defaults without capturing same-named caller parameters. Bodies requiring assignments, loops, or action execution return `Unsupported`, including direct reads of their output initializers, and are not inlined by the solver. Behavioral execution belongs to a separate layer. Lambda bodies with unmodelled local declarations also fail explicitly.
 
+Unbound collections retain integer cardinality bounds from headers, KerML body-declared ranges and supported named multiplicity domains, and through explicit subsettings and redefinitions: `size` can answer four for a valueless `[4]` feature, but member rollups stay indeterminate until the members are available. Exact `[0]` collections are empty; explicit sequences of singleton usages still evaluate. Tuple and cast wrappers do not turn unknown collections into single values. Tuples containing an indeterminate constituent conservatively remain indeterminate because its arity is unknown. Eligible structural usages owned by definitions/usages receive implicit singleton bounds; otherwise unconstrained features default to `[0..*]`. These evaluator rules do not implement complete normative multiplicity semantics.
+
 Dimensional arithmetic is checked from declared quantity types even when parameter values are unbound. Unknown dimensions remain undecided. This check is conservative: it does not yet infer dimensions through arbitrary invocations or lambda bodies. The pinned [OpenSysML negative fixtures](crates/sysmlv2-parser/tests/fixtures/opensysml/) record both diagnostic baselines and remaining gaps; accepting a negative fixture is not counted as validation success.
 
 ### Partial models
@@ -85,7 +87,7 @@ Work-in-progress models with unresolved references are first-class: `check` repo
 
 ## Crates
 
-The repository is a Cargo workspace. Everything is licensed under Apache-2.0; the bindings ship as a wheel and an npm package.
+The repository is a Cargo workspace licensed under Apache-2.0; the bindings ship as a wheel and an npm package (the npm package also bundles the EPL-2.0 standard library — see [License](#license)).
 
 | Crate | What it provides |
 |---|---|
@@ -106,7 +108,7 @@ The repository is a Cargo workspace. Everything is licensed under Apache-2.0; th
 Alongside the crates:
 
 - [`editors/vscode`](editors/vscode) — the VS Code extension: semantic highlighting with a TextMate fallback, plus the language-server client.
-- [`local-packages/`](local-packages) — the generated ambient libraries and their provenance sidecars; checked-in sources work without a generator.
+- [`local-packages/`](local-packages) — `TransformMeta`, the ambient metadata library for generated elements.
 - [`spec-refs/`](spec-refs) — the pinned normative grammars, JSON schemas, and metamodel XMI, plus the official corpus and an external validation corpus as submodules (see [spec-refs/README.md](spec-refs/README.md)).
 - [`tools/`](tools) — the generators for the spec-derived tables (`gen_cbor_tables.py`, `gen_metaclass_hierarchy.py`, `xmi_props.py`), the `SDK.md` doctest runner, and the release and public-export scripts.
 
@@ -123,7 +125,7 @@ Alongside the crates:
 | Multi-file models + standard-library resolution | ✅ `model::Model`; 99.92% of corpus references resolve |
 | Normative library element IDs (KerML 9.1) | ✅ verified against published OMG XMI |
 | Textual printer + formatter (`sysmlv2 fmt`) | ✅ idempotency/semantic/note gates over the corpus |
-| `sysmlv2` CLI with example-rich `--help` | ✅ convert / payload / fmt / check / lint / verify / eval / query / render / describe / members / parse / viz / refactor / lsp |
+| `sysmlv2` CLI with example-rich `--help` | ✅ convert / payload / fmt / check / lint / verify / eval / query / describe / members / parse / viz / refactor / lsp |
 | JSON reader (`lift`) + conversion matrix: text ⇄ compact JSON, full-JSON input normalized | ✅ corpus round-trip gate (`emit∘parse∘print∘lift = id`) |
 | Full JSON form (derived props + implied relationships, `--to full-json`) | ✅ 52,048 corpus elements validate against the published schema |
 | Binary interchange (`--to compact-cbor` / `full-cbor`, `.s2c`) | ✅ deterministic, byte-for-byte reconstructable; elided ids; digest-verified deltas |
@@ -162,7 +164,7 @@ source text ──lexer──▶ tokens ──parser──▶ syntax AST ──b
 
 **Superset parsing.** Bodies accept the union of member kinds across contexts (a state member is not rejected inside a part body). Context validation is a semantic-checker concern; keeping it out of the parser simplified the grammar dramatically without losing any conforming model.
 
-**Error tolerance.** Lexer and parser never abort: they emit diagnostics with byte spans (plus a `LineIndex` for line/column) and recover at member boundaries, so one pass reports many errors and the AST remains usable on broken input. Trailing result expressions (`constraint { mass <= limit }`) are disambiguated from member declarations by checkpoint-and-backtrack.
+**Error tolerance.** Lexer and parser never abort: they emit diagnostics with byte spans (plus a `LineIndex` for line/column) and recover at member boundaries, so one pass reports many errors and the AST remains usable on broken input. Trailing result expressions (`constraint { mass <= limit }`) are disambiguated from member declarations by checkpoint-and-backtrack. A result expression terminated like a statement (`constraint { mass <= limit; }`) is reported at its `;` and still kept as the body's result.
 
 **Name resolution** follows KerML scoping: per scope, owned members (declared *and* short names) → aliases → membership imports → inherited members → namespace imports, with imports followed transitively (re-exports like `ISQ::mass`) and recursively for `::**`. Inherited-member lookup walks explicit specialization/typing targets **plus** the implied library bases of SysML Tables 31/32 (every `action` sees `Actions::Action`'s `start`/`done`) — used for resolution only, never serialized. All paths are cycle-guarded and cached per scope.
 
@@ -189,7 +191,6 @@ source text ──lexer──▶ tokens ──parser──▶ syntax AST ──b
 - The compact form deliberately does not satisfy the published JSON schemas' `required` lists — those describe the *full* (derived) form, which `--to full-json` produces.
 - Body contexts parse as a superset; `sysmlv2 check` closes the gap post-parse (body-context legality, duplicate names, variant ownership, import visibility). Remaining syntax fidelity limits include effect-only transition shorthands and result-expression-last positioning. Metadata-body implicit redefinitions and their static value checks are implemented.
 - Unnamed library elements keep deterministic local IDs instead of the normative positional `path()` IDs (never referenced from user text).
-- The [generated Web library](local-packages/README.md) has nine invalid attribute typings when checked as user input; its generator mappings need correction. Library-mode loading suppresses those library diagnostics.
 - Behavioral execution is not implemented. Calculations that require statement execution return an explicit unsupported error; unbound inputs may yield an indeterminate value. Static action/state checks do not execute behaviors.
 - Only the decidable fragment of constraint expressions reaches the SMT translator; the rest stay `undecided` with a stated reason.
 
@@ -214,4 +215,10 @@ The Python binding builds with `maturin develop` in `crates/sysmlv2-py` (it is o
 
 ## License
 
-Apache License 2.0 — Copyright 2026 Open-MBEE (see [LICENSE](LICENSE)). Reference material under `spec-refs/` keeps its upstream licenses (EPL-2.0 grammars, LGPL-3.0 corpus, MPL-2.0 external corpus).
+Apache License 2.0 — Copyright 2026 Planetary Utilities (see [LICENSE](LICENSE)).
+
+Third-party material keeps its upstream license and is not covered by the above:
+
+- `spec-refs/` — the vendored grammars (EPL-2.0), the OMG schemas and metamodel XMI (OMG specification terms), and two corpus submodules whose files this repository references by pinned revision rather than copies (EPL-2.0 and MPL-2.0). See [spec-refs/README.md](spec-refs/README.md).
+- `crates/sysmlv2-parser/tests/fixtures/opensysml/` — external test fixtures under Apache-2.0, with their upstream copyright notice in that directory's [LICENSE](crates/sysmlv2-parser/tests/fixtures/opensysml/LICENSE).
+- The npm package bundles the SysML v2 standard library, which stays under EPL-2.0; the package ships that license as `LICENSE-EPL-2.0` and the upstream copyright notices in `THIRD-PARTY-NOTICES.md`.
diff --git a/SDK.md b/SDK.md
index 2b52ec8..f84af8a 100644
--- a/SDK.md
+++ b/SDK.md
@@ -133,7 +133,7 @@ False
 False
 ```
 
-`element_id(e)` returns the element's interchange id — the same UUID the JSON emitters use. Every derived property of the abstract syntax is reachable by its specification name through `s.derived(e, "ownedFeature")`, `s.derived(e, "owningNamespace")`, `s.derived(e, "name")`, …; `Session.derives(metaclass, name)` says in advance whether a name is computed (`"exact"`, `"passthrough"`, `"not-computed"`) or not a derived property there (`"not-declared"`), and `s.set_closure_policy("closure")` switches the inheritance-aware properties to their definition over the inherited and imported memberships (API.md §3.2a).
+`element_id(e)` returns the element's interchange id — the same UUID the JSON emitters use. Every derived property of the abstract syntax is reachable by its specification name through `s.derived(e, "ownedFeature")`, `s.derived(e, "owningNamespace")`, `s.derived(e, "name")`, …; `Session.derives(metaclass, name)` says in advance whether a name is computed (`"exact"`, `"passthrough"`, `"not-computed"`) or not a derived property there (`"not-declared"`), and `s.set_closure_policy("closure")` extends the inheritance-aware properties over inherited and imported memberships without upgrading their fidelity to exact.
 
 ## 3. Find usages
 
@@ -310,6 +310,8 @@ Refusals are named `sysmlv2.RefusedError`s — an ineligible kind or header, a t
 
 ## 6. Interchange JSON sessions
 
+`property_json(element, name)` reads a specification property using the checked semantic catalog. `to_full_json_strict()` refuses unavailable semantics or unresolved references instead of inserting placeholders. Many valid Type/Usage models are still refused because their derived dependencies are incomplete; these APIs do not certify whole-model validity.
+
 Sessions round-trip through KerML interchange JSON. `to_compact_json()` / `to_full_json()` emit the current state; `from_interchange_json` opens a session from a compact or full element list — including Flexo MMS `{payload, identity}` change records — by lifting it back to text:
 
 ```pycon
@@ -357,7 +359,7 @@ The lift prints every reference as an always-correct `$::`-rooted path. `minimiz
 >>> "part v : $::Rig::Vehicle;" in j.source(0)
 True
 >>> j.minimize_qualifications()
-(4, 1)
+(4, 0)
 >>> "part v : Vehicle;" in j.source(0)
 True
 >>> "part front : Defs::SpareWheel;" in j.source(0)
diff --git a/crates/sysmlv2-cbor/Cargo.toml b/crates/sysmlv2-cbor/Cargo.toml
index cf12fa8..fdfba08 100644
--- a/crates/sysmlv2-cbor/Cargo.toml
+++ b/crates/sysmlv2-cbor/Cargo.toml
@@ -12,7 +12,7 @@ repository.workspace = true
 include = ["src/**", "Cargo.toml", "README.md"]
 
 [dependencies]
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
 serde_json.workspace = true
 uuid.workspace = true
 
diff --git a/crates/sysmlv2-cbor/src/decode.rs b/crates/sysmlv2-cbor/src/decode.rs
index 1451c27..7bdc21e 100644
--- a/crates/sysmlv2-cbor/src/decode.rs
+++ b/crates/sysmlv2-cbor/src/decode.rs
@@ -371,13 +371,17 @@ fn decode(
     }
     // The derivation-scheme axis gates only payloads that actually
     // derive ids; explicit-id payloads decode regardless of it.
-    if elided && scheme != crate::ID_SCHEME_VERSION {
+    if elided
+        && !matches!(
+            scheme,
+            crate::ID_SCHEME_VERSION | crate::CANONICAL_GRAPH_VERSION
+        )
+    {
         return Err(Error::of(
             ErrorKind::UnsupportedVersion,
             format!(
-                "id-derivation scheme {scheme} unsupported (decoder carries {}); \
-                 the payload's ids cannot be recovered here",
-                crate::ID_SCHEME_VERSION
+                "id-derivation scheme {scheme} unsupported (decoder carries 2 and 3); \
+                 the payload's ids cannot be recovered here"
             ),
         ));
     }
@@ -543,6 +547,13 @@ fn decode(
             .collect();
         patch_placeholders(&mut value, &map);
     }
+    if scheme == crate::CANONICAL_GRAPH_VERSION && !full {
+        sysmlv2_model::migration::validate_graph_format(
+            &value,
+            sysmlv2_model::model::GraphFormat::CanonicalV3,
+        )
+        .map_err(Error::new)?;
+    }
     Ok((value, units))
 }
 
@@ -606,3 +617,51 @@ pub fn from_cbor_with_units(
 pub fn from_compact_cbor_units(bytes: &[u8]) -> Result<(Value, Vec<(u64, String)>), Error> {
     decode(bytes, Some(false), None)
 }
+
+/// Read the lowering/identity contract from the header without decoding the body.
+/// This is metadata only; decoding still validates the payload. The original
+/// explicit-ID scheme 1 uses the legacy graph shape. For compatibility,
+/// unrecognized explicit-ID schemes also select legacy; unknown elided schemes
+/// are refused because their identities cannot be recovered.
+pub fn graph_format(bytes: &[u8]) -> Result<sysmlv2_model::model::GraphFormat, Error> {
+    let mut r = Reader::new(crate::strip_magic(bytes)?);
+    r.array()?;
+    let (scheme, flags) = parse_header(r.uint()?)?;
+    match scheme {
+        1 | 2 => Ok(sysmlv2_model::model::GraphFormat::LegacyV2),
+        3 => Ok(sysmlv2_model::model::GraphFormat::CanonicalV3),
+        _ if flags & FLAG_ELIDE_IDS == 0 => Ok(sysmlv2_model::model::GraphFormat::LegacyV2),
+        _ => Err(Error::of(
+            ErrorKind::UnsupportedVersion,
+            "unknown authored graph format",
+        )),
+    }
+}
+
+/// Reject a payload whose header names a different lowering/identity contract.
+/// The caller must still decode or apply it to validate its contents.
+pub fn assert_graph_format(
+    bytes: &[u8],
+    expected: sysmlv2_model::model::GraphFormat,
+) -> Result<(), Error> {
+    if graph_format(bytes)? != expected {
+        return Err(Error::new(
+            "payload graph format differs from session; migrate or open a matching session",
+        ));
+    }
+    Ok(())
+}
+
+/// Decoded compact graph, source-unit paths, and authored graph-format contract.
+pub type DecodedCompactGraph = (Value, Vec<(u64, String)>, sysmlv2_model::model::GraphFormat);
+
+/// Decode a compact snapshot while retaining its graph-format choice for loading.
+/// Explicit-ID legacy compatibility follows [`graph_format`].
+pub fn from_cbor_with_format(
+    bytes: &[u8],
+    external_name: &dyn Fn(&str) -> Option<String>,
+) -> Result<DecodedCompactGraph, Error> {
+    let format = graph_format(bytes)?;
+    let (value, units) = decode(bytes, Some(false), Some(&external_name))?;
+    Ok((value, units, format))
+}
diff --git a/crates/sysmlv2-cbor/src/delta.rs b/crates/sysmlv2-cbor/src/delta.rs
index 97dabd1..046c9d5 100644
--- a/crates/sysmlv2-cbor/src/delta.rs
+++ b/crates/sysmlv2-cbor/src/delta.rs
@@ -73,6 +73,9 @@ pub enum Claim {
 #[derive(Default)]
 #[non_exhaustive]
 pub struct DeltaOptions {
+    /// Lowering/identity contract for both base and target. Canonical graphs
+    /// are validated before encoding and after application.
+    pub graph_format: sysmlv2_model::model::GraphFormat,
     /// Id-keyed identities and external base references — larger, but
     /// applicable best-effort to a divergent base.
     pub portable: bool,
@@ -98,6 +101,13 @@ impl DeltaOptions {
         Self::default()
     }
 
+    /// Set the lowering/identity contract for this delta.
+    #[must_use]
+    pub fn with_graph_format(mut self, format: sysmlv2_model::model::GraphFormat) -> Self {
+        self.graph_format = format;
+        self
+    }
+
     /// Set [`Self::portable`].
     #[must_use]
     pub fn with_portable(mut self, portable: bool) -> Self {
@@ -795,6 +805,12 @@ fn delta_encode(
     opts: &DeltaOptions,
     elide: Option<Resolver>,
 ) -> Result<Vec<u8>, Error> {
+    if opts.graph_format == sysmlv2_model::model::GraphFormat::CanonicalV3 {
+        sysmlv2_model::migration::validate_graph_format(base, opts.graph_format)
+            .map_err(Error::new)?;
+        sysmlv2_model::migration::validate_graph_format(target, opts.graph_format)
+            .map_err(Error::new)?;
+    }
     let base_arr = canonical_views(base)?;
     let target_arr = canonical_views(target)?;
     let base_digest = digest_of_canonical(&base_arr)?;
@@ -1031,7 +1047,10 @@ fn delta_encode(
         } else {
             crate::encode::FLAG_UNIT_PATHS
         };
-    w.uint(crate::encode::header_word(flags));
+    w.uint(crate::encode::header_word_with_scheme(
+        flags,
+        opts.graph_format.version(),
+    ));
     w.array(3);
     w.bstr(base_digest.as_bytes());
     w.bstr(result_digest.as_bytes());
@@ -1222,13 +1241,17 @@ fn apply(
     if elided && portable {
         return Err(Error::new("id elision applies to strict deltas only"));
     }
-    if elided && scheme != crate::ID_SCHEME_VERSION {
+    if elided
+        && !matches!(
+            scheme,
+            crate::ID_SCHEME_VERSION | crate::CANONICAL_GRAPH_VERSION
+        )
+    {
         return Err(Error::of(
             ErrorKind::UnsupportedVersion,
             format!(
-                "id-derivation scheme {scheme} unsupported (decoder carries {}); \
-                 the delta's created ids cannot be recovered here",
-                crate::ID_SCHEME_VERSION
+                "id-derivation scheme {scheme} unsupported (decoder carries 2 and 3); \
+                 the delta's created ids cannot be recovered here"
             ),
         ));
     }
@@ -1659,6 +1682,18 @@ fn apply(
     {
         return Err(Error::new("unit root index out of range"));
     }
+    if scheme == crate::CANONICAL_GRAPH_VERSION {
+        sysmlv2_model::migration::validate_graph_format(
+            base,
+            sysmlv2_model::model::GraphFormat::CanonicalV3,
+        )
+        .map_err(Error::new)?;
+        sysmlv2_model::migration::validate_graph_format(
+            &value,
+            sysmlv2_model::model::GraphFormat::CanonicalV3,
+        )
+        .map_err(Error::new)?;
+    }
     report.units = units;
     Ok((value, report))
 }
diff --git a/crates/sysmlv2-cbor/src/describe.rs b/crates/sysmlv2-cbor/src/describe.rs
index 5aa69c4..39f7cee 100644
--- a/crates/sysmlv2-cbor/src/describe.rs
+++ b/crates/sysmlv2-cbor/src/describe.rs
@@ -41,7 +41,7 @@ fn uuid16(r: &mut Reader) -> Result<Uuid, Error> {
 ///   "form": "compact" | "full" | "delta",
 ///   "explicitIds": bool (compact: the ids are not all graph-derived),
 ///   "bytes": 1234,
-///   "versions": { "layout": 1, "tables": 1, "scheme": 1,
+///   "versions": { "layout": 1, "tables": 1, "scheme": 2,
 ///                 "supported": true },
 ///   // snapshots:
 ///   "elements": 91319, "externals": 2, "idsElided": false,
@@ -103,7 +103,9 @@ pub fn describe(bytes: &[u8]) -> Result<Value, Error> {
             | crate::FLAG_EXPLICIT_IDS,
     )?;
     let supported = tables == crate::tables::CBOR_TABLES_VERSION
-        && (!elided || scheme == crate::ID_SCHEME_VERSION);
+        && (!elided
+            || scheme == crate::ID_SCHEME_VERSION
+            || scheme == crate::CANONICAL_GRAPH_VERSION);
     let mut out = Map::new();
     out.insert(
         "form".into(),
diff --git a/crates/sysmlv2-cbor/src/encode.rs b/crates/sysmlv2-cbor/src/encode.rs
index ac1b8d8..2f0e403 100644
--- a/crates/sysmlv2-cbor/src/encode.rs
+++ b/crates/sysmlv2-cbor/src/encode.rs
@@ -115,10 +115,10 @@ where
 /// packed big-endian into one uint. Decoders refuse `layout`
 /// unconditionally, `tables` whenever they decode element records,
 /// and `scheme` only when id derivation is in play (elided payloads).
-pub(crate) fn header_word(flags: u8) -> u64 {
+pub(crate) fn header_word_with_scheme(flags: u8, scheme: u8) -> u64 {
     (crate::LAYOUT_VERSION as u64) << 32
         | (crate::tables::CBOR_TABLES_VERSION as u64) << 16
-        | (crate::ID_SCHEME_VERSION as u64) << 8
+        | (scheme as u64) << 8
         | flags as u64
 }
 
@@ -538,7 +538,14 @@ fn encode(
     units: &[(usize, String)],
     implied_owners: bool,
 ) -> Result<Vec<u8>, Error> {
-    encode_flagged(elements, full, units, implied_owners, 0)
+    encode_flagged(
+        elements,
+        full,
+        units,
+        implied_owners,
+        0,
+        crate::ID_SCHEME_VERSION,
+    )
 }
 
 fn encode_flagged(
@@ -547,6 +554,7 @@ fn encode_flagged(
     units: &[(usize, String)],
     implied_owners: bool,
     extra_flags: u8,
+    scheme: u8,
 ) -> Result<Vec<u8>, Error> {
     let elems = elems_of(elements, table_set(full))?;
     let units = check_units(units, elems.len())?;
@@ -563,7 +571,7 @@ fn encode_flagged(
     }
     let mut w = Writer::with_magic_for(elems.len());
     w.array(4 + usize::from(implied) + usize::from(units.is_some()));
-    w.uint(header_word(flags));
+    w.uint(header_word_with_scheme(flags, scheme));
     w.array(interner.ext.len());
     for u in &interner.ext {
         w.bstr(u.as_bytes());
@@ -596,7 +604,10 @@ pub fn to_compact_cbor(value: &Value) -> Result<Vec<u8>, Error> {
 /// [`FLAG_IMPLIED_OWNERS`]. State digests canonicalize through this,
 /// so wire-format elision never moves a digest. Not a wire emitter.
 pub(crate) fn to_compact_cbor_canonical(elements: &[&Value]) -> Result<Vec<u8>, Error> {
-    encode(elements, false, &[], false)
+    // This encodes explicit ids for hashing, with no id derivation. Keep
+    // the original scheme stamp so a wire scheme change cannot invalidate
+    // persisted state digests or explicit-id deltas.
+    encode_flagged(elements, false, &[], false, 0, 1)
 }
 
 /// [`to_compact_cbor`] carrying the model's **unit structure**: each
@@ -624,6 +635,7 @@ pub fn to_compact_cbor_with_units_explicit(
         units,
         true,
         FLAG_EXPLICIT_IDS,
+        crate::ID_SCHEME_VERSION,
     )
 }
 
@@ -666,6 +678,78 @@ pub fn to_compact_cbor_elided_with_units(
     value: &Value,
     external_name: &dyn Fn(&str) -> Option<String>,
     units: &[(usize, String)],
+) -> Result<Vec<u8>, Error> {
+    encode_elided(value, external_name, units, crate::ID_SCHEME_VERSION)
+}
+
+/// Encode a validated authored graph with an explicit lowering/identity contract.
+/// Existing encoding functions retain their legacy scheme stamp.
+pub fn to_compact_cbor_with_format(
+    value: &Value,
+    units: &[(usize, String)],
+    format: sysmlv2_model::model::GraphFormat,
+) -> Result<Vec<u8>, Error> {
+    sysmlv2_model::migration::validate_graph_format(value, format).map_err(Error::new)?;
+    encode_flagged(
+        &element_views(value)?,
+        false,
+        units,
+        true,
+        0,
+        format.version(),
+    )
+}
+
+/// Explicit-ID counterpart of [`to_compact_cbor_with_format`].
+pub fn to_compact_cbor_explicit_with_format(
+    value: &Value,
+    units: &[(usize, String)],
+    format: sysmlv2_model::model::GraphFormat,
+) -> Result<Vec<u8>, Error> {
+    sysmlv2_model::migration::validate_graph_format(value, format).map_err(Error::new)?;
+    encode_flagged(
+        &element_views(value)?,
+        false,
+        units,
+        true,
+        FLAG_EXPLICIT_IDS,
+        format.version(),
+    )
+}
+
+/// Full-form emit view with an explicit lowering/identity contract.
+/// The caller supplies the format used to build the full graph.
+pub fn to_full_cbor_with_format(
+    value: &Value,
+    units: &[(usize, String)],
+    format: sysmlv2_model::model::GraphFormat,
+) -> Result<Vec<u8>, Error> {
+    encode_flagged(
+        &element_views(value)?,
+        true,
+        units,
+        false,
+        0,
+        format.version(),
+    )
+}
+
+/// ID-elided counterpart of [`to_compact_cbor_with_format`].
+pub fn to_compact_cbor_elided_with_format(
+    value: &Value,
+    external_name: &dyn Fn(&str) -> Option<String>,
+    units: &[(usize, String)],
+    format: sysmlv2_model::model::GraphFormat,
+) -> Result<Vec<u8>, Error> {
+    sysmlv2_model::migration::validate_graph_format(value, format).map_err(Error::new)?;
+    encode_elided(value, external_name, units, format.version())
+}
+
+fn encode_elided(
+    value: &Value,
+    external_name: &dyn Fn(&str) -> Option<String>,
+    units: &[(usize, String)],
+    scheme: u8,
 ) -> Result<Vec<u8>, Error> {
     let elements = element_views(value)?;
     let elems = elems_of(&elements, table_set(false))?;
@@ -686,7 +770,7 @@ pub fn to_compact_cbor_elided_with_units(
     }
     let mut w = Writer::with_magic_for(elems.len());
     w.array(5 + usize::from(units.is_some()));
-    w.uint(header_word(flags));
+    w.uint(header_word_with_scheme(flags, scheme));
     w.array(interner.ext.len());
     for u in &interner.ext {
         w.bstr(u.as_bytes());
diff --git a/crates/sysmlv2-cbor/src/lib.rs b/crates/sysmlv2-cbor/src/lib.rs
index 3f474f5..aa06938 100644
--- a/crates/sysmlv2-cbor/src/lib.rs
+++ b/crates/sysmlv2-cbor/src/lib.rs
@@ -28,9 +28,10 @@ pub mod index;
 pub mod resolver;
 
 pub use canonical::{canonicalize_compact, graph_normalize, graph_normalize_compact};
+pub use decode::{DecodedCompactGraph, from_cbor_with_format};
 pub use decode::{
-    from_cbor, from_cbor_with, from_cbor_with_units, from_compact_cbor, from_compact_cbor_elided,
-    from_compact_cbor_units, from_full_cbor,
+    assert_graph_format, from_cbor, from_cbor_with, from_cbor_with_units, from_compact_cbor,
+    from_compact_cbor_elided, from_compact_cbor_units, from_full_cbor, graph_format,
 };
 pub use delta::{
     ApplyReport, Claim, DeltaOptions, FLAG_DELTA, FLAG_DELTA_PORTABLE, apply_delta_cbor,
@@ -41,9 +42,10 @@ pub use delta::{
 pub use describe::describe;
 pub use encode::{
     FLAG_ELIDE_IDS, FLAG_EXPLICIT_IDS, FLAG_FULL_FORM, FLAG_IMPLIED_OWNERS, FLAG_UNIT_PATHS,
-    to_compact_cbor, to_compact_cbor_elided, to_compact_cbor_elided_with_units,
-    to_compact_cbor_with_units, to_compact_cbor_with_units_explicit, to_full_cbor,
-    to_full_cbor_with_units,
+    to_compact_cbor, to_compact_cbor_elided, to_compact_cbor_elided_with_format,
+    to_compact_cbor_elided_with_units, to_compact_cbor_explicit_with_format,
+    to_compact_cbor_with_format, to_compact_cbor_with_units, to_compact_cbor_with_units_explicit,
+    to_full_cbor, to_full_cbor_with_format, to_full_cbor_with_units,
 };
 pub use sysmlv2_model::cbor_tables as tables;
 
@@ -72,7 +74,10 @@ pub const LAYOUT_VERSION: u8 = 1;
 /// of `IDS.md`). Consulted only where derivation is actually in play
 /// — id-elided payloads, snapshot or delta — so a scheme change never
 /// blocks decoding payloads that carry their ids explicitly.
-pub const ID_SCHEME_VERSION: u8 = 1;
+pub const ID_SCHEME_VERSION: u8 = 2;
+/// Opt-in authored conditional graph contract. The graph derivation algorithm is
+/// shared with scheme 2; wrappers change its input graph and therefore identities.
+pub const CANONICAL_GRAPH_VERSION: u8 = 3;
 
 pub(crate) fn strip_magic(bytes: &[u8]) -> Result<&[u8], Error> {
     match bytes.strip_prefix(MAGIC) {
diff --git a/crates/sysmlv2-cbor/src/resolver.rs b/crates/sysmlv2-cbor/src/resolver.rs
index 9eb26a2..2702209 100644
--- a/crates/sysmlv2-cbor/src/resolver.rs
+++ b/crates/sysmlv2-cbor/src/resolver.rs
@@ -140,6 +140,14 @@ impl StdlibResolver {
     /// Refuse an artifact generated under different codec axes than
     /// this build decodes with — same doctrine as the wire header.
     pub fn assert_compatible(&self) -> Result<(), Error> {
+        self.assert_compatible_with_format(sysmlv2_model::model::GraphFormat::LegacyV2)
+    }
+
+    /// Require the resolver's graph contract to match the consuming model.
+    pub fn assert_compatible_with_format(
+        &self,
+        format: sysmlv2_model::model::GraphFormat,
+    ) -> Result<(), Error> {
         if self.tables_version != crate::tables::CBOR_TABLES_VERSION {
             return Err(Error::of(
                 ErrorKind::UnsupportedVersion,
@@ -150,13 +158,13 @@ impl StdlibResolver {
                 ),
             ));
         }
-        if self.scheme_version != crate::ID_SCHEME_VERSION {
+        if self.scheme_version != format.version() {
             return Err(Error::of(
                 ErrorKind::UnsupportedVersion,
                 format!(
                     "resolver artifact id-scheme version {} unsupported (this build carries {})",
                     self.scheme_version,
-                    crate::ID_SCHEME_VERSION
+                    format.version()
                 ),
             ));
         }
diff --git a/crates/sysmlv2-cbor/tests/canonical_constructors.rs b/crates/sysmlv2-cbor/tests/canonical_constructors.rs
new file mode 100644
index 0000000..22715dc
--- /dev/null
+++ b/crates/sysmlv2-cbor/tests/canonical_constructors.rs
@@ -0,0 +1,153 @@
+use std::collections::{HashMap, HashSet};
+use sysmlv2_model::{
+    json::{model_to_compact_json, model_to_compact_json_with_units},
+    loader::{load_document_with_format, overlay_explicit_ids},
+    migration::{migrate_conditional_graph, validate_graph_format},
+    model::{GraphFormat, Model},
+};
+
+const TEXT: &str = "class Point {feature x; feature y;} feature empty=new Point(); feature positional=new Point(1,2); feature named=new Point(y=3,x=4); feature nested=new Point(x=if true ? new Point(5) else new Point(x=6)); class Holder {feature t:Point;} feature h:Holder; feature chained=new h.t(9);";
+
+fn model(format: GraphFormat) -> Model {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_source("constructors.kerml", TEXT)
+            .diagnostics
+            .is_empty()
+    );
+    model
+}
+
+#[test]
+fn nested_constructor_migration_preserves_rows_and_does_not_capture_argument_ids() {
+    let legacy = model_to_compact_json(&model(GraphFormat::LegacyV2));
+    let canonical = model_to_compact_json(&model(GraphFormat::CanonicalV3));
+    let migrated = migrate_conditional_graph(&legacy, &|_| None).unwrap();
+    assert_eq!(migrated.document, canonical);
+    validate_graph_format(&canonical, GraphFormat::CanonicalV3).unwrap();
+    let old_arguments: HashSet<_> = legacy
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter(|row| row["@type"] == "ParameterMembership")
+        .flat_map(|row| {
+            [
+                row["@id"].as_str().unwrap(),
+                row["ownedRelatedElement"][0]["@id"].as_str().unwrap(),
+            ]
+        })
+        .collect();
+    for row in canonical
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter(|row| row["@type"] == "ReturnParameterMembership")
+    {
+        assert!(!old_arguments.contains(row["@id"].as_str().unwrap()));
+        assert!(!old_arguments.contains(row["ownedRelatedElement"][0]["@id"].as_str().unwrap()));
+    }
+    for (i, &j) in migrated.element_indices.iter().enumerate() {
+        assert_eq!(legacy[i]["@type"], canonical[j]["@type"]);
+    }
+}
+
+#[test]
+fn canonical_constructor_compact_and_full_replay_preserve_argument_ownership() {
+    let model = model(GraphFormat::CanonicalV3);
+    let expected = model_to_compact_json(&model);
+    for document in [
+        expected.clone(),
+        sysmlv2_model::full::model_to_full_json(&model),
+    ] {
+        let (loaded, _, ids, warnings) =
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                .unwrap();
+        assert!(warnings.is_empty(), "{warnings:?}");
+        let mut replay = model_to_compact_json(&loaded);
+        overlay_explicit_ids(&mut replay, &ids);
+        assert_eq!(
+            replay.as_array().unwrap().len(),
+            expected.as_array().unwrap().len()
+        );
+        for (actual, expected) in replay
+            .as_array()
+            .unwrap()
+            .iter()
+            .zip(expected.as_array().unwrap())
+        {
+            for (key, value) in expected.as_object().unwrap() {
+                assert_eq!(&actual[key], value, "{key} on {}", expected["@type"]);
+            }
+        }
+        assert!(
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::LegacyV2).is_err()
+        );
+    }
+}
+
+#[test]
+fn canonical_constructor_explicit_and_elided_binary_snapshots_replay_exactly() {
+    let (document, units) = model_to_compact_json_with_units(&model(GraphFormat::CanonicalV3));
+    for elided in [false, true] {
+        let bytes = if elided {
+            sysmlv2_cbor::to_compact_cbor_elided_with_format(
+                &document,
+                &|_| None,
+                &units,
+                GraphFormat::CanonicalV3,
+            )
+        } else {
+            sysmlv2_cbor::to_compact_cbor_with_format(&document, &units, GraphFormat::CanonicalV3)
+        }
+        .unwrap();
+        let (decoded, _, format) = sysmlv2_cbor::from_cbor_with_format(&bytes, &|_| None).unwrap();
+        assert_eq!(format, GraphFormat::CanonicalV3);
+        assert_eq!(decoded, document);
+    }
+}
+
+#[test]
+fn canonical_constructors_keep_library_preparation_and_full_replay_equivalent() {
+    let mut cold = Model::with_graph_format(GraphFormat::CanonicalV3);
+    cold.load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    cold.record_library_cache();
+    let prepared = cold.prepare_library().unwrap();
+    let cache = cold.take_recorded_library_cache().unwrap();
+    let encoded = prepared.to_bytes(29).unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_model::prepared::PreparedLibrary::from_bytes(&encoded, 29).unwrap(),
+    );
+    let mut recorded = Model::with_graph_format(GraphFormat::CanonicalV3);
+    recorded
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    recorded.set_library_cache(cache);
+    let mut warm = Model::with_graph_format(GraphFormat::CanonicalV3);
+    prepared.install(&mut warm).unwrap();
+    let mut restored = Model::with_graph_format(GraphFormat::CanonicalV3);
+    decoded.install(&mut restored).unwrap();
+    let mut compact = None;
+    let mut full = None;
+    for model in [&mut cold, &mut recorded, &mut warm, &mut restored] {
+        model.add_source("constructors.kerml", TEXT);
+        let actual = model_to_compact_json(model);
+        if let Some(ref expected) = compact {
+            assert_eq!(&actual, expected);
+        } else {
+            compact = Some(actual);
+        }
+        let actual = sysmlv2_model::full::model_to_full_json(model);
+        sysmlv2_model::migration::validate_conditional_graph_format(
+            &actual,
+            GraphFormat::CanonicalV3,
+        )
+        .unwrap();
+        if let Some(ref expected) = full {
+            assert_eq!(&actual, expected);
+        } else {
+            full = Some(actual);
+        }
+    }
+}
diff --git a/crates/sysmlv2-cbor/tests/conditional_graph.rs b/crates/sysmlv2-cbor/tests/conditional_graph.rs
new file mode 100644
index 0000000..9e5ffe5
--- /dev/null
+++ b/crates/sysmlv2-cbor/tests/conditional_graph.rs
@@ -0,0 +1,288 @@
+use serde_json::json;
+use std::collections::HashMap;
+use sysmlv2_model::{
+    eval::Value as EvalValue,
+    json::{ResolvedModel, model_to_compact_json, model_to_compact_json_with_units},
+    loader::{load_document, load_document_with_format, overlay_explicit_ids},
+    migration::{migrate_conditional_graph, validate_graph_format},
+    model::{GraphFormat, Model},
+};
+
+const TEXT: &str = "package P { attribute a = false and (1/0 == 1); attribute b = true or (1/0 == 1); attribute c = false implies (1/0 == 1); attribute d = 7 ?? (1/0); attribute e = if true ? (if false ? 1/0 else 8) else 1/0; attribute f = null ?? 9; }";
+fn model(format: GraphFormat) -> Model {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_source("conditionals.sysml", TEXT)
+            .diagnostics
+            .is_empty()
+    );
+    model
+}
+fn evaluate(r: &mut ResolvedModel) {
+    for (name, expected) in [
+        ("a", EvalValue::Boolean(false)),
+        ("b", EvalValue::Boolean(true)),
+        ("c", EvalValue::Boolean(true)),
+        ("d", EvalValue::Integer(7)),
+        ("e", EvalValue::Integer(8)),
+        ("f", EvalValue::Integer(9)),
+    ] {
+        assert_eq!(r.evaluate_qualified(&format!("P::{name}")), Ok(expected));
+    }
+}
+#[test]
+fn migration_matches_canonical_lowering_and_preserves_short_circuiting() {
+    let legacy = model(GraphFormat::LegacyV2);
+    let canonical = model(GraphFormat::CanonicalV3);
+    let before = model_to_compact_json(&legacy);
+    let snapshot = before.clone();
+    let expected = model_to_compact_json(&canonical);
+    let migration = migrate_conditional_graph(&before, &|_| None).unwrap();
+    assert_eq!(before, snapshot);
+    assert_eq!(
+        migration.document.as_array().unwrap().len(),
+        expected.as_array().unwrap().len()
+    );
+    for (i, (actual, expected)) in migration
+        .document
+        .as_array()
+        .unwrap()
+        .iter()
+        .zip(expected.as_array().unwrap())
+        .enumerate()
+    {
+        assert_eq!(actual, expected, "row {i}");
+    }
+    assert_eq!(migration.added.len(), 18);
+    assert_eq!(migration.ids.len(), before.as_array().unwrap().len());
+    for (i, &j) in migration.element_indices.iter().enumerate() {
+        assert_eq!(before[i]["@type"], expected[j]["@type"]);
+        assert_eq!(
+            migration.ids[&uuid::Uuid::parse_str(before[i]["@id"].as_str().unwrap()).unwrap()]
+                .to_string(),
+            expected[j]["@id"]
+        );
+    }
+    assert!(validate_graph_format(&expected, GraphFormat::LegacyV2).is_err());
+    assert!(validate_graph_format(&before, GraphFormat::CanonicalV3).is_err());
+    assert!(migrate_conditional_graph(&expected, &|_| None).is_err());
+    evaluate(&mut ResolvedModel::build(&legacy));
+    evaluate(&mut ResolvedModel::build(&canonical));
+    let (_, mut legacy_replay, _, warnings) = load_document(&before, &HashMap::new()).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    evaluate(&mut legacy_replay);
+    let (loaded, mut replay, ids, warnings) =
+        load_document_with_format(&expected, &HashMap::new(), GraphFormat::CanonicalV3).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let mut after = model_to_compact_json(&loaded);
+    overlay_explicit_ids(&mut after, &ids);
+    assert_eq!(after, expected);
+    evaluate(&mut replay);
+    let full = sysmlv2_model::full::model_to_full_json(&canonical);
+    let (loaded, mut replay, ids, warnings) =
+        load_document_with_format(&full, &HashMap::new(), GraphFormat::CanonicalV3).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let mut after = model_to_compact_json(&loaded);
+    overlay_explicit_ids(&mut after, &ids);
+    assert_eq!(
+        after.as_array().unwrap().len(),
+        expected.as_array().unwrap().len()
+    );
+    for (i, (actual, original)) in after
+        .as_array()
+        .unwrap()
+        .iter()
+        .zip(expected.as_array().unwrap())
+        .enumerate()
+    {
+        for (key, value) in original.as_object().unwrap() {
+            assert_eq!(&actual[key], value, "row {i}, {key}");
+        }
+    }
+    evaluate(&mut replay);
+}
+#[test]
+fn binary_format_and_unit_paths_survive_both_snapshot_encodings() {
+    let canonical = model(GraphFormat::CanonicalV3);
+    let (document, units) = model_to_compact_json_with_units(&canonical);
+    for elided in [false, true] {
+        let bytes = if elided {
+            sysmlv2_cbor::to_compact_cbor_elided_with_format(
+                &document,
+                &|_| None,
+                &units,
+                GraphFormat::CanonicalV3,
+            )
+        } else {
+            sysmlv2_cbor::to_compact_cbor_with_format(&document, &units, GraphFormat::CanonicalV3)
+        }
+        .unwrap();
+        assert_eq!(
+            sysmlv2_cbor::describe(&bytes).unwrap()["versions"]["scheme"],
+            3
+        );
+        let (decoded, decoded_units, format) =
+            sysmlv2_cbor::from_cbor_with_format(&bytes, &|_| None).unwrap();
+        assert_eq!(decoded, document);
+        assert_eq!(
+            decoded_units,
+            units
+                .iter()
+                .map(|(i, n)| (*i as u64, n.clone()))
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(format, GraphFormat::CanonicalV3);
+        let (_, mut replay, _, warnings) =
+            load_document_with_format(&decoded, &HashMap::new(), format).unwrap();
+        assert!(warnings.is_empty(), "{warnings:?}");
+        evaluate(&mut replay);
+    }
+}
+#[test]
+fn migration_updates_inbound_references_simultaneously_and_refuses_bad_ownership() {
+    let mut before = model_to_compact_json(&model(GraphFormat::LegacyV2));
+    // An existing non-ownership reference may point at the moved operand.
+    let migration = migrate_conditional_graph(&before, &|_| None).unwrap();
+    let old = *migration.ids.iter().find(|(a, b)| a != b).unwrap().0;
+    let alias = uuid::Uuid::new_v5(
+        &uuid::Uuid::parse_str(before[0]["@id"].as_str().unwrap()).unwrap(),
+        b"::alias",
+    );
+    let root = before[0]["@id"].clone();
+    before[0]["ownedRelationship"]
+        .as_array_mut()
+        .unwrap()
+        .push(json!({"@id":alias}));
+    before.as_array_mut().unwrap().push(json!({"@id":alias,"@type":"Membership","isImplied":false,"ownedRelationship":[],"ownedRelatedElement":[],"owningRelationship":null,"owningRelatedElement":{"@id":root},"memberElement":{"@id":old},"memberName":"alias"}));
+    let migrated = migrate_conditional_graph(&before, &|_| None).unwrap();
+    assert!(
+        migrated
+            .document
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|r| r.get("memberElement") == Some(&json!({"@id": migrated.ids[&old]})))
+    );
+    let mut malformed = before.clone();
+    malformed.as_array_mut().unwrap().push(before[1].clone());
+    assert!(migrate_conditional_graph(&malformed, &|_| None).is_err());
+    let mut malformed = before.clone();
+    let child = malformed
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|r| r["owningRelationship"].is_object())
+        .unwrap();
+    child["owningRelationship"] = json!({"@id":uuid::Uuid::nil()});
+    assert!(migrate_conditional_graph(&malformed, &|_| None).is_err());
+}
+#[test]
+fn prepared_and_resolution_caches_keep_their_graph_contract() {
+    let source = "standard library package L { feature value = if true ? 1 else 2; }";
+    let mut legacy = Model::new();
+    legacy.add_library_source("library.kerml", source);
+    legacy.record_library_cache();
+    ResolvedModel::build(&legacy);
+    let cache = legacy.take_recorded_library_cache().unwrap();
+    let prepared = legacy.prepare_library().unwrap();
+    let mut canonical = Model::with_graph_format(GraphFormat::CanonicalV3);
+    assert!(prepared.install(&mut canonical).is_err());
+    canonical.add_library_source("library.kerml", source);
+    canonical.set_library_cache(cache);
+    let actual = sysmlv2_model::json::library_to_compact_json(&canonical);
+    let mut cold = Model::with_graph_format(GraphFormat::CanonicalV3);
+    cold.add_library_source("library.kerml", source);
+    assert_eq!(actual, sysmlv2_model::json::library_to_compact_json(&cold));
+    let prepared = cold.prepare_library().unwrap();
+    let bytes = prepared.to_bytes(71).unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_model::prepared::PreparedLibrary::from_bytes(&bytes, 71).unwrap(),
+    );
+    assert_eq!(decoded.graph_format(), GraphFormat::CanonicalV3);
+    let mut restored = Model::with_graph_format(GraphFormat::CanonicalV3);
+    decoded.install(&mut restored).unwrap();
+    assert_eq!(
+        actual,
+        sysmlv2_model::json::library_to_compact_json(&restored)
+    );
+}
+
+#[test]
+fn supplied_sources_migrate_to_the_same_canonical_graph() {
+    let root = sysmlv2_testkit::corpus_root();
+    let mut legacy = Model::new();
+    let mut canonical = Model::with_graph_format(GraphFormat::CanonicalV3);
+    for file in sysmlv2_testkit::user_files() {
+        let name = sysmlv2_testkit::relative_source_name(&root, &file);
+        let text = std::fs::read_to_string(file).unwrap();
+        legacy.add_source(name.clone(), &text);
+        canonical.add_source(name, &text);
+    }
+    let before = model_to_compact_json(&legacy);
+    let expected = model_to_compact_json(&canonical);
+    let migration = migrate_conditional_graph(&before, &|_| None).unwrap();
+    assert_eq!(
+        migration.document.as_array().unwrap().len(),
+        expected.as_array().unwrap().len()
+    );
+    for (i, (actual, expected)) in migration
+        .document
+        .as_array()
+        .unwrap()
+        .iter()
+        .zip(expected.as_array().unwrap())
+        .enumerate()
+    {
+        assert_eq!(actual, expected, "row {i}");
+    }
+    assert!(!migration.added.is_empty());
+    let bytes = sysmlv2_cbor::to_compact_cbor_elided_with_format(
+        &expected,
+        &|_| None,
+        &[],
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert_eq!(
+        sysmlv2_cbor::from_cbor_with_format(&bytes, &|_| None)
+            .unwrap()
+            .0,
+        expected
+    );
+}
+
+#[test]
+fn canonical_standard_library_cold_recorded_and_prepared_replay_agree() {
+    let mut cold = Model::with_graph_format(GraphFormat::CanonicalV3);
+    cold.load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    cold.record_library_cache();
+    let prepared = cold.prepare_library().unwrap();
+    let cache = cold.take_recorded_library_cache().unwrap();
+    let library = sysmlv2_model::json::library_to_compact_json(&cold);
+    validate_graph_format(&library, GraphFormat::CanonicalV3).unwrap();
+    let mut recorded = Model::with_graph_format(GraphFormat::CanonicalV3);
+    recorded
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    recorded.set_library_cache(cache);
+    assert_eq!(
+        sysmlv2_model::json::library_to_compact_json(&recorded),
+        library
+    );
+    let mut warm = Model::with_graph_format(GraphFormat::CanonicalV3);
+    prepared.install(&mut warm).unwrap();
+    for m in [&mut cold, &mut recorded, &mut warm] {
+        m.add_source("conditionals.sysml", TEXT);
+    }
+    let expected = model_to_compact_json(&cold);
+    assert_eq!(model_to_compact_json(&recorded), expected);
+    assert_eq!(model_to_compact_json(&warm), expected);
+    evaluate(&mut ResolvedModel::build(&cold));
+    evaluate(&mut ResolvedModel::build(&recorded));
+    evaluate(&mut ResolvedModel::build(&warm));
+    let full = sysmlv2_model::full::model_to_full_json(&warm);
+    sysmlv2_model::migration::validate_conditional_graph_format(&full, GraphFormat::CanonicalV3)
+        .unwrap();
+}
diff --git a/crates/sysmlv2-cbor/tests/connector_end_defaults.rs b/crates/sysmlv2-cbor/tests/connector_end_defaults.rs
new file mode 100644
index 0000000..69e0770
--- /dev/null
+++ b/crates/sysmlv2-cbor/tests/connector_end_defaults.rs
@@ -0,0 +1,71 @@
+use sysmlv2_cbor::{from_compact_cbor, from_full_cbor, to_compact_cbor, to_full_cbor};
+use sysmlv2_parser::{
+    full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json},
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+
+#[test]
+fn connector_end_owned_defaults_survive_full_cbor_without_changing_source_transport() {
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "ends.kerml",
+                "class A { end feature x; end feature y; connector c from x to y; }"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let compact = model_to_compact_json(&model);
+    let source_bytes = to_compact_cbor(&compact).unwrap();
+    assert_eq!(from_compact_cbor(&source_bytes).unwrap(), compact);
+    let mut resolved = ResolvedModel::build(&model);
+    for closures in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        let full = resolved_to_full_json(
+            &mut resolved,
+            &model,
+            EmissionPolicy {
+                unresolved: UnresolvedReferencePolicy::Reject,
+                closures,
+            },
+        )
+        .unwrap();
+        let decoded = from_full_cbor(&to_full_cbor(&full).unwrap()).unwrap();
+        assert_eq!(decoded, full);
+        let ends = decoded
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|row| row["@type"] == "Feature" && row["isEnd"] == true)
+            .collect::<Vec<_>>();
+        assert_eq!(ends.len(), 4);
+        assert!(ends.iter().all(|row| row["isConstant"] == false));
+        assert_eq!(
+            decoded
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|row| row["@id"].clone())
+                .collect::<Vec<_>>(),
+            compact
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|row| row["@id"].clone())
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(
+            to_compact_cbor(&model_to_compact_json(&model)).unwrap(),
+            source_bytes
+        );
+    }
+}
diff --git a/crates/sysmlv2-cbor/tests/delta.rs b/crates/sysmlv2-cbor/tests/delta.rs
index e6a061f..a15d9ff 100644
--- a/crates/sysmlv2-cbor/tests/delta.rs
+++ b/crates/sysmlv2-cbor/tests/delta.rs
@@ -455,9 +455,10 @@ fn elided_delta_tampering_fails_a_digest_hard() {
     let base = compact_of(&[("m.sysml", BASE_UNIT)]);
     let target = compact_of(&[("m.sysml", TARGET_UNIT)]);
     let bytes = delta_compact_cbor_elided(&base, &target, &opts(false), &none).unwrap();
-    // Every single-byte mutation must die cleanly (malformed, digest,
-    // or refused header — never a panic, never silent acceptance of a
-    // divergent state); some mutation must reach each digest guard.
+    // Body mutations must die cleanly (malformed or digest), never
+    // silently accept a divergent state. A 2→3 header flip is meaningful
+    // metadata over this graph with no conditional operands; both schemes
+    // derive the same IDs. Session boundaries separately enforce the contract.
     let (mut id_digest_failures, mut ok) = (0usize, 0usize);
     for i in 0..bytes.len() {
         let mut bad = bytes.clone();
@@ -471,6 +472,11 @@ fn elided_delta_tampering_fails_a_digest_hard() {
                 // A mutation that still applies must be a no-op flip
                 // landing on the identical state.
                 assert_eq!(v, delta_canonical(&target).unwrap());
+                assert_eq!(i, 16, "only the supported graph-format stamp may change");
+                assert_eq!(
+                    sysmlv2_cbor::describe(&bad).unwrap()["versions"]["scheme"],
+                    3
+                );
                 ok += 1;
             }
         }
@@ -479,7 +485,7 @@ fn elided_delta_tampering_fails_a_digest_hard() {
         id_digest_failures > 0,
         "some mutation reached the created-id digest"
     );
-    assert_eq!(ok, 0, "no mutation silently applied");
+    assert_eq!(ok, 1, "only the graph-format stamp changed");
 }
 
 #[test]
@@ -1086,3 +1092,28 @@ mod implied_owner_deltas {
         assert_eq!(described["delta"]["ownerExceptions"], 0);
     }
 }
+
+#[test]
+fn previous_id_scheme_refuses_elided_deltas_but_accepts_explicit_ids() {
+    let base = compact_of(&[("m.sysml", BASE_UNIT)]);
+    let target = compact_of(&[("m.sysml", TARGET_UNIT)]);
+    let mut elided = delta_compact_cbor_elided(&base, &target, &opts(false), &none).unwrap();
+    assert_eq!(elided[9], 0x1B);
+    elided[16] = 1;
+    let err = apply_delta_cbor_with(&elided, &base, &none)
+        .unwrap_err()
+        .to_string();
+    assert!(err.contains("id-derivation scheme"), "{err}");
+    assert_eq!(
+        sysmlv2_cbor::describe(&elided).unwrap()["versions"]["supported"],
+        false
+    );
+    for portable in [false, true] {
+        let mut explicit = delta_compact_cbor(&base, &target, &opts(portable)).unwrap();
+        explicit[16] = 1;
+        assert_eq!(
+            apply_delta_cbor(&explicit, &base).unwrap(),
+            delta_canonical(&target).unwrap()
+        );
+    }
+}
diff --git a/crates/sysmlv2-cbor/tests/determinism.rs b/crates/sysmlv2-cbor/tests/determinism.rs
index 1cab30e..3f3011c 100644
--- a/crates/sysmlv2-cbor/tests/determinism.rs
+++ b/crates/sysmlv2-cbor/tests/determinism.rs
@@ -58,8 +58,8 @@ fn wire_format_is_pinned() {
         0xD9, 0xD9, 0xF7, // tag(55799) — self-described CBOR
         0xDA, 0x24, 0x53, 0x32, 0x43, // tag(0x24533243) — "$S2C" (RFC 9277 file magic)
         0x85, // array(5) — owner-exception section under FLAG_IMPLIED_OWNERS
-        0x1B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01,
-        0x20, // header word: layout 1 · tables 1 · scheme 1 · flags 0x20 (implied owners)
+        0x1B, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x02,
+        0x20, // header word: layout 1 · tables 1 · scheme 2 · flags 0x20 (implied owners)
         0x81, // external table, 1 entry
         0x50, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x41, 0x11, 0x81, 0x11, 0x11, 0x11, 0x11, 0x11,
         0x11, 0x11, // bstr(16) 11111111-1111-4111-8111-111111111111
diff --git a/crates/sysmlv2-cbor/tests/elide.rs b/crates/sysmlv2-cbor/tests/elide.rs
index e602b65..b6328d1 100644
--- a/crates/sysmlv2-cbor/tests/elide.rs
+++ b/crates/sysmlv2-cbor/tests/elide.rs
@@ -166,12 +166,25 @@ fn plain_decoders_refuse_elided_payloads() {
 #[test]
 fn foreign_derivation_scheme_refuses_elided_payloads_only() {
     let (compact, _) = golden_compact();
-    let mut elided = to_compact_cbor_elided(&compact, &no_external).unwrap();
-    // Header word bytes: 8 magic + array(4) + 0x1B, scheme at [16].
-    assert_eq!(elided[9], 0x1B);
-    elided[16] = 0xFF;
-    let err = from_compact_cbor_elided(&elided, &no_external)
-        .unwrap_err()
-        .to_string();
-    assert!(err.contains("id-derivation scheme"), "{err}");
+    for scheme in [1, 0xFF] {
+        let mut elided = to_compact_cbor_elided(&compact, &no_external).unwrap();
+        // Header word bytes: 8 magic + array + 0x1B, scheme at [16].
+        assert_eq!(elided[9], 0x1B);
+        elided[16] = scheme;
+        let err = from_compact_cbor_elided(&elided, &no_external)
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("id-derivation scheme"), "{err}");
+        assert_eq!(
+            sysmlv2_cbor::describe(&elided).unwrap()["versions"]["supported"],
+            false
+        );
+        let mut explicit = to_compact_cbor(&compact).unwrap();
+        explicit[16] = scheme;
+        assert_eq!(from_compact_cbor(&explicit).unwrap(), compact);
+        assert_eq!(
+            sysmlv2_cbor::describe(&explicit).unwrap()["versions"]["supported"],
+            true
+        );
+    }
 }
diff --git a/crates/sysmlv2-cbor/tests/owned_results.rs b/crates/sysmlv2-cbor/tests/owned_results.rs
new file mode 100644
index 0000000..0854ee5
--- /dev/null
+++ b/crates/sysmlv2-cbor/tests/owned_results.rs
@@ -0,0 +1,110 @@
+//! Source transport remains scheme 2; semantic result/binding nodes travel in full form.
+use sysmlv2_cbor::{
+    from_compact_cbor, from_compact_cbor_elided, from_full_cbor, to_compact_cbor,
+    to_compact_cbor_elided, to_full_cbor,
+};
+use sysmlv2_parser::{
+    full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json},
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    lift::from_compact_json,
+    model::Model,
+    print::print_source,
+};
+
+#[test]
+fn owned_results_preserve_source_cbor_and_roundtrip_atomic_full_subtrees() {
+    let mut model = Model::new();
+    model.add_source("declarations.kerml", "package P {datatype T; feature n:T;}");
+    model.add_source("references.kerml", "feature x=P::n; feature y=P::n;");
+    assert!(!model.has_errors());
+    let compact = model_to_compact_json(&model);
+    let compact_bytes = to_compact_cbor(&compact).unwrap();
+    let no_external =
+        |name: &str| -> Option<String> { panic!("unexpected external reference {name}") };
+    let elided_bytes = to_compact_cbor_elided(&compact, &no_external).unwrap();
+    assert_eq!(from_compact_cbor(&compact_bytes).unwrap(), compact);
+    assert_eq!(
+        from_compact_cbor_elided(&elided_bytes, &no_external).unwrap(),
+        compact
+    );
+    let expected_source = print_source(&from_compact_json(&compact).unwrap().unit);
+    let mut resolved = ResolvedModel::build(&model);
+    let expressions: Vec<_> = resolved
+        .elements()
+        .filter(|&e| resolved.element_type(e) == "FeatureReferenceExpression")
+        .collect();
+    assert_eq!(expressions.len(), 2);
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        let full = resolved_to_full_json(
+            &mut resolved,
+            &model,
+            EmissionPolicy {
+                unresolved: UnresolvedReferencePolicy::Reject,
+                closures: policy,
+            },
+        )
+        .unwrap();
+        assert_eq!(
+            full.as_array().unwrap().len(),
+            compact.as_array().unwrap().len() + 28
+        );
+        assert_eq!(
+            full.as_array()
+                .unwrap()
+                .iter()
+                .filter(|row| row["@type"] == "TypeFeaturing")
+                .count(),
+            6
+        );
+        let encoded = to_full_cbor(&full).unwrap();
+        let decoded = from_full_cbor(&encoded).unwrap();
+        assert_eq!(decoded, full);
+        assert_eq!(
+            print_source(&from_compact_json(&decoded).unwrap().unit),
+            expected_source
+        );
+        assert_eq!(
+            to_compact_cbor(&model_to_compact_json(&model)).unwrap(),
+            compact_bytes
+        );
+        assert_eq!(
+            to_compact_cbor_elided(&model_to_compact_json(&model), &no_external).unwrap(),
+            elided_bytes
+        );
+    }
+    assert_eq!(sysmlv2_cbor::ID_SCHEME_VERSION, 2);
+    assert_eq!(sysmlv2_cbor::LAYOUT_VERSION, 1);
+}
+
+#[test]
+fn full_binding_cbor_preserves_sysml_dialect() {
+    let mut model = Model::new();
+    model.add_source(
+        "reference.sysml",
+        "part def Container { attribute n; attribute x=n; }",
+    );
+    assert!(!model.has_errors());
+    let compact = model_to_compact_json(&model);
+    let expected = from_compact_json(&compact).unwrap();
+    let full = sysmlv2_parser::full::model_to_full_json(&model);
+    assert!(
+        full.as_array()
+            .unwrap()
+            .iter()
+            .any(|row| row["@type"] == "BindingConnector")
+    );
+    let decoded = from_full_cbor(&to_full_cbor(&full).unwrap()).unwrap();
+    assert_eq!(decoded, full);
+    let actual = from_compact_json(&decoded).unwrap();
+    assert!(actual.errors.is_empty(), "{:?}", actual.errors);
+    assert_eq!(actual.unit.dialect, sysmlv2_parser::ast::Dialect::Sysml);
+    assert_eq!(print_source(&actual.unit), print_source(&expected.unit));
+}
diff --git a/crates/sysmlv2-cbor/tests/resolver.rs b/crates/sysmlv2-cbor/tests/resolver.rs
index d9c5bc3..9cb6917 100644
--- a/crates/sysmlv2-cbor/tests/resolver.rs
+++ b/crates/sysmlv2-cbor/tests/resolver.rs
@@ -106,6 +106,12 @@ fn collision_and_version_policies_are_loud() {
     assert_eq!(r.id_of("Pkg::Dup"), None, "collisions never resolve");
     assert!(r.is_collision("Pkg::Dup"));
 
+    v["schemeVersion"] = serde_json::json!(1);
+    let r = StdlibResolver::from_value(&v).unwrap();
+    let err = r.assert_compatible().unwrap_err().to_string();
+    assert!(err.contains("scheme"), "{err}");
+    v["schemeVersion"] = serde_json::json!(sysmlv2_cbor::ID_SCHEME_VERSION);
+
     v["tablesVersion"] = serde_json::json!(9999);
     let r = StdlibResolver::from_value(&v).unwrap();
     let err = r.assert_compatible().unwrap_err().to_string();
diff --git a/crates/sysmlv2-cli/Cargo.toml b/crates/sysmlv2-cli/Cargo.toml
index b956ff4..76f325f 100644
--- a/crates/sysmlv2-cli/Cargo.toml
+++ b/crates/sysmlv2-cli/Cargo.toml
@@ -44,4 +44,4 @@ xattr = "1"
 
 [dev-dependencies]
 sysmlv2-testkit.workspace = true
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
diff --git a/crates/sysmlv2-cli/src/lib.rs b/crates/sysmlv2-cli/src/lib.rs
index fd440e6..c362672 100644
--- a/crates/sysmlv2-cli/src/lib.rs
+++ b/crates/sysmlv2-cli/src/lib.rs
@@ -8,7 +8,9 @@
 
 use clap::{Parser, Subcommand, ValueEnum};
 use std::collections::{HashMap, HashSet};
-use std::fs::{OpenOptions, Permissions};
+use std::fs::OpenOptions;
+#[cfg(not(target_os = "wasi"))]
+use std::fs::Permissions;
 use std::io::{self, BufWriter, IsTerminal, Write};
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
@@ -809,28 +811,6 @@ enum Command {
         #[arg(long, env = "SYSMLV2_LIB_DIR")]
         lib: Option<PathBuf>,
     },
-    /// Render a view's template over its exposed model slice (semantic mode)
-    #[command(
-        long_about = "Render the component template a view usage presents over the\n\
-                      model elements the view exposes (semantic mode): the\n\
-                      view's rendering definition owns an imported template root whose\n\
-                      translated expressions evaluate over the exposed slice. Prints the\n\
-                      rendered tree as JSON, or as HTML with --html. The model is not\n\
-                      modified.",
-        after_help = "EXAMPLES:\n\
-                      \x20 sysmlv2 render --lib sysml.library model.sysml PackagesView.sysml Site::packagesView\n\
-                      \x20 sysmlv2 render --lib sysml.library --html app.sysml App::home"
-    )]
-    Render {
-        /// Model files (.sysml/.kerml) followed by the view usage's qualified name
-        args: Vec<String>,
-        /// Standard-library directory for reference resolution
-        #[arg(long, env = "SYSMLV2_LIB_DIR")]
-        lib: Option<PathBuf>,
-        /// Print HTML instead of the JSON node tree
-        #[arg(long)]
-        html: bool,
-    },
     /// Describe one element: metaclass, owner, typing, position
     #[command(
         long_about = "Describe one element of the resolved model: its metaclass,\n\
@@ -921,8 +901,8 @@ enum Command {
         /// SYSMLV2_MODEL_DIR is set
         files: Vec<PathBuf>,
         /// View to render. Default: tree — except when --element
-        /// targets a view usage, whose own `render` member picks the
-        /// style
+        /// targets a view usage, whose rendering (its own `render`
+        /// member, else the one it inherits) picks the style
         #[arg(long, value_enum)]
         view: Option<DiagramView>,
         /// Root the diagram at this ::-qualified element
@@ -1052,8 +1032,8 @@ enum RefactorOp {
                             root-level name collision. Run again on a moved file to\n\
                             split deeper.\n\n\
                             EXAMPLES:\n\
-                            \x20 sysmlv2 refactor split model.sysml TMT --dry-run\n\
-                            \x20 sysmlv2 refactor split model.sysml TMT --slug"
+                            \x20 sysmlv2 refactor split model.sysml Rover --dry-run\n\
+                            \x20 sysmlv2 refactor split model.sysml Rover --slug"
     )]
     Split {
         /// Input file (.sysml or .kerml); optional when SYSMLV2_MODEL_DIR
@@ -1147,12 +1127,18 @@ fn parse_file(path: &Path, src: &str) -> Parse {
 }
 
 fn report(path: &Path, src: &str, diags: &[Diagnostic]) {
-    let reporter = Reporter::new(path, src);
+    let mut reporter = Reporter::new(path, src);
     for d in diags {
         reporter.report(d);
     }
 }
 
+/// The most characters of a source line the text report shows under a
+/// finding. A longer line is cut to this many around the finding, so the
+/// report on a one-line model grows with its findings, not with findings
+/// times the line's length.
+const EXCERPT_WIDTH: usize = 160;
+
 /// Diagnostics for one source, rendered against a line index built once.
 /// Loops that emit findings one at a time across several files keep one
 /// `Reporter` per file: rebuilding the index per finding made `check` and
@@ -1161,6 +1147,10 @@ struct Reporter<'a> {
     path: &'a Path,
     src: &'a str,
     index: LineIndex,
+    /// The start of the line the last finding was on and the end of its
+    /// text, trailing whitespace trimmed. Findings on one long line reuse
+    /// it instead of scanning to the line's end each time.
+    line: Option<(usize, usize)>,
 }
 
 impl<'a> Reporter<'a> {
@@ -1169,10 +1159,17 @@ impl<'a> Reporter<'a> {
             path,
             src,
             index: LineIndex::new(src),
+            line: None,
         }
     }
 
-    fn report(&self, d: &Diagnostic) {
+    fn report(&mut self, d: &Diagnostic) {
+        eprint!("{}", self.render(d));
+    }
+
+    /// One finding as the text report writes it: the message, its
+    /// location, an excerpt of its line and a caret line under its span.
+    fn render(&mut self, d: &Diagnostic) -> String {
         let severity = match d.severity {
             sysmlv2_parser::diag::Severity::Error => "error",
             sysmlv2_parser::diag::Severity::Warning => "warning",
@@ -1180,22 +1177,93 @@ impl<'a> Reporter<'a> {
         let pos = self.index.line_col(d.span.start);
         // The diagnostic's own line, located from its offset rather than by
         // counting lines from the top of the file.
+        let start = (d.span.start - (pos.col - 1)) as usize;
+        let end = match self.line {
+            Some((line, end)) if line == start => end,
+            _ => {
+                let rest = &self.src[start..];
+                let line = &rest[..rest.find('\n').unwrap_or(rest.len())];
+                let end = start + line.trim_end().len();
+                self.line = Some((start, end));
+                end
+            }
+        };
+        let text = &self.src[start..end];
+        // The span in the line's text: a start past the text (in trailing
+        // whitespace, or at the end of the source) is marked just past it.
         let mut at = (d.span.start as usize).min(self.src.len());
         while !self.src.is_char_boundary(at) {
             at -= 1;
         }
-        let (before, after) = self.src.split_at(at);
-        let start = before.rfind('\n').map_or(0, |i| i + 1);
-        let end = at + after.find('\n').unwrap_or(after.len());
-        let line = &self.src[start..end];
-        eprintln!(
-            "{severity}: {}\n  --> {}:{}:{}\n   |\n   | {}\n",
+        let at = at.min(end) - start;
+        let mut to = (d.span.end as usize)
+            .saturating_sub(start)
+            .clamp(at, text.len());
+        while !text.is_char_boundary(to) {
+            to -= 1;
+        }
+        let (excerpt, caret) = excerpt(text, at, to);
+        format!(
+            "{severity}: {}\n  --> {}:{}:{}\n   |\n   | {excerpt}\n   | {caret}\n\n",
             d.message,
             self.path.display(),
             pos.line,
             pos.col,
-            line.trim_end()
-        );
+        )
+    }
+}
+
+/// The excerpt of a line's text shown under a finding spanning its bytes
+/// `at..to`, and the caret line marking that span. A line of at most
+/// [`EXCERPT_WIDTH`] characters shows whole. A longer one shows that many,
+/// up to a third of them before the finding, with `…` where it was cut.
+/// The caret line copies the tabs it passes, so the carets stay under the
+/// span at any tab width; every other character counts as one column.
+fn excerpt(text: &str, at: usize, to: usize) -> (String, String) {
+    let whole = text.len() <= EXCERPT_WIDTH || text.chars().nth(EXCERPT_WIDTH).is_none();
+    let (from, until) = if whole {
+        (0, text.len())
+    } else {
+        excerpt_window(text, at)
+    };
+    let mut shown = String::new();
+    let mut caret = String::new();
+    if from > 0 {
+        shown.push('…');
+        caret.push(' ');
+    }
+    shown.push_str(&text[from..until]);
+    if until < text.len() {
+        shown.push('…');
+    }
+    let blank = |c: char| if c == '\t' { '\t' } else { ' ' };
+    caret.extend(text[from..at].chars().map(blank));
+    let marked = text[at..to.min(until)].chars().count().max(1);
+    caret.extend(std::iter::repeat_n('^', marked));
+    (shown, caret)
+}
+
+/// The bytes of a line longer than [`EXCERPT_WIDTH`] characters shown
+/// around byte `at`: that many characters, starting up to a third of them
+/// before `at`, or the line's last ones when it ends sooner. Each walk
+/// covers at most the window, whatever the line's length.
+fn excerpt_window(text: &str, at: usize) -> (usize, usize) {
+    let from = text[..at]
+        .char_indices()
+        .rev()
+        .take(EXCERPT_WIDTH / 3)
+        .last()
+        .map_or(at, |(i, _)| i);
+    match text[from..].char_indices().nth(EXCERPT_WIDTH) {
+        Some((until, _)) => (from, from + until),
+        None => {
+            let from = text
+                .char_indices()
+                .rev()
+                .nth(EXCERPT_WIDTH - 1)
+                .map_or(0, |(i, _)| i);
+            (from, text.len())
+        }
     }
 }
 
@@ -2314,6 +2382,7 @@ struct StagedRefactorFile {
 
 #[derive(Debug)]
 struct RefactorFileMetadata {
+    #[cfg(not(target_os = "wasi"))]
     permissions: Permissions,
     #[cfg(all(unix, not(target_os = "wasi")))]
     uid: u32,
@@ -2555,44 +2624,54 @@ fn write_refactor_sidecar(
     ))
 }
 
+#[cfg(all(unix, not(target_os = "wasi")))]
 fn refactor_file_metadata(file: &std::fs::File) -> std::io::Result<RefactorFileMetadata> {
+    use std::os::unix::fs::MetadataExt;
+    use xattr::FileExt;
+
     let metadata = file.metadata()?;
-    #[cfg(all(unix, not(target_os = "wasi")))]
-    {
-        use std::os::unix::fs::MetadataExt;
-        use xattr::FileExt;
-
-        if metadata.nlink() != 1 {
-            return Err(std::io::Error::other(format!(
-                "has {} hard links; refusing to split linked paths during atomic replacement",
-                metadata.nlink()
-            )));
-        }
-        let mut xattrs = Vec::new();
-        match file.list_xattr() {
-            Ok(names) => {
-                for name in names {
-                    if let Some(value) = file.get_xattr(&name)? {
-                        xattrs.push((name, value));
-                    }
+    if metadata.nlink() != 1 {
+        return Err(std::io::Error::other(format!(
+            "has {} hard links; refusing to split linked paths during atomic replacement",
+            metadata.nlink()
+        )));
+    }
+    let mut xattrs = Vec::new();
+    match file.list_xattr() {
+        Ok(names) => {
+            for name in names {
+                if let Some(value) = file.get_xattr(&name)? {
+                    xattrs.push((name, value));
                 }
             }
-            Err(e) if e.kind() == std::io::ErrorKind::Unsupported => {}
-            Err(e) => return Err(e),
         }
-        Ok(RefactorFileMetadata {
-            permissions: metadata.permissions(),
-            uid: metadata.uid(),
-            gid: metadata.gid(),
-            xattrs,
-        })
+        Err(e) if e.kind() == std::io::ErrorKind::Unsupported => {}
+        Err(e) => return Err(e),
     }
-    #[cfg(not(all(unix, not(target_os = "wasi"))))]
     Ok(RefactorFileMetadata {
         permissions: metadata.permissions(),
+        uid: metadata.uid(),
+        gid: metadata.gid(),
+        xattrs,
+    })
+}
+
+#[cfg(all(not(unix), not(target_os = "wasi")))]
+fn refactor_file_metadata(file: &std::fs::File) -> std::io::Result<RefactorFileMetadata> {
+    Ok(RefactorFileMetadata {
+        permissions: file.metadata()?.permissions(),
     })
 }
 
+#[cfg(target_os = "wasi")]
+fn refactor_file_metadata(file: &std::fs::File) -> std::io::Result<RefactorFileMetadata> {
+    // Nothing carries over to the sidecars here (see the WASI
+    // `set_refactor_sidecar_metadata`), but a target the host cannot
+    // inspect is still refused.
+    file.metadata()?;
+    Ok(RefactorFileMetadata {})
+}
+
 #[cfg(all(unix, not(target_os = "wasi")))]
 fn set_refactor_sidecar_metadata(
     file: &std::fs::File,
@@ -4510,38 +4589,6 @@ pub fn run_eval(
     Ok(())
 }
 
-/// `render`: evaluate one view usage and write the nodes it exposes,
-/// as JSON or as an HTML fragment.
-pub fn run_render(
-    args: Vec<String>,
-    lib: Option<&Path>,
-    html: bool,
-    quiet: bool,
-) -> Result<(), CliError> {
-    let (files, names): (Vec<String>, Vec<String>) =
-        args.into_iter().partition(|a| is_model_source(a));
-    let [view_name] = names.as_slice() else {
-        return Err(fail(format!(
-            "expected exactly one view usage name, got {}",
-            names.len()
-        )));
-    };
-    let mut resolved =
-        load_model(files.into_iter().map(PathBuf::from).collect(), lib, quiet)?.into_resolved();
-    let Some(view) = resolved.resolve_qualified(view_name) else {
-        return Err(fail(format!("element not found: {view_name}")));
-    };
-    let nodes = resolved.render_view(view).map_err(fail)?;
-    if html {
-        let html = sysmlv2_parser::render::to_html(&nodes) + "\n";
-        write_bytes(None, html.as_bytes())?;
-    } else {
-        let json = serde_json::Value::Array(nodes.iter().map(|n| n.to_json()).collect());
-        write_json(None, &json)?;
-    }
-    Ok(())
-}
-
 /// `query`: evaluate one expression against the model's root scope and
 /// write its value, one line per item of a sequence.
 pub fn run_query(
@@ -4729,8 +4776,9 @@ pub fn run_viz(args: VizArgs, quiet: bool) -> Result<(), CliError> {
     };
     // A view usage directs its own rendering: the diagram's
     // elements are what the view exposes (filter conditions
-    // applied), and its `render` member picks the style unless
-    // --view was given explicitly.
+    // applied), and its rendering — its own `render` member, else
+    // the one it inherits — picks the style unless --view was given
+    // explicitly.
     let (root, view, roots) = match root {
         Some(e) => match sysmlv2_viz::view_directed(&mut resolved, e) {
             Some((style, exposed)) => (None, view.or(style), Some(exposed)),
@@ -4936,9 +4984,6 @@ fn dispatch(command: Command, quiet: bool) -> ExitCode {
             lib,
         } => finish(run_eval(input, names, all, lib.as_deref(), quiet)),
 
-        Command::Render { args, lib, html } => {
-            finish(run_render(args, lib.as_deref(), html, quiet))
-        }
         Command::Query { input, args, lib } => {
             finish(run_query(input, args, lib.as_deref(), quiet))
         }
@@ -5246,3 +5291,178 @@ mod stack_tests {
         assert!(said.contains("without a diagnostic"), "{said}");
     }
 }
+
+#[cfg(test)]
+mod report_tests {
+    use super::*;
+
+    /// The text report of a warning `w` at bytes `start..end` of `src`.
+    fn render(src: &str, start: u32, end: u32) -> String {
+        Reporter::new(Path::new("m.sysml"), src)
+            .render(&Diagnostic::warning(Span::new(start, end), "w"))
+    }
+
+    /// The excerpt line and the caret line of a rendered finding, without
+    /// their `   | ` gutter.
+    fn excerpt_lines(report: &str) -> (String, String) {
+        let lines: Vec<&str> = report.lines().collect();
+        (lines[3][5..].to_string(), lines[4][5..].to_string())
+    }
+
+    /// Where the carets start in the caret line, in characters, and how
+    /// many there are.
+    fn carets(caret: &str) -> (usize, usize) {
+        let at = caret.chars().take_while(|&c| c != '^').count();
+        (at, caret.chars().filter(|&c| c == '^').count())
+    }
+
+    /// A line of `n` five-character words, `w000 w001 …`: a finding on
+    /// word `i` starts at byte and character `5 * i`.
+    fn words(n: usize) -> String {
+        (0..n)
+            .map(|i| format!("w{i:03} "))
+            .collect::<String>()
+            .trim_end()
+            .to_string()
+    }
+
+    #[test]
+    fn a_short_line_shows_whole_with_carets_under_the_span() {
+        let src = "package P {\n    part x : Missing;\n}\n";
+        let caret = format!("{}^^^^^^^", " ".repeat(13));
+        assert_eq!(
+            render(src, 25, 32),
+            format!(
+                "warning: w\n  --> m.sysml:2:14\n   |\n   |     part x : Missing;\n   | {caret}\n\n"
+            )
+        );
+    }
+
+    /// Terminals expand a tab to the next tab stop, which the caret line
+    /// reaches only by passing a tab of its own at the same place.
+    #[test]
+    fn the_caret_line_copies_tabs_before_the_span() {
+        let src = "\tpart x :\tMissing;";
+        let (_, caret) = excerpt_lines(&render(src, 10, 17));
+        assert_eq!(caret, "\t        \t^^^^^^^");
+    }
+
+    #[test]
+    fn a_long_line_is_cut_around_the_finding() {
+        let line = words(200);
+        let report = render(&line, 500, 504);
+        let (shown, caret) = excerpt_lines(&report);
+        assert!(shown.starts_with('…') && shown.ends_with('…'), "{shown}");
+        assert_eq!(shown.chars().count(), EXCERPT_WIDTH + 2);
+        // A third of the width before the finding, after the leading `…`.
+        assert_eq!(carets(&caret), (1 + EXCERPT_WIDTH / 3, 4));
+        let marked: String = shown.chars().skip(1 + EXCERPT_WIDTH / 3).take(4).collect();
+        assert_eq!(marked, "w100");
+        // The location keeps the finding's column in the whole line.
+        assert!(report.contains("--> m.sysml:1:501\n"), "{report}");
+    }
+
+    #[test]
+    fn a_finding_near_either_end_keeps_the_full_width() {
+        let line = words(200);
+        let (shown, caret) = excerpt_lines(&render(&line, 10, 14));
+        assert!(!shown.starts_with('…') && shown.ends_with('…'), "{shown}");
+        assert_eq!(shown.chars().count(), EXCERPT_WIDTH + 1);
+        assert_eq!(carets(&caret), (10, 4));
+
+        let last = line.len() - 4;
+        let (shown, caret) = excerpt_lines(&render(&line, last as u32, line.len() as u32));
+        assert!(shown.starts_with('…') && !shown.ends_with('…'), "{shown}");
+        assert_eq!(shown.chars().count(), EXCERPT_WIDTH + 1);
+        assert!(shown.ends_with("w199"), "{shown}");
+        assert_eq!(carets(&caret), (1 + EXCERPT_WIDTH - 4, 4));
+    }
+
+    #[test]
+    fn a_line_of_the_full_width_shows_whole_and_one_more_character_is_cut() {
+        let line = "x".repeat(EXCERPT_WIDTH);
+        let (shown, _) = excerpt_lines(&render(&line, 0, 1));
+        assert_eq!(shown, line);
+
+        let line = "x".repeat(EXCERPT_WIDTH + 1);
+        let (shown, _) = excerpt_lines(&render(&line, 0, 1));
+        assert_eq!(shown, format!("{}…", "x".repeat(EXCERPT_WIDTH)));
+    }
+
+    /// The width counts characters and the cuts fall between them, so a
+    /// line of multibyte characters shows as many as an ASCII one.
+    #[test]
+    fn a_line_of_multibyte_characters_is_cut_between_characters() {
+        let line = "⋅".repeat(1000);
+        let at = 3 * 500;
+        let (shown, caret) = excerpt_lines(&render(&line, at, at + 3));
+        assert_eq!(shown.chars().count(), EXCERPT_WIDTH + 2);
+        assert_eq!(carets(&caret), (1 + EXCERPT_WIDTH / 3, 1));
+    }
+
+    /// Carets mark the span only as far as the excerpt shows it: to the
+    /// cut, or to the end of a line the span runs past.
+    #[test]
+    fn carets_stop_where_the_excerpt_ends() {
+        let line = words(200);
+        let (_, caret) = excerpt_lines(&render(&line, 500, 900));
+        assert_eq!(
+            carets(&caret),
+            (1 + EXCERPT_WIDTH / 3, EXCERPT_WIDTH - EXCERPT_WIDTH / 3)
+        );
+
+        let src = "part x {\n}\n";
+        let (_, caret) = excerpt_lines(&render(src, 5, 10));
+        assert_eq!(caret, "     ^^^");
+    }
+
+    /// A span that is empty, or starts at the end of the source or in a
+    /// line's trailing whitespace, still gets one caret, just past the
+    /// text when it starts beyond it.
+    #[test]
+    fn an_empty_span_or_one_past_the_text_gets_one_caret() {
+        let src = "part x : ;";
+        let (_, caret) = excerpt_lines(&render(src, 9, 9));
+        assert_eq!(caret, "         ^");
+
+        let src = "part x {   ";
+        let (shown, caret) = excerpt_lines(&render(src, 11, 11));
+        assert_eq!(shown, "part x {");
+        assert_eq!(caret, "        ^");
+
+        let src = "part x {\n";
+        let report = render(src, 9, 9);
+        assert!(
+            report.ends_with("--> m.sysml:2:1\n   |\n   | \n   | ^\n\n"),
+            "{report}"
+        );
+    }
+
+    #[test]
+    fn a_carriage_return_ending_the_line_is_not_shown() {
+        let src = "part x : Missing;\r\npart y;\r\n";
+        let (shown, caret) = excerpt_lines(&render(src, 9, 16));
+        assert_eq!(shown, "part x : Missing;");
+        assert_eq!(caret, "         ^^^^^^^");
+    }
+
+    /// The reporter remembers the end of the last finding's line; a
+    /// finding on another line, then on the first again, renders as a
+    /// fresh reporter renders it.
+    #[test]
+    fn findings_alternating_between_lines_render_as_alone() {
+        let src = format!("{}\npart x : Missing;\n", words(200));
+        let second = src.find("Missing").unwrap() as u32;
+        let spans = [
+            (500, 504),
+            (second, second + 7),
+            (10, 14),
+            (second, second + 7),
+        ];
+        let mut reporter = Reporter::new(Path::new("m.sysml"), &src);
+        for (start, end) in spans {
+            let finding = Diagnostic::warning(Span::new(start, end), "w");
+            assert_eq!(reporter.render(&finding), render(&src, start, end));
+        }
+    }
+}
diff --git a/crates/sysmlv2-cli/tests/cli.rs b/crates/sysmlv2-cli/tests/cli.rs
index ad12485..78fbf4b 100644
--- a/crates/sysmlv2-cli/tests/cli.rs
+++ b/crates/sysmlv2-cli/tests/cli.rs
@@ -166,8 +166,8 @@ fn verify_ranges_narrows_and_attributes_verdicts() {
         "package Demo {\n\
          \x20   attribute def Real;\n\
          \x20   attribute def Integer;\n\
-         \x20   attribute wingSpan : Real;\n\
-         \x20   attribute count : Integer;\n\
+         \x20   attribute wingSpan : Real[1];\n\
+         \x20   attribute count : Integer[1];\n\
          \x20   assert constraint span_lo { wingSpan >= 10 }\n\
          \x20   assert constraint span_hi { wingSpan <= 200 }\n\
          \x20   assert constraint bad { count > 5 & count < 4 }\n\
@@ -214,7 +214,59 @@ fn check_reports_rustc_style_diagnostics() {
     assert!(!out.status.success());
     let err = stderr(&out);
     assert!(err.contains("error:"), "{err}");
-    assert!(err.contains("bad.sysml:1:"), "location missing: {err}");
+    assert!(err.contains("bad.sysml:1:22\n"), "location missing: {err}");
+    // The finding's line, and a caret under its span.
+    let excerpt = format!(
+        "   | package Q {{ part x : ; }}\n   | {}^\n",
+        " ".repeat(21)
+    );
+    assert!(err.contains(&excerpt), "{err}");
+}
+
+/// The text report shows at most 160 characters of a finding's line, so
+/// on a model written as one long line it costs the same per finding
+/// whatever the line's length. Echoing the whole line made the report
+/// grow with findings times line length: 960 findings on a 12 KB line
+/// wrote 12 MB.
+#[test]
+fn check_report_per_finding_does_not_grow_with_the_line() {
+    const FINDINGS: usize = 100;
+    let dir =
+        std::env::temp_dir().join(format!("sysmlv2-cli-test-long-line-{}", std::process::id()));
+    fs::create_dir_all(&dir).unwrap();
+    // `FINDINGS` parts of unresolved types on one line, each followed by a
+    // note of `pad` characters.
+    let report = |name: &str, pad: usize| {
+        let note = format!("//* {} */", "x".repeat(pad));
+        let parts: String = (0..FINDINGS)
+            .map(|i| format!("part p{i} : Missing{i}; {note} "))
+            .collect();
+        let path = dir.join(name);
+        fs::write(&path, format!("package P {{ {parts}}}\n")).unwrap();
+        stderr(&sysmlv2(&["check", path.to_str().unwrap()]))
+    };
+    let short = report("s.sysml", 200);
+    let long = report("l.sysml", 20_000);
+    for text in [&short, &long] {
+        assert_eq!(
+            text.matches("warning: unresolved reference").count(),
+            FINDINGS,
+            "{text}"
+        );
+        // The gutter, at most 160 characters of the line and a `…` at
+        // each cut; the caret line is no longer.
+        for line in text.lines().filter(|line| line.starts_with("   | ")) {
+            assert!(line.chars().count() <= 5 + 160 + 2, "{line}");
+        }
+    }
+    // A line a hundred times longer adds only the digits of the columns.
+    assert!(
+        long.len() <= short.len() + 3 * FINDINGS,
+        "{} > {}",
+        long.len(),
+        short.len()
+    );
+    let _ = fs::remove_dir_all(&dir);
 }
 
 #[test]
@@ -852,7 +904,7 @@ fn query_finds_parts_by_usage_type() {
                 part rear : Wheel;
                 part engine : Engine;
             }
-            part car : Vehicle;
+            part car : Vehicle[1];
         }",
     )
     .unwrap();
@@ -903,7 +955,7 @@ fn query_reads_multiple_files_and_stdin() {
     let defs = dir.join("defs.sysml");
     let uses = dir.join("uses.sysml");
     fs::write(&defs, "package Defs { part def Wheel; }").unwrap();
-    fs::write(&uses, "package Uses { import Defs::*; part w : Wheel; }").unwrap();
+    fs::write(&uses, "package Uses { import Defs::*; part w : Wheel[1]; }").unwrap();
 
     // Cross-file query: both files form one model.
     let out = sysmlv2(&[
@@ -1076,6 +1128,61 @@ fn viz_element_scopes_and_unknown_element_fails() {
     assert!(err.contains("element not found"), "{err}");
 }
 
+/// `viz --element` on a view usage draws in the style of the view's
+/// rendering: its own `render` member's, else the one its definition
+/// declares. `--view` overrides either.
+#[test]
+fn viz_element_view_takes_an_inherited_rendering() {
+    let lib = sysmlv2_testkit::library_dir();
+    if !lib.exists() {
+        eprintln!("skipping: corpus not present");
+        return;
+    }
+    let dir = std::env::temp_dir().join(format!(
+        "sysmlv2-cli-test-viz-rendering-{}",
+        std::process::id()
+    ));
+    fs::create_dir_all(&dir).unwrap();
+    let model = dir.join("m.sysml");
+    fs::write(
+        &model,
+        "package P {
+            port def Jack;
+            part def Amp { port line : Jack; }
+            part def Speaker { port feed : Jack; }
+            part rig {
+                part amp : Amp;
+                part main : Speaker;
+                connect amp.line to main.feed;
+            }
+            view def Wiring { render Views::asInterconnectionDiagram; }
+            view wiring : Wiring { expose rig; }
+            view outline : Wiring {
+                expose rig;
+                render Views::asTreeDiagram;
+            }
+        }",
+    )
+    .unwrap();
+    let (model, lib) = (model.to_str().unwrap(), lib.to_str().unwrap());
+    let viz = |args: &[&str]| {
+        let out = sysmlv2(&[&["viz", model, "--lib", lib], args].concat());
+        assert!(out.status.success(), "{}", stderr(&out));
+        stdout(&out)
+    };
+    // The rendering the definition declares: parts as blocks, with ports.
+    let wiring = viz(&["--element", "P::wiring"]);
+    assert!(wiring.contains("rectangle \"rig\""), "{wiring}");
+    assert!(wiring.contains("port \"line : Jack\""), "{wiring}");
+    // The view's own rendering wins over the inherited one.
+    let outline = viz(&["--element", "P::outline"]);
+    assert!(outline.contains("class \"rig\""), "{outline}");
+    assert!(!outline.contains("port \""), "{outline}");
+    // An explicit --view overrides an inherited rendering.
+    let tree = viz(&["--element", "P::wiring", "--view", "tree"]);
+    assert!(tree.contains("class \"rig\""), "{tree}");
+}
+
 #[test]
 fn convert_min_qual_respells_references() {
     let dir = std::env::temp_dir().join(format!("sysmlv2-cli-test-minqual-{}", std::process::id()));
diff --git a/crates/sysmlv2-cli/tests/inprocess.rs b/crates/sysmlv2-cli/tests/inprocess.rs
index cba91a7..94341ec 100644
--- a/crates/sysmlv2-cli/tests/inprocess.rs
+++ b/crates/sysmlv2-cli/tests/inprocess.rs
@@ -146,27 +146,16 @@ fn a_verb_that_cannot_resolve_its_name_says_so() {
 }
 
 #[test]
-fn the_expression_verbs_refuse_an_argument_list_they_cannot_read() {
+fn query_refuses_an_argument_list_it_cannot_read() {
     let ws = Workspace::new("args", &[("m.sysml", "package M {\n    part def V;\n}\n")]);
     let model = ws.path("m.sysml").display().to_string();
 
-    let e = sysmlv2_cli::run_query(
-        None,
-        vec![model.clone(), "1".into(), "2".into()],
-        None,
-        true,
-    )
-    .expect_err("refused");
+    let e = sysmlv2_cli::run_query(None, vec![model, "1".into(), "2".into()], None, true)
+        .expect_err("refused");
     assert_eq!(
         message(&e).as_deref(),
         Some("expected exactly one query expression, got 2")
     );
-
-    let e = sysmlv2_cli::run_render(vec![model], None, false, true).expect_err("refused");
-    assert_eq!(
-        message(&e).as_deref(),
-        Some("expected exactly one view usage name, got 0")
-    );
 }
 
 #[test]
diff --git a/crates/sysmlv2-lint/Cargo.toml b/crates/sysmlv2-lint/Cargo.toml
index 60dee5c..88c0554 100644
--- a/crates/sysmlv2-lint/Cargo.toml
+++ b/crates/sysmlv2-lint/Cargo.toml
@@ -12,8 +12,8 @@ repository.workspace = true
 include = ["src/**", "Cargo.toml"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
 serde_json.workspace = true
 regex-lite.workspace = true
 
diff --git a/crates/sysmlv2-lint/src/lib.rs b/crates/sysmlv2-lint/src/lib.rs
index 2f2b474..4893e90 100644
--- a/crates/sysmlv2-lint/src/lib.rs
+++ b/crates/sysmlv2-lint/src/lib.rs
@@ -209,6 +209,7 @@ rule_ids! {
     UsageKindMismatch = "usage-kind-mismatch",
     PortMemberReferential = "port-member-referential",
     InheritedNameShadow = "inherited-name-shadow",
+    RedefinitionOutsideInheritance = "redefinition-outside-inheritance",
     UnqualifiedEnumLiteral = "unqualified-enum-literal",
     UnitSpelling = "unit-spelling",
     DimensionalConsistency = "dimensional-consistency",
@@ -493,6 +494,17 @@ pub const RULES: &[Rule] = &[
         families: &[],
         options: &[],
     },
+    Rule {
+        id: RuleId::RedefinitionOutsideInheritance,
+        description: "an unqualified redefinition that resolves through an enclosing namespace \
+                      rather than a member of its selected explicit general; qualify an \
+                      intentional external target. No automatic fix",
+        default: Severity::Warn,
+        scopes: &[],
+        styles: &[],
+        families: &[],
+        options: &[],
+    },
     Rule {
         id: RuleId::UnqualifiedEnumLiteral,
         description: "an unresolved simple name that matches exactly one enumeration \
@@ -1426,6 +1438,9 @@ pub fn lint_units(
     if config.cfg(RuleId::InheritedNameShadow).enabled() {
         inherited_name_shadow(resolved, config, sources, &mut out);
     }
+    if config.cfg(RuleId::RedefinitionOutsideInheritance).enabled() {
+        redefinition_outside_inheritance(resolved, config, &mut out);
+    }
     if config.cfg(RuleId::UnqualifiedEnumLiteral).enabled() {
         unqualified_enum_literal(resolved, config, &mut out);
     }
@@ -5444,3 +5459,71 @@ fn report_unclaimed_markers(
         );
     }
 }
+
+/// Flag a bare redefinition that escaped its general's member namespace.
+fn redefinition_outside_inheritance(
+    resolved: &mut ResolvedModel,
+    config: &Config,
+    out: &mut Vec<Finding>,
+) {
+    for (site, name) in resolved.redefinitions_outside_inheritance() {
+        let Some(feature) = site.exclude else {
+            continue;
+        };
+        let severity = config
+            .cfg(RuleId::RedefinitionOutsideInheritance)
+            .severity(resolved.element_type(feature));
+        if severity == Severity::Off {
+            continue;
+        }
+        let Some(owner) = resolved.owner(feature) else {
+            continue;
+        };
+        let target = resolved
+            .element_qualified_name(site.target)
+            .unwrap_or_else(|| format!("@{}", resolved.element_id(site.target)));
+        let owner_name = resolved
+            .element_qualified_name(owner)
+            .unwrap_or_else(|| format!("@{}", resolved.element_id(owner)));
+        let mut message = format!(
+            "Unqualified redefinition resolves to `{target}` through an enclosing namespace, rather than a member of the selected general of `{owner_name}`; qualify the target if intentional"
+        );
+        // A shallow, unique structural alternative is useful context, never
+        // an automatic repair. Its value might itself be non-overridable.
+        let mut alternatives = Vec::new();
+        for child in resolved.effective_features(owner, true) {
+            if child == feature
+                || !sysmlv2_model::check::metaclass_conforms(
+                    resolved.element_type(child),
+                    "PartUsage",
+                )
+            {
+                continue;
+            }
+            let Some(child_name) = resolved.element_effective_name(child) else {
+                continue;
+            };
+            if let Some(target) = resolved.owned_member(child, &name) {
+                if target != site.target {
+                    alternatives.push(format!(
+                        "{}.{}",
+                        sysmlv2_syntax::ast::escape_name(&child_name),
+                        sysmlv2_syntax::ast::escape_name(&name)
+                    ));
+                }
+            }
+        }
+        alternatives.sort();
+        alternatives.dedup();
+        if let [path] = alternatives.as_slice() {
+            message.push_str(&format!(
+                ". A nested feature `{path}` also exists; check the intended target"
+            ));
+        }
+        let mut f = finding(RuleId::RedefinitionOutsideInheritance, severity, message);
+        f.unit = Some(site.unit);
+        f.span = Some(site.span);
+        f.element = edit_target(resolved, feature);
+        out.push(f);
+    }
+}
diff --git a/crates/sysmlv2-lint/tests/lint.rs b/crates/sysmlv2-lint/tests/lint.rs
index fea84ec..b05c70c 100644
--- a/crates/sysmlv2-lint/tests/lint.rs
+++ b/crates/sysmlv2-lint/tests/lint.rs
@@ -1178,10 +1178,13 @@ fn visibility_blocked_reference_offers_to_widen_the_member() {
 
 #[test]
 fn visibility_blocked_reference_covers_inherited_and_qualified_members() {
+    // A redefinition header resolves in its general, where the private
+    // member is addressable, so `Redefining` blocks nothing.
     let src = "package P {
     part def Base { private attribute v; }
-    part def Sub :> Base { attribute :>> v = 1; }
+    part def Sub :> Base { attribute u = v; }
     part def Other { attribute w = Base::v; }
+    part def Redefining :> Base { attribute :>> v = 1; }
 }
 ";
     let mut model = Model::new();
@@ -1191,7 +1194,7 @@ fn visibility_blocked_reference_covers_inherited_and_qualified_members() {
     let names: Vec<&str> = blocked.iter().map(|b| b.spelling.as_str()).collect();
     assert_eq!(names, ["v", "Base::v"], "{blocked:?}");
     assert!(blocked.iter().all(|b| b.visibility == "private"));
-    // The redefinition reaches `v` through the specialization, so
+    // The reference in `Sub` reaches `v` through the specialization, so
     // `protected` suffices there; the qualified reference from `Other`
     // needs `public`.
     assert_eq!(
@@ -1280,7 +1283,7 @@ package A { private package B { import Outer::Hidden::*; part h : H; } }
 }
 
 // ---------------------------------------------------------------------------
-// M32d: kind and referential fixes
+// Kind and referential fixes
 // ---------------------------------------------------------------------------
 
 fn rule_findings(sources: &[(&str, &str)], rule: &str) -> Vec<Finding> {
@@ -1609,7 +1612,7 @@ fn import_visibility_recommends_public_for_dependents_reaching_through_a_chain()
 fn inherited_name_shadow_spells_the_redefinition() {
     let src = "package P {\n    attribute def Real;\n    attribute def SwitchStatus { attribute downlinkPort : Real; }\n    attribute def M1 :> SwitchStatus { attribute downlinkPort : Real[6]; }\n    attribute def Lan { attribute m1 : M1; }\n}\n";
     let findings = rule_findings(&[("a.sysml", src)], "inherited-name-shadow");
-    assert_eq!(findings.len(), 2, "{findings:?}");
+    assert_eq!(findings.len(), 1, "{findings:?}");
     let owned = findings
         .iter()
         .find(|f| f.element.as_deref() == Some("P::M1::downlinkPort"))
@@ -1625,16 +1628,12 @@ fn inherited_name_shadow_spells_the_redefinition() {
         "{fixed}"
     );
     assert!(rule_findings(&[("a.sysml", &fixed)], "inherited-name-shadow").is_empty());
-    // The inheriting usage carries the finding without a fix: nothing to
-    // redefine on its side.
-    let both = findings
-        .iter()
-        .find(|f| f.element.as_deref() == Some("P::Lan::m1"))
-        .expect("inherited-twice collision");
-    assert!(both.fix.is_none());
+    // The base has already removed the shadowed membership, so its typed
+    // usage inherits one member and needs no duplicate downstream finding.
     assert!(
-        both.message
-            .starts_with("`downlinkPort` is inherited from both `M1` and `SwitchStatus`")
+        !findings
+            .iter()
+            .any(|f| f.element.as_deref() == Some("P::Lan::m1"))
     );
 }
 
@@ -1718,10 +1717,9 @@ fn inherited_name_shadow_admits_conforming_redefinitions() {
 }
 
 #[test]
-fn inherited_name_shadow_targets_the_nearest_of_a_chain_by_qualified_name() {
-    // `C::x` hides both `B::x` and `A::x`; the fix redefines the nearer,
-    // qualified — the simple name is ambiguous there — and together with
-    // the fix on `B::x` the model comes out clean.
+fn inherited_name_shadow_targets_the_filtered_nearest_base() {
+    // B has already removed A's membership, so C sees only B's x. The
+    // simple redefinition spelling identifies that nearest inherited member.
     let src = "package P {\n    attribute def Real;\n    part def A { attribute x : Real; }\n    part def B :> A { attribute x : Real; }\n    part def C :> B { attribute x : Real; }\n}\n";
     let findings = rule_findings(&[("a.sysml", src)], "inherited-name-shadow");
     assert_eq!(findings.len(), 2, "{findings:?}");
@@ -1736,7 +1734,7 @@ fn inherited_name_shadow_targets_the_nearest_of_a_chain_by_qualified_name() {
         "{fixed}"
     );
     assert!(
-        fixed.contains("part def C :> B { attribute :>> P::B::x : Real; }"),
+        fixed.contains("part def C :> B { attribute :>> x : Real; }"),
         "{fixed}"
     );
     assert!(rule_findings(&[("a.sysml", &fixed)], "inherited-name-shadow").is_empty());
@@ -1878,3 +1876,253 @@ fn only_unreadable_config_is_an_error() {
     assert_eq!(findings.len(), 1, "{findings:?}");
     assert_eq!(findings[0].rule, "lint-config");
 }
+
+#[test]
+fn redefinition_outside_inheritance_reports_the_actual_target_without_a_fix() {
+    let source = "package Quantities { attribute mass; }
+        package P {
+            private import Quantities::*;
+            part def Vehicle { part chassis { attribute mass = 0.4; } }
+            part tiny : Vehicle;
+            part analyzed :> tiny { attribute :>> mass = 0.4; }
+            part medium : Vehicle { attribute :>> chassis.mass = 2.5; }
+            part mediumAnalyzed :> medium { attribute :>> mass = 2.5; }
+            part intentional :> tiny { attribute :>> Quantities::mass = 0.4; }
+            part named : Vehicle { attribute mass :>> chassis.mass default = 2.5; }
+            part namedAnalyzed :> named { attribute :>> mass = 2.5; }
+        }";
+    let findings = rule_findings(
+        &[("model.sysml", source)],
+        "redefinition-outside-inheritance",
+    );
+    assert_eq!(findings.len(), 2, "{findings:?}");
+    let mut model = Model::new();
+    model.add_source("model.sysml", source);
+    let mut resolved = ResolvedModel::build(&model);
+    assert!(
+        !sysmlv2_parser::check::validate_model_with(&mut resolved, &model)
+            .iter()
+            .any(|(_, d)| d.message.contains("validateFeatureValueOverriding"))
+    );
+    for f in &findings {
+        assert_eq!(f.severity, Severity::Warn);
+        assert!(f.message.contains("Quantities::mass"), "{f:?}");
+        assert!(f.message.contains("chassis.mass"), "{f:?}");
+        assert_eq!(f.span.unwrap().slice(source), "mass");
+        assert!(f.fix.is_none() && f.alternatives.is_empty());
+    }
+    let config =
+        Config::from_json(r#"{"rules":{"redefinition-outside-inheritance":"off"}}"#).unwrap();
+    assert!(
+        !run(&[("model.sysml", source)], &config)
+            .iter()
+            .any(|f| f.rule == "redefinition-outside-inheritance")
+    );
+    let config = Config::from_json(r#"{"rules":{"redefinition-outside-inheritance":{"severity":"off","scopes":{"AttributeUsage":"warn"}}}}"#).unwrap();
+    assert_eq!(
+        run(&[("model.sysml", source)], &config)
+            .iter()
+            .filter(|f| f.rule == "redefinition-outside-inheritance")
+            .count(),
+        2
+    );
+}
+
+#[test]
+fn redefinition_fallback_provenance_preserves_base_order_aliases_and_cache_modes() {
+    use std::sync::Arc;
+    use sysmlv2_parser::{libcache::LibraryCache, prepared::PreparedLibrary};
+    let library = "package Quantities { feature mass; }
+        package Outer {
+            private import Quantities::*;
+            class Empty;
+            class Real { feature mass; }
+            class Imported { private import Quantities::mass; }
+            class Aliased { alias mass for Quantities::mass; }
+        }";
+    let user = "package P {
+        class Accidental specializes Outer::Empty { feature measured redefines mass = 1; }
+        class FirstWins specializes Outer::Empty, Outer::Imported { feature measured redefines mass = 1; }
+        class RealMember specializes Outer::Real { feature redefines mass = 1; }
+        class ImportedMember specializes Outer::Imported { feature redefines mass = 1; }
+        class AliasedMember specializes Outer::Aliased { feature redefines mass = 1; }
+        class Qualified specializes Outer::Empty { feature redefines Quantities::mass = 1; }
+        class Global specializes Outer::Empty { feature redefines $::Quantities::mass = 1; }
+        class Missing specializes Outer::Empty { feature redefines unknown = 1; }
+        class Incomplete specializes Outer::Empty, MissingBase { feature redefines mass = 1; }
+    }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", library);
+    base.record_library_cache();
+    let _ = ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(41).unwrap(), 41).unwrap());
+    let mut baseline = None;
+    for mode in 0..4 {
+        let mut model = Model::new();
+        match mode {
+            2 => prepared.clone().install(&mut model).unwrap(),
+            3 => decoded.clone().install(&mut model).unwrap(),
+            _ => {
+                model.add_library_source("lib.kerml", library);
+                if mode == 1 {
+                    model.set_library_cache(cache.clone());
+                }
+            }
+        }
+        model.add_source("user.kerml", user);
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let before = sysmlv2_parser::check::validate_model_with(&mut r, &model);
+        let findings: Vec<_> = lint(&mut r, &Config::default())
+            .into_iter()
+            .filter(|f| f.rule == "redefinition-outside-inheritance")
+            .collect();
+        assert_eq!(findings.len(), 2, "mode {mode}: {findings:?}");
+        let messages: Vec<_> = findings.iter().map(|f| f.message.clone()).collect();
+        assert!(messages[0].contains("P::Accidental"));
+        assert!(messages[1].contains("P::FirstWins"));
+        if let Some(ref baseline) = baseline {
+            assert_eq!(&messages, baseline);
+        } else {
+            baseline = Some(messages);
+        }
+        let after = sysmlv2_parser::check::validate_model_with(&mut r, &model);
+        assert_eq!(
+            before, after,
+            "lint must not change unused-import diagnostics"
+        );
+        let again: Vec<_> = lint(&mut r, &Config::default())
+            .into_iter()
+            .filter(|f| f.rule == "redefinition-outside-inheritance")
+            .map(|f| f.message)
+            .collect();
+        assert_eq!(again, *baseline.as_ref().unwrap());
+    }
+}
+
+#[test]
+fn redefinition_provenance_requires_complete_transitive_providers() {
+    use std::sync::Arc;
+    use sysmlv2_parser::{libcache::LibraryCache, prepared::PreparedLibrary};
+    let mut cases = vec![
+        ("class Base;", true),
+        ("class Base specializes Absent;", false),
+        (
+            "class Ancestor specializes Absent; class Base specializes Ancestor;",
+            false,
+        ),
+        ("class Base { public import Absent::*; }", false),
+        (
+            "package Provider { public import Absent::*; } class Base { public import Provider::*; }",
+            false,
+        ),
+        (
+            "class Ancestor { public import Absent::*; } feature Base : Ancestor;",
+            false,
+        ),
+        ("class Base { private import Absent::mass; }", false),
+        ("class Base { alias mass for Absent::mass; }", false),
+        ("class Base { private import Quantities::mass; }", false),
+        ("class Base { alias mass for Quantities::mass; }", false),
+        ("class Base { public import Quantities::*; }", false),
+        (
+            "package Provider { public import Quantities::*; } class Base { public import Provider::*; }",
+            false,
+        ),
+        (
+            "package Provider { feature other; } class Base { public import Provider::*; }",
+            true,
+        ),
+        (
+            "package Provider { public import Absent::*; feature other; } class Base { private import Provider::other; }",
+            true,
+        ),
+        (
+            "package Unrelated { public import Absent::*; } class Base;",
+            true,
+        ),
+        ("class Base { public import Quantities::*[true]; }", false),
+        ("class Base { public import Quantities::**; }", false),
+        (
+            "class A specializes B; class B specializes A; class Base specializes A;",
+            false,
+        ),
+        (
+            "package A { public import B::*; } package B { public import A::*; } class Base { public import A::*; }",
+            false,
+        ),
+    ];
+    cases.push(("class Container { feature item; } feature root : Container; feature Base subsets root.item;", false));
+    cases.push(("class Root; class Left specializes Root; class Right specializes Root; class Base specializes Left, Right;", true));
+    let mut deep = String::from("class Level0; ");
+    for i in 1..32 {
+        deep.push_str(&format!("class Level{i} specializes Level{}; ", i - 1));
+    }
+    deep.push_str("class Base specializes Level31;");
+    cases.push((&deep, false));
+    for (case, (declarations, warns)) in cases.into_iter().enumerate() {
+        let library = format!(
+            "package Quantities {{ feature mass; }} package Outer {{ private import Quantities::*; {declarations} }}"
+        );
+        let user = "package P { private import Quantities::*;
+            part x : Outer::Base; part Child :> x {
+                attribute measured :>> mass = 1;
+            }
+        }";
+        let mut base = Model::new();
+        base.add_library_source("lib.kerml", &library);
+        assert!(!base.has_errors(), "{declarations}");
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(41).unwrap(), 41).unwrap());
+        for mode in 0..4 {
+            let mut model = Model::new();
+            match mode {
+                2 => prepared.clone().install(&mut model).unwrap(),
+                3 => decoded.clone().install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lib.kerml", &library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("user.sysml", user);
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let before = sysmlv2_parser::check::validate_model_with(&mut r, &model);
+            if (1..=5).contains(&case) {
+                let feature = r.resolve_qualified("P::Child::measured").unwrap();
+                let mass = r.resolve_qualified("Quantities::mass").unwrap();
+                assert_eq!(
+                    r.redefinition_targets(feature),
+                    vec![mass],
+                    "mode {mode}: {declarations}"
+                );
+            }
+            for _ in 0..2 {
+                let warnings = r.redefinitions_outside_inheritance();
+                assert_eq!(
+                    warnings.len(),
+                    usize::from(warns),
+                    "mode {mode}: {declarations}"
+                );
+                if warns {
+                    let mass = r.resolve_qualified("Quantities::mass").unwrap();
+                    assert_eq!(warnings[0].0.target, mass);
+                }
+            }
+            let after = sysmlv2_parser::check::validate_model_with(&mut r, &model);
+            assert_eq!(before, after, "query effects: mode {mode}: {declarations}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/accept.rs b/crates/sysmlv2-lsp/src/accept.rs
new file mode 100644
index 0000000..3c0f396
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/accept.rs
@@ -0,0 +1,488 @@
+//! What accepting a completion item writes, decided once per request
+//! ([`Accept::new`]) and then per item ([`Accept::name`]): the range the
+//! accepted text replaces, the text itself — the name spelled as source,
+//! quoted where the name needs it — the statement repairs riding along
+//! (see [`crate::autofix`]), and the text an editor filters the item by.
+//!
+//! **Range.** The partial word, extended backward over characters of
+//! the candidate's own spelling: a typed `m/s` is replaced whole by
+//! `'m/s²'`. Inside a quoted name being typed (`['metre per sec|`) the
+//! range is the typed quoted spelling from its opening quote — through
+//! the closing quote when the line holds one, as an editor that
+//! auto-closes quotes leaves it, else through the rest of the word the
+//! cursor sits in — so the accepted name replaces every word typed, not
+//! the last one, and never leaves a quote or a word fragment behind.
+//!
+//! **Insert and replace.** With the cursor inside a word (`Mas|sValue`),
+//! a client that takes insert/replace edits gets both ranges — insert
+//! up to the cursor, replace through the rest of the word — and its own
+//! setting picks one; other clients get the insert range, as before.
+//! Items this module does not edit (keywords) get the same two ranges
+//! from [`word_edits`]. A repair that would land where the replace range
+//! ends rides the main edit then, since as a separate edit it would
+//! overlap the replacement: right for the replacing accept, while an
+//! inserting one leaves the rest of the word behind either way. Inside
+//! a quoted name being typed the one range is replaced whole.
+//!
+//! **Filtering.** An editor refilters an open list by the text typed
+//! since each item's range start, spaces included, and keeps the list
+//! open while any item matches. A name containing whitespace (a model's
+//! own `'Vehicle One'`) filters by its spelling with the whitespace
+//! replaced (`Vehicle_One`): typing its first word, or any of its words,
+//! still finds it, but a typed space matches no item and closes the
+//! list, so the next word opens a fresh list instead of being filtered
+//! against a stale one — whose first item Enter would accept. Inside a
+//! quoted name a space belongs to the name, and the text typed from the
+//! opening quote is matched against each item's quoted spelling. So it
+//! does for a unit name typed word by word without its quotes inside a
+//! bracket (`[metre per|`): once the words typed begin the name, its
+//! range covers them and it filters by its own spelling, so the next
+//! list — opened on the word after the space — still finds it. Only
+//! there: the item's editor match then runs over every word typed, so
+//! it outranks anything matching the partial word alone, and outside a
+//! bracket the words before it usually mean something else — a type
+//! followed by `ordered`, a feature followed by `then`, a keyword
+//! followed by a declared name — which accepting would replace. Outside
+//! a bracket such a name is typed from its opening quote.
+//!
+//! The repairs depend on where the replacement starts, and nearly every
+//! item of a request starts at the same place — only a restricted name
+//! reaching back over its own characters differs — so the statement is
+//! scanned once per distinct start, not once per item.
+
+use crate::autofix::{Repairs, statement_repairs};
+use crate::nav::CompletionCx;
+use crate::position::{Encoding, Mapper, offset32};
+use lsp_types::{
+    CompletionItem, CompletionTextEdit, InsertReplaceEdit, InsertTextFormat, TextEdit,
+};
+use std::cell::RefCell;
+use sysmlv2_parser::ast::Dialect;
+use sysmlv2_parser::span::Span;
+
+#[cfg(test)]
+thread_local! {
+    /// Reads of the quoted name the cursor is typing, on this thread, so
+    /// a test can pin what one completion request costs.
+    pub(crate) static QUOTE_READS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// A quoted name the cursor is typing: `'metre per sec|`, or with the
+/// closing quote an editor inserts along with the opening one,
+/// `'metre per sec|'`.
+#[derive(Clone, Copy)]
+pub(crate) struct Quoted {
+    /// The opening quote.
+    open: u32,
+    /// Just past the closing quote, when the cursor's line holds one.
+    close_end: Option<u32>,
+}
+
+impl Quoted {
+    /// Where the opening quote is.
+    pub(crate) fn open(&self) -> u32 {
+        self.open
+    }
+}
+
+/// Where accepted text goes, decided once per request: the partial
+/// word, and the quoted name being typed around it, if any.
+pub(crate) struct Replacement {
+    partial_start: u32,
+    offset: u32,
+    /// The identifier characters around the cursor: where an editor's
+    /// own insertion of a label starts (`word_start..offset`), and the
+    /// rest of the word the cursor sits in (`offset..word_end`).
+    word_start: u32,
+    word_end: u32,
+    quoted: Option<Quoted>,
+    /// The partial word sits inside an open bracket, where a unit is
+    /// written (see [`Self::typed_words`]).
+    in_bracket: bool,
+}
+
+impl Replacement {
+    pub(crate) fn new(text: &str, cx: &CompletionCx) -> Replacement {
+        let (word_start, word_end) = word_around(text, cx.offset);
+        Replacement {
+            partial_start: cx.partial_start,
+            offset: cx.offset,
+            word_start,
+            word_end,
+            quoted: cx.quoted,
+            in_bracket: cx.in_bracket,
+        }
+    }
+
+    /// Where accepting `name` starts replacing: the opening quote of a
+    /// quoted name being typed; for a unit name containing whitespace
+    /// typed word by word without its quotes, its first word (see
+    /// [`Self::typed_words`]); else the partial word extended backward
+    /// over characters of `name`'s own spelling — self-limiting: `3*m`
+    /// stops at the `*` no unit name contains.
+    pub(crate) fn start_for(&self, text: &str, name: &str) -> u32 {
+        if let Some(q) = &self.quoted {
+            return q.open;
+        }
+        if let Some(start) = self.typed_words(text, name) {
+            return start;
+        }
+        let mut start = self.partial_start as usize;
+        while let Some(prev) = text[..start].chars().next_back() {
+            if prev.is_whitespace() || prev == '\'' || !name.contains(prev) {
+                break;
+            }
+            start -= prev.len_utf8();
+        }
+        offset32(start)
+    }
+
+    /// Where `name`, a name containing whitespace, starts when it is
+    /// being typed word by word without its quotes inside a bracket
+    /// (`[metre per|` for `'metre per second squared'`): the word
+    /// furthest back on the line from which the text typed up to the
+    /// cursor begins the name, case aside. `None` outside a bracket (see
+    /// the module notes), and when no word before the partial one does.
+    fn typed_words(&self, text: &str, name: &str) -> Option<u32> {
+        if !self.in_bracket || !name.contains(char::is_whitespace) {
+            return None;
+        }
+        // No word typed before the partial one: nothing to take.
+        let mut at = self.partial_start as usize;
+        if text[..at].trim_end_matches([' ', '\t']).len() == at {
+            return None;
+        }
+        let name = name.to_lowercase();
+        let in_name = |c: char| c.to_lowercase().all(|l| name.contains(l));
+        let typed_to = self.offset as usize;
+        let mut found = None;
+        loop {
+            // Back over the spaces before this word, then over the
+            // word before them, as far as the name's own characters go.
+            let spaced = text[..at].trim_end_matches([' ', '\t']).len();
+            if spaced == at {
+                break;
+            }
+            let mut word = spaced;
+            while let Some(c) = text[..word].chars().next_back() {
+                if c.is_whitespace() || !in_name(c) {
+                    break;
+                }
+                word -= c.len_utf8();
+            }
+            if word == spaced {
+                break;
+            }
+            if name.starts_with(&text[word..typed_to].to_lowercase()) {
+                found = Some(offset32(word));
+            }
+            at = word;
+        }
+        found
+    }
+
+    /// Where the replacement ends: past the closing quote of a quoted
+    /// name being typed (the accepted spelling brings its own), through
+    /// the rest of the word the cursor sits in when the line holds no
+    /// closing quote — inside the quotes that word is part of the name
+    /// being replaced — else the cursor. What follows is the
+    /// statement's tail.
+    pub(crate) fn end(&self) -> u32 {
+        match &self.quoted {
+            Some(q) => q.close_end.unwrap_or(self.word_end),
+            None => self.offset,
+        }
+    }
+
+    /// Where a replacing accept ends: through the rest of the word the
+    /// cursor sits in — or, inside a quoted name being typed, where
+    /// [`Self::end`] does: that replacement is whole either way.
+    fn replace_end(&self) -> u32 {
+        match &self.quoted {
+            Some(_) => self.end(),
+            None => self.word_end,
+        }
+    }
+}
+
+/// The identifier characters around `offset`: where the word the
+/// cursor sits in starts and ends.
+fn word_around(text: &str, offset: u32) -> (u32, u32) {
+    let bytes = text.as_bytes();
+    let is_ident = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
+    let at = (offset as usize).min(bytes.len());
+    let mut start = at;
+    while start > 0 && is_ident(bytes[start - 1]) {
+        start -= 1;
+    }
+    let mut end = at;
+    while end < bytes.len() && is_ident(bytes[end]) {
+        end += 1;
+    }
+    (offset32(start), offset32(end))
+}
+
+/// The quoted name the cursor at `offset` is typing, its opening quote
+/// at `open` — found on the tokens of the text ahead of the cursor
+/// (see [`crate::site::Scan::quote`]) — and the rest of the line may
+/// close it. A quote that leaves the rest of the line with an
+/// unterminated quoted name opens that name instead of closing this one
+/// (`'Wid| + 'Gadget';` would pair the typed quote with the opening one
+/// of `'Gadget'`): no closing quote then. A string spanning lines that
+/// closes past the cursor reads, up to it, as one left open, so an
+/// apostrophe earlier on the cursor's line inside it is taken for the
+/// quote being typed (`it's m/|` gives `it'm/s²'`) — a rare case, and
+/// one where completion has nothing to offer anyway.
+pub(crate) fn quoted_from(text: &str, open: u32, offset: u32) -> Option<Quoted> {
+    use sysmlv2_parser::token::TokenKind;
+    #[cfg(test)]
+    QUOTE_READS.with(|n| n.set(n.get() + 1));
+    let at = offset as usize;
+    let line_end = text.get(at..)?.find('\n').map_or(text.len(), |i| at + i);
+    let line = text.get(open as usize..line_end)?;
+    let tokens = sysmlv2_parser::lexer::tokenize(line).0;
+    let (name, rest) = tokens.split_first()?;
+    let reopens = rest
+        .iter()
+        .any(|t| t.kind == TokenKind::Error && line[t.span.start as usize..].starts_with('\''));
+    Some(Quoted {
+        open,
+        close_end: (name.kind == TokenKind::UnrestrictedName && !reopens)
+            .then(|| open + name.span.end),
+    })
+}
+
+/// One request's completion accepts: the document, where accepted text
+/// goes, and what the client takes.
+pub(crate) struct Accept<'a> {
+    text: &'a str,
+    mapper: Mapper<'a>,
+    dialect: Dialect,
+    stmt_start: u32,
+    at: Replacement,
+    /// The client takes snippet syntax: a repair suffix riding the main
+    /// edit carries a `$0` stop ahead of it.
+    snippets: bool,
+    /// The client takes insert/replace edits.
+    insert_replace: bool,
+    /// Statement repairs by replacement start.
+    repairs: RefCell<Vec<(u32, Option<Repairs>)>>,
+}
+
+/// The edits accepting one item performs; [`Self::fill`] puts them on
+/// the item.
+#[derive(Default)]
+pub(crate) struct ItemEdits {
+    /// The main edit; `None` when inserting the label over the word
+    /// being completed is exactly right.
+    pub text_edit: Option<CompletionTextEdit>,
+    /// A repair landing behind the main edit.
+    pub repair: Option<TextEdit>,
+    /// Snippet format, when the main edit carries a cursor stop.
+    pub insert_text_format: Option<InsertTextFormat>,
+    /// The text the item is filtered by, when its label will not do.
+    pub filter_text: Option<String>,
+}
+
+impl ItemEdits {
+    /// `item` with these edits, the `imports` its name needs riding
+    /// ahead of the repair. Every tier completes its items here, so
+    /// none can drop a field — the filter text least of all, without
+    /// which a typed space keeps a list open again.
+    pub(crate) fn fill(self, item: CompletionItem, imports: Vec<TextEdit>) -> CompletionItem {
+        let additional: Vec<TextEdit> = imports.into_iter().chain(self.repair).collect();
+        CompletionItem {
+            text_edit: self.text_edit,
+            additional_text_edits: (!additional.is_empty()).then_some(additional),
+            insert_text_format: self.insert_text_format,
+            filter_text: self.filter_text,
+            ..item
+        }
+    }
+}
+
+impl<'a> Accept<'a> {
+    pub(crate) fn new(
+        text: &'a str,
+        enc: Encoding,
+        cx: &CompletionCx,
+        dialect: Dialect,
+        snippets: bool,
+        insert_replace: bool,
+    ) -> Accept<'a> {
+        Accept {
+            text,
+            mapper: Mapper::new(text, enc),
+            dialect,
+            stmt_start: cx.stmt_start,
+            at: Replacement::new(text, cx),
+            snippets,
+            insert_replace,
+            repairs: RefCell::new(Vec::new()),
+        }
+    }
+
+    /// Accepting `name`. Insert text is source for this document: a
+    /// name the dialect reserves (`'view'`) and a non-basic name
+    /// (`'m/s²'` — the raw label would parse as an expression) insert
+    /// quoted, over the typed spelling (see [`Replacement::start_for`]);
+    /// a word the dialect does not reserve stays bare, even where it was
+    /// typed quoted. No main edit for a basic name needing no repairs:
+    /// plain label insertion is right and keeps the item light.
+    pub(crate) fn name(&self, name: &str) -> ItemEdits {
+        let spelled = sysmlv2_parser::name::spell_name_in(Some(self.dialect), name);
+        let start = self.at.start_for(self.text, name);
+        let plain = spelled == name;
+        self.edits(name, spelled, start, plain)
+    }
+
+    /// Accepting the item named `name` by inserting `spelled` — source
+    /// text already, such as an import's qualified path — over the
+    /// partial word, or the quoted name being typed.
+    pub(crate) fn spelled(&self, name: &str, spelled: String) -> ItemEdits {
+        let start = self
+            .at
+            .quoted
+            .as_ref()
+            .map_or(self.at.partial_start, |q| q.open);
+        self.edits(name, spelled, start, false)
+    }
+
+    /// The main edit writing `spelled` from `start`, with the statement
+    /// repairs riding along: the suffix on the main edit, the rest as a
+    /// separate insertion past it. When a repair suffix rides the main
+    /// edit and the client takes snippets, the edit carries a `$0` stop
+    /// between the text and the suffix: the cursor belongs where typing
+    /// continues, before the auto-inserted `]`, not after it. `plain`:
+    /// the editor's own insertion of the label would write `spelled`.
+    fn edits(&self, name: &str, spelled: String, start: u32, plain: bool) -> ItemEdits {
+        let range = Span::new(start, self.at.end());
+        let replace_end = self.at.replace_end();
+        // Mid-word, for a client that takes both: insert and replace.
+        let both = self.insert_replace && replace_end != range.end;
+        let (mut suffix, mut insert) = match self.repairs(start) {
+            Some(r) => (r.suffix, r.insert),
+            None => (String::new(), None),
+        };
+        // A repair landing where the replaced word ends would overlap
+        // the replacement: it rides the main edit instead, right for the
+        // replacing accept (`[m|s` → `['m/s²']`); inserting mid-word
+        // leaves the rest of the word behind either way.
+        if both {
+            if let Some((_, fix)) = insert.take_if(|(at, _)| *at <= replace_end) {
+                suffix.push_str(&fix);
+            }
+        }
+        let snippet = self.snippets && !suffix.is_empty();
+        // What an editor inserts for an item without an edit: its label
+        // over the word before the cursor.
+        let default_range = range == Span::new(self.at.word_start, self.at.offset);
+        let text_edit = (!plain || !suffix.is_empty() || !default_range || both).then(|| {
+            let new_text = if snippet {
+                format!("{}$0{suffix}", snippet_escape(&spelled))
+            } else {
+                format!("{spelled}{suffix}")
+            };
+            let insert = self.mapper.range(range);
+            if both {
+                CompletionTextEdit::InsertAndReplace(InsertReplaceEdit {
+                    new_text,
+                    insert,
+                    replace: self.mapper.range(Span::new(start, replace_end)),
+                })
+            } else {
+                CompletionTextEdit::Edit(TextEdit {
+                    range: insert,
+                    new_text,
+                })
+            }
+        });
+        ItemEdits {
+            text_edit,
+            repair: insert.map(|(at, fix)| TextEdit {
+                range: self.mapper.range(Span::new(at, at)),
+                new_text: fix,
+            }),
+            insert_text_format: snippet.then_some(InsertTextFormat::SNIPPET),
+            filter_text: match self.at.quoted {
+                Some(_) => Some(quoted_spelling(name)),
+                // Typed word by word: the text an editor matches holds
+                // the name's own spaces.
+                None if self.text[start as usize..self.at.offset as usize]
+                    .contains(char::is_whitespace) =>
+                {
+                    None
+                }
+                None => name
+                    .contains(char::is_whitespace)
+                    .then(|| name.replace(char::is_whitespace, "_")),
+            },
+        }
+    }
+
+    /// The statement repairs for a replacement starting at `start`,
+    /// scanned on first use. The scan reads the statement up to `start`
+    /// — before any opening quote the replacement absorbs, so it never
+    /// sees a dangling quoted name — and the tail from the
+    /// replacement's end.
+    fn repairs(&self, start: u32) -> Option<Repairs> {
+        let mut memo = self.repairs.borrow_mut();
+        if let Some((_, known)) = memo.iter().find(|(s, _)| *s == start) {
+            return known.clone();
+        }
+        let scanned = statement_repairs(self.text, self.stmt_start, start, self.at.end());
+        memo.push((start, scanned.clone()));
+        scanned
+    }
+}
+
+/// With the cursor at `offset` inside a word, give each item left to the
+/// editor's default insertion — its label over the partial word, no
+/// edit of its own, as keywords are — the insert and replace ranges
+/// [`Accept`] gives the items it edits. For a client that takes
+/// insert/replace edits only.
+pub(crate) fn word_edits(items: &mut [CompletionItem], text: &str, offset: u32, enc: Encoding) {
+    let (start, end) = word_around(text, offset);
+    if end == offset {
+        return;
+    }
+    let mapper = Mapper::new(text, enc);
+    let insert = mapper.range(Span::new(start, offset));
+    let replace = mapper.range(Span::new(start, end));
+    for item in items.iter_mut().filter(|i| i.text_edit.is_none()) {
+        let new_text = item
+            .insert_text
+            .take()
+            .unwrap_or_else(|| item.label.clone());
+        item.text_edit = Some(CompletionTextEdit::InsertAndReplace(InsertReplaceEdit {
+            new_text,
+            insert,
+            replace,
+        }));
+    }
+}
+
+/// `name` spelled as a quoted name whatever its form (`'Widget'`,
+/// `'metre per second'`): the text typed inside a quoted name is
+/// matched against it.
+fn quoted_spelling(name: &str) -> String {
+    let escaped = sysmlv2_parser::ast::escape_name(name);
+    if escaped.starts_with('\'') {
+        escaped
+    } else {
+        format!("'{escaped}'")
+    }
+}
+
+/// A completion's literal text made safe for snippet-format delivery:
+/// `$`, `}`, and `\` are snippet syntax and must arrive escaped.
+fn snippet_escape(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    for c in text.chars() {
+        if matches!(c, '$' | '}' | '\\') {
+            out.push('\\');
+        }
+        out.push(c);
+    }
+    out
+}
diff --git a/crates/sysmlv2-lsp/src/autofix.rs b/crates/sysmlv2-lsp/src/autofix.rs
index 111c37e..739aeca 100644
--- a/crates/sysmlv2-lsp/src/autofix.rs
+++ b/crates/sysmlv2-lsp/src/autofix.rs
@@ -1,41 +1,57 @@
 //! Statement repairs riding a completion accept (the auto-import
 //! tier's second half): accepting a suggestion mid-statement also fixes what
-//! the statement being typed still obviously needs. Today that is two
-//! passes — close unbalanced quantity brackets, insert the terminal
-//! semicolon — and the module is shaped for more: each pass reads the
-//! shared [`Cx`] and appends to the fix, so a new auto-fixable thing
-//! is a new pass function in [`statement_repairs`]'s sequence, not a
-//! rework.
+//! the statement being typed still obviously needs. Today that is one
+//! pass — close unbalanced quantity brackets — and the module is shaped
+//! for more: each pass reads the shared [`Cx`] and appends to the fix,
+//! so a new auto-fixable thing is a new pass function in
+//! [`statement_repairs`]'s sequence, not a rework.
+//!
+//! No pass inserts the terminal `;`. The scan cannot tell whether the
+//! statement is finished — a body, a multiplicity, or a value may follow
+//! the accepted name — nor whether the enclosing body takes terminated
+//! members at all: a constraint or calculation body ends in a bare
+//! result expression, where a `;` is a syntax error. And a terminator
+//! waiting behind the cursor doubles the one typed at the end.
 //!
 //! Repairs only ever apply when the cursor sits at the *effective end*
 //! of the statement's line — everything after it is whitespace, a
 //! continuation of the name chain being completed (`.volume` when the
-//! accept lands mid-chain), closing brackets, or the terminator itself
-//! — so mid-expression edits are never touched. The analysis is
-//! lexical over the statement prefix (strings and comments respected);
+//! accept lands mid-chain), closing brackets, or the terminator — so
+//! mid-expression edits are never touched. The analysis is
+//! lexical over the statement prefix, on the toolkit's own tokens
+//! (strings, quoted names, comments, and notes respected);
 //! a context the scan cannot judge (an unclosed `(`, an unterminated
 //! string outside the completion's own replacement) yields no repairs
 //! at all: a wrong fix costs more than a missing one.
 //!
-//! Delivery: when nothing follows the cursor, the repair text rides
-//! the completion's main text edit (`'m/s²'];`) — one edit, no
-//! ordering questions. When a chain tail or auto-closed brackets
-//! already sit after the cursor, what remains becomes its own
-//! insertion after them (a position strictly past the main edit, so
-//! clients apply it unambiguously). Either way the cursor belongs
-//! where typing continues — after the accepted name, *before* any
-//! repair text — which the suffix path realizes as a snippet stop
-//! (see `item_edits` in `nav`) and the insertion path gets for free.
+//! Delivery: when nothing but whitespace or the terminator follows the
+//! cursor, the repair text rides the completion's main text edit
+//! (`'m/s²']`, ahead of any `;`) — one edit, no ordering questions.
+//! When a chain tail or auto-closed brackets already sit after the
+//! cursor, what remains becomes its own insertion behind them — a
+//! position strictly past the main edit, never at its end, as the
+//! protocol requires of additional edits. Either way the cursor
+//! belongs where typing continues — after the accepted name, *before*
+//! any repair text — which the suffix path realizes as a snippet stop
+//! (see [`crate::accept`]) and the insertion path gets for free.
 
 use crate::position::offset32;
 
+#[cfg(test)]
+thread_local! {
+    /// Statement scans run on this thread, so a test can pin what one
+    /// completion request costs.
+    pub(crate) static SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
 /// What a completion accept should additionally fix.
+#[derive(Clone)]
 pub(crate) struct Repairs {
     /// Appended to the completion's inserted text.
     pub suffix: String,
-    /// A separate insertion `(byte offset, text)` past the cursor, for
-    /// what cannot ride the main edit (the tail already holds closers
-    /// the fix must land behind).
+    /// A separate insertion `(byte offset, text)` strictly past the
+    /// main edit, for what cannot ride it (the tail already holds
+    /// closers or a chain tail the fix must land behind).
     pub insert: Option<(u32, String)>,
 }
 
@@ -47,27 +63,30 @@ struct Cx {
     open_brackets: usize,
     /// `]` count in the tail (before any `;`).
     closers_after: usize,
-    /// The tail already terminates the statement.
-    has_semicolon: bool,
 }
 
-/// Compute the repairs a completion accepted at `offset` should carry.
-/// `stmt_start`..`prefix_end` is the statement text the accept leaves
-/// in place (`prefix_end` = the main edit's replacement start, so a
-/// typed opening quote the edit absorbs does not read as an
-/// unterminated string). `None`: nothing to fix, or no safe judgment.
+/// Compute the repairs a completion accept should carry. The accept
+/// replaces `prefix_end..tail_start`: `stmt_start..prefix_end` is the
+/// statement text it leaves in place ahead of it (`prefix_end` = the
+/// main edit's replacement start, so a typed opening quote the edit
+/// absorbs does not read as an unterminated string), and the line's
+/// tail runs from `tail_start` — the cursor, or past what the edit
+/// replaces beyond it (the rest of a quoted name being typed). `None`:
+/// nothing to fix, or no safe judgment.
 pub(crate) fn statement_repairs(
     text: &str,
     stmt_start: u32,
     prefix_end: u32,
-    offset: u32,
+    tail_start: u32,
 ) -> Option<Repairs> {
+    #[cfg(test)]
+    SCANS.with(|n| n.set(n.get() + 1));
     let stmt = text.get(stmt_start as usize..prefix_end as usize)?;
-    let line_end = text[offset as usize..]
+    let line_end = text[tail_start as usize..]
         .find('\n')
-        .map(|i| offset as usize + i)
+        .map(|i| tail_start as usize + i)
         .unwrap_or(text.len());
-    let tail = &text[offset as usize..line_end];
+    let tail = &text[tail_start as usize..line_end];
 
     let open_brackets = open_brackets(stmt)?;
     // The tail must hold nothing but a continuation of the name chain
@@ -78,17 +97,13 @@ pub(crate) fn statement_repairs(
     let mut closers_after = 0usize;
     let mut has_semicolon = false;
     let mut last_closer_end: Option<usize> = None;
-    let mut semicolon_at: Option<usize> = None;
     for (i, c) in tail.char_indices() {
         match c {
             ']' if !has_semicolon => {
                 closers_after += 1;
                 last_closer_end = Some(i + 1);
             }
-            ';' if !has_semicolon => {
-                has_semicolon = true;
-                semicolon_at = Some(i);
-            }
+            ';' if !has_semicolon => has_semicolon = true,
             c if (c.is_ascii_alphanumeric() || c == '_' || c == '.')
                 && closers_after == 0
                 && !has_semicolon =>
@@ -102,32 +117,29 @@ pub(crate) fn statement_repairs(
     let cx = Cx {
         open_brackets,
         closers_after,
-        has_semicolon,
     };
 
-    // The passes, in statement order: brackets close before the
-    // terminator. A future pass appends here.
+    // The passes, in statement order. A future pass appends here.
     let mut fix = String::new();
     fix.push_str(&close_brackets_pass(&cx)?);
-    fix.push_str(terminator_pass(&cx));
     if fix.is_empty() {
         return None;
     }
 
-    if closers_after == 0 && !has_semicolon && chain_end.is_none() {
-        // Bare tail: everything rides the main edit.
+    if closers_after == 0 && chain_end.is_none() {
+        // Nothing to land behind (whitespace, at most a terminator):
+        // the fix rides the main edit, ahead of the tail.
         return Some(Repairs {
             suffix: fix,
             insert: None,
         });
     }
-    // Land behind the existing closers and chain tail (and before an
-    // existing `;`, where only closers remain to add).
+    // Land behind the existing closers and chain tail: strictly past
+    // the main edit, never at its end.
     let at = last_closer_end
-        .or(semicolon_at)
         .or(chain_end)
-        .map(|i| offset + offset32(i))
-        .unwrap_or(offset);
+        .map(|i| tail_start + offset32(i))
+        .unwrap_or(tail_start);
     Some(Repairs {
         suffix: String::new(),
         insert: Some((at, fix)),
@@ -142,57 +154,59 @@ fn close_brackets_pass(cx: &Cx) -> Option<String> {
     Some("]".repeat(needed))
 }
 
-/// Pass: the terminal `;`, when the tail does not already have one.
-fn terminator_pass(cx: &Cx) -> &'static str {
-    if cx.has_semicolon { "" } else { ";" }
+/// Unclosed `[` count in the statement prefix. `None` for contexts a
+/// repair cannot judge: text that does not lex (an unterminated string,
+/// quoted name, comment, or note; a stray character such as a lone `!`
+/// or an unquoted `°`), a `]` without its `[`, or an unclosed `(`/`{`
+/// (the cursor is inside a grouping whose completion the user still
+/// owes).
+fn open_brackets(stmt: &str) -> Option<usize> {
+    let g = groupings(stmt);
+    (!g.unlexable && !g.unmatched && g.parens_or_braces == 0).then_some(g.brackets)
 }
 
-/// Unclosed `[` count in the statement prefix, strings and comments
-/// skipped. `None` for contexts a repair cannot judge: an unterminated
-/// string or comment, or an unclosed `(`/`{` (the cursor is inside a
-/// grouping whose completion the user still owes).
-fn open_brackets(stmt: &str) -> Option<usize> {
-    let mut depth = 0usize;
-    let mut paren_or_brace = 0usize;
-    let mut chars = stmt.chars().peekable();
-    while let Some(c) = chars.next() {
-        match c {
-            '\'' | '"' => loop {
-                match chars.next() {
-                    None => return None,
-                    Some('\\') => {
-                        chars.next();
-                    }
-                    Some(q) if q == c => break,
-                    Some(_) => {}
-                }
+/// The groupings a statement prefix leaves open, counted over the
+/// toolkit's own tokens: a string, a quoted name, a comment, or a note
+/// (`//* … */` included) is one token, so a bracket inside it never
+/// counts.
+struct Groupings {
+    /// Unclosed `[`.
+    brackets: usize,
+    /// Unclosed `(` and `{` together.
+    parens_or_braces: usize,
+    /// A `]` arrived with no `[` open (it is not counted).
+    unmatched: bool,
+    /// Some span did not lex: an unterminated string, quoted name,
+    /// comment, or note (one token running to the end), or a stray
+    /// character.
+    unlexable: bool,
+}
+
+/// Count the groupings `stmt` leaves open (see [`Groupings`]).
+fn groupings(stmt: &str) -> Groupings {
+    use sysmlv2_parser::token::TokenKind;
+    let mut g = Groupings {
+        brackets: 0,
+        parens_or_braces: 0,
+        unmatched: false,
+        unlexable: false,
+    };
+    for token in sysmlv2_parser::lexer::tokenize(stmt).0 {
+        match token.kind {
+            TokenKind::LBracket => g.brackets += 1,
+            TokenKind::RBracket => match g.brackets.checked_sub(1) {
+                Some(depth) => g.brackets = depth,
+                None => g.unmatched = true,
             },
-            '/' if chars.peek() == Some(&'/') => {
-                for q in chars.by_ref() {
-                    if q == '\n' {
-                        break;
-                    }
-                }
+            TokenKind::LParen | TokenKind::LBrace => g.parens_or_braces += 1,
+            TokenKind::RParen | TokenKind::RBrace => {
+                g.parens_or_braces = g.parens_or_braces.saturating_sub(1);
             }
-            '/' if chars.peek() == Some(&'*') => {
-                chars.next();
-                let mut prev = ' ';
-                loop {
-                    match chars.next() {
-                        None => return None,
-                        Some('/') if prev == '*' => break,
-                        Some(q) => prev = q,
-                    }
-                }
-            }
-            '[' => depth += 1,
-            ']' => depth = depth.checked_sub(1)?,
-            '(' | '{' => paren_or_brace += 1,
-            ')' | '}' => paren_or_brace = paren_or_brace.saturating_sub(1),
+            TokenKind::Error => g.unlexable = true,
             _ => {}
         }
     }
-    (paren_or_brace == 0).then_some(depth)
+    g
 }
 
 #[cfg(test)]
@@ -217,83 +231,120 @@ mod tests {
     }
 
     #[test]
-    fn closes_bracket_and_terminates_on_bare_tail() {
+    fn closes_bracket_on_bare_tail() {
         let text = "package P {\n    attribute g = 9.8 [m\n}\n";
-        assert_eq!(repairs(text, "[m"), Some(("];".to_string(), None)));
+        assert_eq!(repairs(text, "[m"), Some(("]".to_string(), None)));
     }
 
     #[test]
-    fn terminates_behind_an_auto_closed_bracket() {
-        let text = "package P {\n    attribute g = 9.8 [m]\n}\n";
-        let (suffix, insert) = repairs(text, "[m").expect("repairs");
-        assert_eq!(suffix, "");
-        let at = offset32(text.find("m]").unwrap()) + 2;
-        assert_eq!(insert, Some((at, ";".to_string())));
+    fn nothing_behind_a_closed_bracket() {
+        for text in [
+            "package P {\n    attribute g = 9.8 [m]\n}\n",
+            "package P {\n    attribute g = 9.8 [m];\n}\n",
+        ] {
+            assert_eq!(repairs(text, "[m"), None, "{text:?}");
+        }
     }
 
     #[test]
     fn closes_bracket_before_an_existing_terminator() {
-        let text = "package P {\n    attribute g = 9.8 [m;\n}\n";
-        let (suffix, insert) = repairs(text, "[m").expect("repairs");
+        for text in [
+            "package P {\n    attribute g = 9.8 [m;\n}\n",
+            "package P {\n    attribute g = 9.8 [m  ;\n}\n",
+        ] {
+            assert_eq!(
+                repairs(text, "[m"),
+                Some(("]".to_string(), None)),
+                "{text:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn closes_bracket_behind_a_chain_tail_ahead_of_a_terminator() {
+        let text = "package P {\n    attribute v = a[b.chain;\n}\n";
+        let (suffix, insert) = repairs(text, "a[b").expect("repairs");
         assert_eq!(suffix, "");
-        let at = offset32(text.find(';').unwrap());
+        let at = offset32(text.find(".chain").unwrap()) + 6;
         assert_eq!(insert, Some((at, "]".to_string())));
     }
 
+    /// The terminator is never inserted: not after a plain statement,
+    /// a chain tail, or an import path, and not inside a body whose
+    /// last member is a bare result expression.
     #[test]
-    fn terminates_plain_statements() {
-        let text = "package P {\n    part w : Whee\n}\n";
-        assert_eq!(repairs(text, "Whee"), Some((";".to_string(), None)));
+    fn never_terminates_the_statement() {
+        for (text, cursor) in [
+            ("package P {\n    part w : Whee\n}\n", "Whee"),
+            (
+                "package P {\n    attribute v = fuelTank.over.volume\n}\n",
+                "over",
+            ),
+            ("package P {\n    private import Qua\n}\n", "Qua"),
+            (
+                "part def P {\n    assert constraint {\n        mass <= lim\n    }\n}\n",
+                "<= lim",
+            ),
+            ("calc def F {\n    in x : Real;\n    x * fac\n}\n", "* fac"),
+        ] {
+            assert_eq!(repairs(text, cursor), None, "{text}");
+        }
     }
 
     #[test]
-    fn terminates_behind_a_chain_tail() {
-        // Accept lands mid-chain (`fuelTank.over|.volume`): the `;`
-        // goes after the tail, not at the cursor.
-        let text = "package P {\n    attribute v = fuelTank.over.volume\n}\n";
-        let (suffix, insert) = repairs(text, "over").expect("repairs");
-        assert_eq!(suffix, "");
-        let at = offset32(text.find(".volume").unwrap()) + 7;
-        assert_eq!(insert, Some((at, ";".to_string())));
+    fn closes_bracket_in_a_constraint_body() {
+        let text = "part def P {\n    assert constraint {\n        mass <= 2000 [k\n    }\n}\n";
+        assert_eq!(repairs(text, "[k"), Some(("]".to_string(), None)));
     }
 
     #[test]
-    fn closes_bracket_behind_a_chain_and_its_closer() {
-        let text = "package P {\n    attribute v = a[b.chain]\n}\n";
+    fn closes_bracket_behind_a_chain_tail() {
+        // Accept lands mid-chain (`a[b|.chain`): the `]` goes after the
+        // tail, not at the cursor.
+        let text = "package P {\n    attribute v = a[b.chain\n}\n";
         let (suffix, insert) = repairs(text, "a[b").expect("repairs");
         assert_eq!(suffix, "");
-        let at = offset32(text.find("chain]").unwrap()) + 6;
-        assert_eq!(insert, Some((at, ";".to_string())));
+        let at = offset32(text.find(".chain").unwrap()) + 6;
+        assert_eq!(insert, Some((at, "]".to_string())));
     }
 
     #[test]
-    fn nothing_when_a_chain_tail_is_already_terminated() {
-        let text = "package P {\n    attribute v = fuelTank.over.volume;\n}\n";
-        assert_eq!(repairs(text, "over"), None);
+    fn nothing_when_a_chain_tail_already_closes() {
+        let text = "package P {\n    attribute v = a[b.chain]\n}\n";
+        assert_eq!(repairs(text, "a[b"), None);
     }
 
     #[test]
-    fn nothing_when_already_terminated() {
-        let text = "package P {\n    attribute g = 9.8 [m];\n}\n";
+    fn nothing_mid_expression() {
+        let text = "package P {\n    attribute g = 9.8 [m * 2];\n}\n";
         assert_eq!(repairs(text, "[m"), None);
     }
 
     #[test]
-    fn nothing_mid_expression() {
-        let text = "package P {\n    attribute g = 9.8 [m * 2];\n}\n";
+    fn nothing_inside_open_parens() {
+        let text = "package P {\n    calc def F(\n        x = 9.8 [m\n}\n";
         assert_eq!(repairs(text, "[m"), None);
     }
 
     #[test]
-    fn nothing_inside_open_parens() {
-        let text = "package P {\n    calc def F(\n        x : Rea\n}\n";
-        assert_eq!(repairs(text, "Rea"), None);
+    fn noted_brackets_do_not_count() {
+        // A note runs to its `*/`, across lines; counted, its `[` would
+        // ask for a `]`.
+        let text = "package P {\n    attribute g = 9.8 //* see\n    [ */ + m\n}\n";
+        assert_eq!(repairs(text, "+ m"), None);
+    }
+
+    #[test]
+    fn nothing_after_text_that_does_not_lex() {
+        let text = "package P {\n    attribute g = x ! 9.8 [m\n}\n";
+        assert_eq!(repairs(text, "[m"), None);
     }
 
     #[test]
     fn quoted_brackets_do_not_count() {
+        // Counted, the quoted `[` would ask for a `]`.
         let text = "package P {\n    attribute g = 'a[' + m\n}\n";
-        assert_eq!(repairs(text, "+ m"), Some((";".to_string(), None)));
+        assert_eq!(repairs(text, "+ m"), None);
     }
 
     #[test]
@@ -303,6 +354,6 @@ mod tests {
         let text = "package P {\n    attribute g = 9.8 ['m\n}\n";
         let offset = offset32(text.find("['m").unwrap() + 3);
         let r = statement_repairs(text, 12, offset - 2, offset).expect("repairs");
-        assert_eq!(r.suffix, "];");
+        assert_eq!(r.suffix, "]");
     }
 }
diff --git a/crates/sysmlv2-lsp/src/autoimport.rs b/crates/sysmlv2-lsp/src/autoimport.rs
index dd50243..53125e6 100644
--- a/crates/sysmlv2-lsp/src/autoimport.rs
+++ b/crates/sysmlv2-lsp/src/autoimport.rs
@@ -7,15 +7,21 @@
 //!
 //! Everything here is syntax-tier over the current document, matching
 //! the completion path's cost model (no per-keystroke model build).
-//! Visibility is therefore approximate in a deliberate direction:
-//! only *provably present* names (a declaration or an admitting import
-//! in the cursor's scope chain) suppress the edit, and the analysis
-//! cannot see inheritance — a name visible only through a
-//! specialization still gets an import offered. That import is
-//! redundant, never wrong: the qualified target resolves from the root
-//! namespace regardless.
+//! The cursor's scope chain is read as the notation resolves a name,
+//! innermost first: the first scope that declares the name or whose
+//! imports bring it in decides what it finds. The analysis cannot see
+//! inheritance — a name visible only through a specialization still
+//! gets an import offered, redundant but harmless: the qualified target
+//! resolves from the root namespace regardless. What an imported
+//! namespace makes visible is the one fact from beyond the document:
+//! the symbol tables supply it ([`Reexports`]), so an existing
+//! `import ISQ::*;` admits `MassValue`, which `ISQ` re-exports from
+//! `ISQBase` — but not a name two of a scope's imports bring in for
+//! different elements, which finds neither: an import of the one
+//! member, found ahead of them, settles it.
 
 use crate::position::offset32;
+use std::collections::HashMap;
 use sysmlv2_parser::ast::{Dialect, Import, Member, MemberKind, Name, SourceUnit, Visibility};
 use sysmlv2_parser::span::Span;
 
@@ -25,6 +31,149 @@ struct Scope<'a> {
     /// A package/namespace body (or the unit root) — somewhere an
     /// import statement conventionally belongs.
     package: bool,
+    /// The namespace's qualified path (`""`: the unit root) — where an
+    /// import in it resolves from. A usage without a name of its own
+    /// has its effective name's; another anonymous member's body keeps
+    /// the path of the namespace around it.
+    path: String,
+    /// The names its members declare — by name, short name, or the
+    /// name a usage without one is found by — but the phantom the
+    /// half-typed statement introduces, sorted for a binary search.
+    declared: Vec<&'a str>,
+}
+
+/// What the symbol tables know about namespaces beyond the document.
+pub(crate) trait Reexports {
+    /// The qualified path of the namespace an import names: the import
+    /// sits in the namespace at `owner` (`""` for the root) and names
+    /// `target` as written.
+    fn namespace(&self, owner: &str, target: &[String], global: bool) -> Option<String>;
+    /// What `name` denotes, measured against the symbol at `qualified`,
+    /// among what an import of the namespace at `ns` brings in — its
+    /// members, and with `recursive` those of the namespaces below it —
+    /// as a client of `ns` finds them (owned there, or brought in by its
+    /// public imports), or with `all` as a name written inside it does.
+    fn brought(&self, ns: &str, name: &str, qualified: &str, recursive: bool, all: bool)
+    -> Brought;
+    /// What `name` denotes, measured against the symbol at `qualified`,
+    /// among what the element at `ns` inherits from what it specializes.
+    fn inherits(&self, ns: &str, name: &str, qualified: &str) -> Brought;
+    /// The paths of the elements the element at `ns` inherits from what
+    /// it specializes, each found there by its name alone.
+    fn inherited_paths(&self, ns: &str) -> Vec<String>;
+    /// The path an import of the symbol at `qualified` (named `name`)
+    /// should name when it runs through a package that re-exports it
+    /// (`ISQ::MassValue` for `ISQBase::MassValue`), `None` when it is
+    /// the symbol's own.
+    fn import_route(&self, name: &str, qualified: &str) -> Option<String>;
+}
+
+/// What a name finds, measured against the symbol asked about.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Brought {
+    Nothing,
+    /// That symbol, and nothing else.
+    It,
+    /// One other element, told apart by its path (hashed): a reference
+    /// to the name finds it.
+    Else(u64),
+    /// Several elements: a reference to the name is ambiguous.
+    Several,
+}
+
+impl Brought {
+    /// The one other element at `path`.
+    pub(crate) fn other(path: &str) -> Brought {
+        use std::hash::{Hash, Hasher};
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        path.hash(&mut hasher);
+        Brought::Else(hasher.finish())
+    }
+
+    /// Take in `other`, brought in beside this.
+    fn add(&mut self, other: Brought) {
+        *self = match (*self, other) {
+            (Brought::Nothing, other) | (other, Brought::Nothing) => other,
+            (Brought::It, Brought::It) => Brought::It,
+            (Brought::Else(a), Brought::Else(b)) if a == b => Brought::Else(a),
+            _ => Brought::Several,
+        };
+    }
+}
+
+/// What accepting a name by itself at the cursor takes to resolve to
+/// the symbol offered.
+pub(crate) enum Needs {
+    /// Nothing: the name finds it as it stands.
+    Nothing,
+    /// This import.
+    Import(ImportEdit),
+    /// More than an import should give: the name finds another element
+    /// at the cursor — which an inserted import would take it from, for
+    /// every reference in the package — or two, decided nearer the
+    /// cursor than the import can go.
+    Qualifier,
+}
+
+/// Which imports admission takes at their word for a symbol (see
+/// [`AutoImport::finds`]).
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Admit {
+    /// Any: an import whose target the symbol tables do not resolve
+    /// admits a name its target spells the symbol with, as a guess.
+    Any,
+    /// Those the tables resolve, and such a guess only for an
+    /// `import all`: for a member its namespace holds private or
+    /// protected, which no other import brings in.
+    All,
+    /// Those the tables resolve alone: for a symbol an ancestor's
+    /// visibility keeps inside a namespace, which a guess from its path
+    /// cannot see.
+    Resolved,
+}
+
+/// What a name finds at the cursor (see [`AutoImport::finds`]).
+enum Found {
+    /// The symbol asked about.
+    It,
+    /// Nothing.
+    Nowhere,
+    /// Something else, or two elements (`several`), in the scope at
+    /// this index of the chain — decided there by a declaration or an
+    /// import of the one name (`fixed`), which an inserted import beside
+    /// them cannot outrank, or by the namespace imports, which it can.
+    Other {
+        scope: usize,
+        fixed: bool,
+        several: bool,
+    },
+}
+
+/// An import statement to insert: the byte offset, the text, the
+/// root-qualified path it names when that is not the symbol's own, and
+/// whether it writes that path from the global scope (`$::`).
+pub(crate) struct ImportEdit {
+    pub at: u32,
+    pub text: String,
+    pub route: Option<String>,
+    pub global: bool,
+}
+
+impl ImportEdit {
+    /// The path the statement names, the symbol's own being `qualified`.
+    pub fn path<'a>(&'a self, qualified: &'a str) -> &'a str {
+        self.route.as_deref().unwrap_or(qualified)
+    }
+
+    /// That path as the statement spells it in `dialect`.
+    pub fn spelled(&self, dialect: Dialect, qualified: &str) -> String {
+        let path = escape_qualified(dialect, self.path(qualified));
+        if self.global {
+            format!("$::{path}")
+        } else {
+            path
+        }
+    }
 }
 
 /// The cursor's syntactic surroundings: the ancestor scope chain
@@ -37,6 +186,17 @@ pub(crate) struct AutoImport<'a> {
     dialect: Dialect,
     scopes: Vec<Scope<'a>>,
     partial: Span,
+    /// What the scope chain's imports name, as the symbol tables resolve
+    /// their targets, by import member start.
+    targets: HashMap<u32, String>,
+    /// The symbol tables, when known: they choose the imported path.
+    tables: Option<&'a dyn Reexports>,
+    /// Whether an inserted import starts at the global scope, by the
+    /// path's first segment, once asked (see [`Self::needs`]).
+    rooted: std::cell::RefCell<HashMap<String, bool>>,
+    /// The paths of what the scopes around the cursor inherit, once
+    /// asked (see [`Self::may_find`]).
+    inherited: std::cell::OnceCell<std::collections::HashSet<String>>,
 }
 
 impl<'a> AutoImport<'a> {
@@ -44,14 +204,35 @@ impl<'a> AutoImport<'a> {
         let mut scopes = vec![Scope {
             members: &unit.members,
             package: true,
+            path: String::new(),
+            declared: declared_in(&unit.members, partial),
         }];
         loop {
-            let cur = scopes.last().unwrap().members;
-            let next = cur.iter().find_map(|m| {
+            let cur = scopes.last().unwrap();
+            let next = cur.members.iter().find_map(|m| {
                 if m.span.start <= offset && offset <= m.span.end {
-                    body_of(&m.kind).map(|b| Scope {
-                        members: b,
-                        package: matches!(m.kind, MemberKind::Package(_)),
+                    let name = declared_names(&m.kind)
+                        .last()
+                        .copied()
+                        .or_else(|| crate::outline::effective_name_of(m));
+                    body_of(&m.kind).map(|b| {
+                        let mut declared = declared_in(b, partial);
+                        // A connection's named ends are its features too.
+                        if let MemberKind::Usage(u) = &m.kind {
+                            declared.extend(end_names(&u.detail));
+                            declared.sort_unstable();
+                            declared.dedup();
+                        }
+                        Scope {
+                            members: b,
+                            package: matches!(m.kind, MemberKind::Package(_)),
+                            path: match name {
+                                Some(n) if cur.path.is_empty() => n.value.clone(),
+                                Some(n) => format!("{}::{}", cur.path, n.value),
+                                None => cur.path.clone(),
+                            },
+                            declared,
+                        }
                     })
                 } else {
                     None
@@ -67,53 +248,341 @@ impl<'a> AutoImport<'a> {
             dialect: unit.dialect,
             scopes,
             partial,
+            targets: HashMap::new(),
+            tables: None,
+            rooted: std::cell::RefCell::default(),
+            inherited: std::cell::OnceCell::new(),
         }
     }
 
-    /// The import edit that makes `name` (fully `qualified` from the
-    /// root) resolve at the cursor: `None` when the name is already
-    /// visible — declared on the scope chain or admitted by an
-    /// existing import — otherwise the byte offset and text of the
-    /// statement to insert.
-    pub fn import_edit(&self, name: &str, qualified: &str) -> Option<(u32, String)> {
-        let parent = qualified
+    /// Let existing imports admit what they bring in as the symbol
+    /// tables know it — what an imported namespace re-exports too — and
+    /// let the tables choose the path an inserted import names.
+    pub fn with_reexports(mut self, tables: &'a dyn Reexports) -> Self {
+        self.tables = Some(tables);
+        for scope in &self.scopes {
+            for m in scope.members {
+                let MemberKind::Import(imp) = &m.kind else {
+                    continue;
+                };
+                let target: Vec<String> = imp
+                    .target
+                    .segments
+                    .iter()
+                    .map(|s| s.value.clone())
+                    .collect();
+                if let Some(path) = tables.namespace(&scope.path, &target, imp.target.is_global) {
+                    self.targets.insert(m.span.start, path);
+                }
+            }
+        }
+        self
+    }
+
+    /// What `name` (fully `qualified` from the root) needs to resolve to
+    /// that symbol at the cursor: nothing when the name finds it already
+    /// ([`Self::finds`]); an import when the name finds nothing, or two
+    /// elements where nothing nearer the cursor than the import can go
+    /// decides it — the import goes into the nearest enclosing package,
+    /// where an import of the one member is found ahead of what
+    /// namespace imports beside it bring in; a qualifier otherwise: an
+    /// import of this symbol would take the name from every reference
+    /// in that package that finds the other element by it now. The
+    /// import names the symbol tables' choice of path when known — a
+    /// re-exporting package's path can be the conventional one — else
+    /// `qualified`.
+    pub fn needs(&self, name: &str, qualified: &str) -> Needs {
+        let Some(parent) = qualified
             .strip_suffix(name)
-            .and_then(|p| p.strip_suffix("::"))?;
-        if self.visible(name, parent, qualified) {
-            return None;
+            .and_then(|p| p.strip_suffix("::"))
+        else {
+            return Needs::Nothing;
+        };
+        let at = self
+            .scopes
+            .iter()
+            .rposition(|s| s.package)
+            .expect("the unit root is always a package scope");
+        match self.finds(name, parent, qualified, Admit::Any) {
+            Found::It => Needs::Nothing,
+            Found::Other { scope, fixed, .. } if scope > at || (scope == at && fixed) => {
+                Needs::Qualifier
+            }
+            // The one element the name finds keeps it; a name two
+            // elements make ambiguous finds nothing yet, so an import
+            // only settles it.
+            Found::Other { several: false, .. } => Needs::Qualifier,
+            Found::Nowhere | Found::Other { .. } => {
+                let route = self
+                    .tables
+                    .and_then(|tables| tables.import_route(name, qualified));
+                let path = route.as_deref().unwrap_or(qualified);
+                // An import resolves its path from where it sits: a first
+                // segment a name there takes from the top-level element is
+                // written from the global scope.
+                let first = path.split("::").next().unwrap_or(path);
+                let known = self.rooted.borrow().get(first).copied();
+                let global = known.unwrap_or_else(|| {
+                    let taken = matches!(
+                        self.finds_from(at, first, "", first, Admit::Any),
+                        Found::Other { .. }
+                    );
+                    self.rooted.borrow_mut().insert(first.to_string(), taken);
+                    taken
+                });
+                let (at, text) = self.insertion(path, global);
+                Needs::Import(ImportEdit {
+                    at,
+                    text,
+                    route,
+                    global,
+                })
+            }
         }
-        Some(self.insertion(qualified))
     }
 
-    /// Is `name` provably visible at the cursor? Declarations exactly
-    /// at the partial word are the phantom the half-typed statement
-    /// itself introduces and do not count.
-    fn visible(&self, name: &str, parent: &str, qualified: &str) -> bool {
-        for scope in &self.scopes {
-            for m in scope.members {
-                if declared_names(&m.kind)
-                    .iter()
-                    .any(|n| n.value == name && !overlaps(n.span, self.partial))
-                {
-                    return true;
+    /// Is the cursor inside the namespace at the qualified path `ns` —
+    /// in its body, or in one nested in it?
+    pub fn inside(&self, ns: &str) -> bool {
+        self.scopes.iter().any(|scope| {
+            scope
+                .path
+                .strip_prefix(ns)
+                .is_some_and(|rest| rest.is_empty() || rest.starts_with("::"))
+        })
+    }
+
+    /// Can `name`, fully `qualified`, which its namespace holds private
+    /// or protected, be named bare at the cursor? Inside the namespace
+    /// it can; elsewhere only through an `import all`, of its namespace
+    /// or of one that brings it in so, as no other import brings in a
+    /// member that is not public.
+    pub fn sees_hidden(&self, name: &str, qualified: &str) -> bool {
+        let Some(parent) = qualified
+            .strip_suffix(name)
+            .and_then(|p| p.strip_suffix("::"))
+        else {
+            return true;
+        };
+        matches!(self.finds(name, parent, qualified, Admit::All), Found::It)
+    }
+
+    /// Can `name`, fully `qualified`, which an ancestor's visibility
+    /// keeps inside a namespace the cursor is outside of, be named bare
+    /// here? Only through an import the symbol tables follow to a
+    /// namespace that brings it in: its own path does not resolve here.
+    pub fn sees_enclosed(&self, name: &str, qualified: &str) -> bool {
+        let Some(parent) = qualified
+            .strip_suffix(name)
+            .and_then(|p| p.strip_suffix("::"))
+        else {
+            return true;
+        };
+        matches!(
+            self.finds(name, parent, qualified, Admit::Resolved),
+            Found::It
+        )
+    }
+
+    /// Does `name` at the cursor find the element at `qualified`? The
+    /// scope chain is read innermost first, and the first scope where
+    /// the name is found decides: one declaring it (the phantom the
+    /// half-typed statement introduces aside), else one whose imports
+    /// bring it in, taken together ([`Self::imported`]) — the element
+    /// found must be the one at `qualified`, and a name they bring in
+    /// for different elements is ambiguous, finding neither. `admit`
+    /// tells which imports are taken at their word.
+    fn finds(&self, name: &str, parent: &str, qualified: &str, admit: Admit) -> Found {
+        self.finds_from(self.scopes.len() - 1, name, parent, qualified, admit)
+    }
+
+    /// [`Self::finds`], for `name` written in the scope at index `from`
+    /// of the chain.
+    fn finds_from(
+        &self,
+        from: usize,
+        name: &str,
+        parent: &str,
+        qualified: &str,
+        admit: Admit,
+    ) -> Found {
+        for (i, scope) in self.scopes[..=from].iter().enumerate().rev() {
+            let (found, fixed) = if scope.declared.binary_search(&name).is_ok() {
+                // The member the scope declares: the symbol, if its path
+                // is the scope's and the name's.
+                let own = if scope.path.is_empty() {
+                    parent.is_empty()
+                } else {
+                    parent == scope.path
+                };
+                let declared = if scope.path.is_empty() {
+                    name.to_string()
+                } else {
+                    format!("{}::{name}", scope.path)
+                };
+                (
+                    if own {
+                        Brought::It
+                    } else {
+                        Brought::other(&declared)
+                    },
+                    true,
+                )
+            } else {
+                self.imported(scope, name, parent, qualified, admit)
+            };
+            match found {
+                Brought::Nothing => {}
+                Brought::It => return Found::It,
+                Brought::Else(_) | Brought::Several => {
+                    return Found::Other {
+                        scope: i,
+                        fixed,
+                        several: found == Brought::Several,
+                    };
                 }
-                if let MemberKind::Import(imp) = &m.kind {
-                    if import_admits(imp, name, parent, qualified) {
-                        return true;
+            }
+        }
+        Found::Nowhere
+    }
+
+    /// What the imports of `scope` bring in under `name`, and whether
+    /// imports naming one member (`import T::m;`, and the `T` of
+    /// `import T::**;`) did: those come ahead of imports naming a
+    /// namespace's members, whose names they hide. The symbol tables
+    /// tell what an import whose target they resolve brings in; any
+    /// other admits a name its target spells the symbol at `qualified`
+    /// with, as a guess, where `admit` allows it. A filtered import — a
+    /// `[…]` condition of its own, or a `filter` member beside it —
+    /// admits no re-export, only its target's own members: its
+    /// condition is not known here.
+    fn imported(
+        &self,
+        scope: &Scope<'_>,
+        name: &str,
+        parent: &str,
+        qualified: &str,
+        admit: Admit,
+    ) -> (Brought, bool) {
+        let conditioned = scope
+            .members
+            .iter()
+            .any(|m| matches!(m.kind, MemberKind::Filter(_)));
+        let (mut one, mut members) = (Brought::Nothing, Brought::Nothing);
+        for m in scope.members {
+            let MemberKind::Import(imp) = &m.kind else {
+                continue;
+            };
+            // Read off the target's spelling only when asked.
+            let admits = || {
+                let taken = match admit {
+                    Admit::Any => true,
+                    Admit::All => imp.is_import_all,
+                    Admit::Resolved => false,
+                };
+                taken && import_admits(imp, name, parent, qualified)
+            };
+            let target = self.targets.get(&m.span.start).zip(self.tables);
+            let filtered = !imp.filters.is_empty() || conditioned;
+            if !imp.is_namespace && imp.target.segments.last().is_some_and(|s| s.value == name) {
+                one.add(match target {
+                    Some((path, _)) if path != qualified => Brought::other(path),
+                    // A plain import of the one member brings in no
+                    // private or protected member.
+                    Some(_) if admit != Admit::All || imp.is_import_all => Brought::It,
+                    None if admits() => Brought::It,
+                    _ => Brought::Nothing,
+                });
+            }
+            if imp.is_namespace || imp.is_recursive {
+                members.add(match target {
+                    Some((ns, tables)) if !filtered => {
+                        tables.brought(ns, name, qualified, imp.is_recursive, imp.is_import_all)
                     }
-                }
+                    _ if admits() => Brought::It,
+                    _ => Brought::Nothing,
+                });
             }
         }
-        false
+        if one != Brought::Nothing {
+            return (one, true);
+        }
+        // An element's own scope finds what it inherits next, ahead of
+        // what namespace imports bring in.
+        let inherited = match self.tables {
+            Some(tables) if !scope.package && !scope.path.is_empty() => {
+                tables.inherits(&scope.path, name, qualified)
+            }
+            _ => Brought::Nothing,
+        };
+        if inherited != Brought::Nothing {
+            (inherited, true)
+        } else {
+            (members, false)
+        }
+    }
+
+    /// Might `name`, of the symbol at `qualified`, a member of the type
+    /// or usage at `owner`, find it at the cursor at all — declared in a
+    /// scope around the cursor, inherited by one, or brought in by an
+    /// import in one naming its owner, the member itself, or everything
+    /// below a namespace holding it, or by one of a namespace whose
+    /// imports bring it in, as the symbol tables follow them? A cheap
+    /// test ahead of [`Self::needs`], which tells.
+    pub fn may_find(&self, name: &str, qualified: &str, owner: &str) -> bool {
+        if self.scopes.iter().any(|scope| scope.path == owner) {
+            return true;
+        }
+        let below = |ns: &str| {
+            owner
+                .strip_prefix(ns)
+                .is_some_and(|rest| rest.is_empty() || rest.starts_with("::"))
+        };
+        let imported = self.scopes.iter().flat_map(|scope| scope.members).any(|m| {
+            let (MemberKind::Import(imp), Some(target)) =
+                (&m.kind, self.targets.get(&m.span.start))
+            else {
+                return false;
+            };
+            // What the target's imports bring in — through a package
+            // re-exporting the member — or, recursively, what the
+            // elements below it inherit.
+            let brings = || {
+                self.tables.is_some_and(|tables| {
+                    tables.brought(target, name, qualified, imp.is_recursive, imp.is_import_all)
+                        == Brought::It
+                })
+            };
+            (imp.is_recursive && below(target))
+                || (imp.is_namespace && owner == target)
+                || (!imp.is_namespace && qualified == target)
+                || ((imp.is_namespace || imp.is_recursive) && brings())
+        });
+        imported
+            || self
+                .inherited
+                .get_or_init(|| {
+                    let Some(tables) = self.tables else {
+                        return std::collections::HashSet::new();
+                    };
+                    self.scopes
+                        .iter()
+                        .filter(|scope| !scope.package && !scope.path.is_empty())
+                        .flat_map(|scope| tables.inherited_paths(&scope.path))
+                        .collect()
+                })
+                .contains(qualified)
     }
 
     /// Where and what to insert: after the last import of the nearest
     /// enclosing package body (or the unit root), matching its
     /// indentation and visibility spelling; with no imports yet,
     /// before the first substantive member as a `private import` (the
-    /// non-re-exporting default).
-    fn insertion(&self, qualified: &str) -> (u32, String) {
+    /// non-re-exporting default). `global` writes the path from the
+    /// global scope.
+    fn insertion(&self, qualified: &str, global: bool) -> (u32, String) {
         let path = escape_qualified(self.dialect, qualified);
+        let path = if global { format!("$::{path}") } else { path };
         let scope = self
             .scopes
             .iter()
@@ -225,6 +694,40 @@ pub(crate) fn within_import(members: &[Member], offset: u32) -> bool {
     })
 }
 
+/// The names `members` declare — by name, short name, or the name a
+/// usage without one is found by — but where one overlaps `partial`, the
+/// phantom the half-typed statement introduces.
+fn declared_in(members: &[Member], partial: Span) -> Vec<&str> {
+    let mut out = Vec::new();
+    for m in members {
+        let names = declared_names(&m.kind)
+            .into_iter()
+            .chain(crate::outline::effective_name_of(m));
+        for n in names.filter(|n| !overlaps(n.span, partial)) {
+            out.push(n.value.as_str());
+        }
+    }
+    out.sort_unstable();
+    out.dedup();
+    out
+}
+
+/// The names of the ends a connection declares as it connects them
+/// (`connect lugNut ::> wheel.lugNut to shank ::> hub.shank`).
+fn end_names(detail: &sysmlv2_parser::ast::UsageDetail) -> Vec<&str> {
+    use sysmlv2_parser::ast::UsageDetail as D;
+    let ends: Vec<&sysmlv2_parser::ast::ConnectorEnd> = match detail {
+        D::Connector { ends } | D::Binding { ends } => ends.iter().collect(),
+        D::Succession { source, target } => {
+            source.as_deref().into_iter().chain([&**target]).collect()
+        }
+        _ => Vec::new(),
+    };
+    ends.into_iter()
+        .filter_map(|e| e.name.as_ref().map(|n| n.value.as_str()))
+        .collect()
+}
+
 /// The names a member declares in its owning scope.
 fn declared_names(kind: &MemberKind) -> Vec<&Name> {
     let id = match kind {
@@ -283,27 +786,6 @@ pub(crate) fn escape_qualified(dialect: Dialect, qualified: &str) -> String {
     sysmlv2_parser::name::spell_path(Some(dialect), qualified.split("::"))
 }
 
-/// The byte range a completion for `name` should replace. The partial
-/// word is the trailing identifier run, but a restricted name like
-/// `m/s²` spans word-breaking characters — a typed `m/s` must be
-/// replaced whole, so the range extends backward over characters that
-/// belong to the candidate's own spelling (self-limiting: `3*m` stops
-/// at the `*` no unit name contains). A typed opening quote joins the
-/// range so accepting `'m/s²'` never doubles it.
-pub(crate) fn replace_range_for(text: &str, partial_start: u32, offset: u32, name: &str) -> Span {
-    let mut start = partial_start as usize;
-    while let Some(prev) = text[..start].chars().next_back() {
-        if prev.is_whitespace() || prev == '\'' || !name.contains(prev) {
-            break;
-        }
-        start -= prev.len_utf8();
-    }
-    if text[..start].ends_with('\'') {
-        start -= 1;
-    }
-    Span::new(offset32(start), offset)
-}
-
 #[cfg(test)]
 mod tests {
     use super::{AutoImport, offset32};
@@ -324,7 +806,10 @@ mod tests {
             offset32(at),
             Span::new(offset32(word_start), offset32(at)),
         );
-        auto.import_edit(name, qualified)
+        match auto.needs(name, qualified) {
+            super::Needs::Import(e) => Some((e.at, e.text)),
+            super::Needs::Nothing | super::Needs::Qualifier => None,
+        }
     }
 
     #[test]
diff --git a/crates/sysmlv2-lsp/src/kinds.rs b/crates/sysmlv2-lsp/src/kinds.rs
new file mode 100644
index 0000000..ca6821c
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/kinds.rs
@@ -0,0 +1,1162 @@
+//! What a completion candidate names, and which kinds of element a
+//! position takes.
+//!
+//! Every symbol completion offers carries a [`Decl`]: whether its
+//! declaration is a namespace, a definition (a SysML `… def` or a KerML
+//! type) of some kind, or a usage (a SysML usage or a KerML feature) of
+//! some kind — read off the syntax tree like the outline, so it costs no
+//! model build. Positions admit and rank candidates by it, following the
+//! metamodel: an attribute is typed by data types (attribute and
+//! enumeration definitions among them), a part by part definitions, a
+//! definition specializes definitions of its own kind or of the kinds
+//! its kind specializes, and a usage of a kind is one of every kind its
+//! kind specializes too (a part usage is an item usage).
+
+use crate::position::Mapper;
+use std::collections::{HashMap, HashSet};
+use sysmlv2_parser::ast::{
+    DefKind, FeatureSpecialization, Identification, Member, MemberKind, QualifiedName, SourceUnit,
+    TargetRef, Usage, UsageKind,
+};
+use sysmlv2_parser::span::Span;
+
+/// What a symbol's declaration is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Decl {
+    /// A package or namespace.
+    Namespace,
+    /// A definition or KerML type, by its kind keyword.
+    Definition(DefKind),
+    /// A usage or KerML feature, by its kind keyword; one declared
+    /// without a kind keyword (`x : T;`) is [`UsageKind::Default`].
+    Usage(UsageKind),
+    /// Anything else the outline names: a dependency, an alias the
+    /// symbol tables cannot follow to what it names.
+    Other,
+}
+
+/// A declaration as completion reads it: what it declares, and the
+/// types it names.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Declared {
+    pub decl: Decl,
+    /// The names, last segment only, of the types a usage is typed by or
+    /// a definition specializes, as written.
+    pub types: Vec<String>,
+}
+
+impl Declared {
+    fn other() -> Declared {
+        Declared {
+            decl: Decl::Other,
+            types: Vec::new(),
+        }
+    }
+}
+
+/// Every named member of `unit` as [`Declared`], keyed by the position
+/// the outline selects for it (its name, else its short name). An alias
+/// declares nothing of its own: the symbol table it is indexed in takes
+/// it as what its target names.
+pub(crate) fn declarations(
+    unit: &SourceUnit,
+    mapper: &Mapper<'_>,
+) -> HashMap<lsp_types::Position, Declared> {
+    let mut out = HashMap::new();
+    collect(&unit.members, mapper, &mut out);
+    out
+}
+
+/// The member's identification, declaration, and body, when it declares
+/// something.
+fn declared(m: &Member) -> Option<(&Identification, Declared, Option<&[Member]>)> {
+    let names = |targets: &mut dyn Iterator<Item = &TargetRef>| -> Vec<String> {
+        targets
+            .filter_map(|t| match t {
+                TargetRef::Name(qn) => qn.segments.last().map(|s| s.value.clone()),
+                _ => None,
+            })
+            .collect()
+    };
+    match &m.kind {
+        MemberKind::Package(p) => Some((
+            &p.id,
+            Declared {
+                decl: Decl::Namespace,
+                types: Vec::new(),
+            },
+            p.body.as_deref(),
+        )),
+        MemberKind::Definition(d) => Some((
+            &d.id,
+            Declared {
+                decl: Decl::Definition(d.kind),
+                types: names(&mut d.specializes.iter()),
+            },
+            d.body.as_deref(),
+        )),
+        MemberKind::Dependency(d) => Some((&d.id, Declared::other(), None)),
+        _ => {
+            let u = usage(m)?;
+            let mut typings = u.declaration.specializations.iter().flat_map(|s| match s {
+                FeatureSpecialization::TypedBy(types) => types.iter().map(|t| &t.target).collect(),
+                _ => Vec::new(),
+            });
+            Some((
+                &u.declaration.id,
+                Declared {
+                    decl: Decl::Usage(u.kind),
+                    types: names(&mut typings),
+                },
+                u.body.as_deref(),
+            ))
+        }
+    }
+}
+
+/// The usage member `m` declares, whatever membership owns it.
+pub(crate) fn usage(m: &Member) -> Option<&Usage> {
+    match &m.kind {
+        MemberKind::Usage(u)
+        | MemberKind::Subject(u)
+        | MemberKind::Actor(u)
+        | MemberKind::Stakeholder(u)
+        | MemberKind::Objective(u)
+        | MemberKind::FramedConcern(u)
+        | MemberKind::RequirementVerification(u)
+        | MemberKind::Render(u)
+        | MemberKind::Return(u)
+        | MemberKind::RequirementConstraint { usage: u, .. }
+        | MemberKind::StateSubaction {
+            action: Some(u), ..
+        } => Some(u),
+        _ => None,
+    }
+}
+
+/// A declaration whose body holds an offset, as the live text writes it
+/// (see [`enclosing`]).
+pub(crate) struct Enclosing {
+    /// Its name, else its short name, else the name of the feature it
+    /// redefines; `None` for an anonymous one (`@Safety { … }`, `part :
+    /// Wheel { … }`).
+    pub name: Option<String>,
+    /// The types it names, qualified as written: a usage's typings, a
+    /// definition's specializations.
+    pub types: Vec<QualifiedName>,
+    /// What it declares.
+    pub decl: Decl,
+    /// The whole member, its body included.
+    pub span: Span,
+}
+
+/// The declarations of `unit` whose bodies hold byte offset `at`,
+/// outermost first — those in an expression's body too (`forAll { …
+/// attribute t : T { … } … }`) — and the innermost's body, the unit's
+/// members when none holds it. The named ones spell the innermost's
+/// qualified name, which finds it in a model built from an earlier text
+/// as well.
+pub(crate) fn enclosing(unit: &SourceUnit, at: u32) -> (Vec<Enclosing>, &[Member]) {
+    let mut out = Vec::new();
+    let mut members: &[Member] = &unit.members;
+    while let Some((m, id, declared, body)) = declaration_around(members, at) {
+        out.push(Enclosing {
+            name: id
+                .name
+                .as_ref()
+                .or(id.short_name.as_ref())
+                .map(|n| n.value.clone())
+                .or_else(|| redefined_name(m)),
+            types: written_types(m),
+            decl: declared.decl,
+            span: m.span,
+        });
+        members = body;
+    }
+    (out, members)
+}
+
+/// The member of `members` holding byte offset `at` when it declares
+/// something with a body, else the declaration with a body holding it
+/// in that member's expression body (a constraint's `forAll { … }`, a
+/// select's `?{ … }`): with its identification, what it declares, and
+/// its body.
+fn declaration_around(
+    members: &[Member],
+    at: u32,
+) -> Option<(&Member, &Identification, Declared, &[Member])> {
+    let m = members
+        .iter()
+        .find(|m| m.span.start < at && at < m.span.end)?;
+    match declared(m) {
+        Some((id, declared, Some(body))) => Some((m, id, declared, body)),
+        _ => declaration_around(expression_body(m, at)?, at),
+    }
+}
+
+/// The members of the expression body in `m` holding byte offset `at`.
+fn expression_body(m: &Member, at: u32) -> Option<&[Member]> {
+    use sysmlv2_parser::ast::{Expr, ExprKind};
+    use sysmlv2_parser::visit::{Visit, walk_expr};
+    struct Find<'a> {
+        at: u32,
+        found: Option<&'a [Member]>,
+    }
+    impl<'a> Visit<'a> for Find<'a> {
+        fn visit_expr(&mut self, e: &'a Expr) {
+            if self.found.is_some() || !(e.span.start < self.at && self.at < e.span.end) {
+                return;
+            }
+            if let ExprKind::Body { members } = &e.kind {
+                self.found = Some(members);
+            } else {
+                walk_expr(self, e);
+            }
+        }
+    }
+    let mut find = Find { at, found: None };
+    find.visit_member(m);
+    find.found
+}
+
+/// The members of `body` other than the statement being typed, which
+/// starts at byte offset `at`.
+fn settled(body: &[Member], at: u32) -> impl Iterator<Item = &Member> {
+    body.iter()
+        .filter(move |m| !(m.span.start <= at && at < m.span.end.max(m.span.start + 1)))
+}
+
+/// The features `body` declares, but for the statement being typed at
+/// `at`: each with the name it is found by — a redefinition declaring
+/// none by the feature it redefines — and what it declares.
+pub(crate) fn body_features(body: &[Member], at: u32) -> Vec<(String, Decl)> {
+    settled(body, at)
+        .filter_map(|m| {
+            let (id, declared, _) = declared(m)?;
+            if !matches!(declared.decl, Decl::Usage(_)) {
+                return None;
+            }
+            let name = id
+                .name
+                .as_ref()
+                .or(id.short_name.as_ref())
+                .map(|n| n.value.clone())
+                .or_else(|| redefined_name(m))?;
+            Some((name, declared.decl))
+        })
+        .collect()
+}
+
+/// The names of the features the members of `body` redefine, but for
+/// the statement being typed at `at`, last segment only — and those
+/// they redefine without naming them: a `subject` the library's `subj`
+/// every case and requirement has, a `return` parameter the `result`
+/// every calculation has.
+pub(crate) fn redefined_names(body: &[Member], at: u32) -> HashSet<String> {
+    let mut names: HashSet<String> = settled(body, at)
+        .filter_map(usage)
+        .flat_map(|u| &u.declaration.specializations)
+        .filter_map(|s| match s {
+            FeatureSpecialization::Redefines(targets) => Some(targets),
+            _ => None,
+        })
+        .flatten()
+        .filter_map(|t| match t {
+            TargetRef::Name(qn) => qn.segments.last().map(|s| s.value.clone()),
+            _ => None,
+        })
+        .collect();
+    for m in settled(body, at) {
+        match m.kind {
+            MemberKind::Subject(_) => names.insert("subj".to_string()),
+            MemberKind::Return(_) => names.insert("result".to_string()),
+            _ => false,
+        };
+    }
+    names
+}
+
+/// The name a usage declaring none takes from the first feature it
+/// redefines (`part :>> engine { … }` is named `engine`), as the model
+/// names it.
+fn redefined_name(m: &Member) -> Option<String> {
+    let redefined = usage(m)?
+        .declaration
+        .specializations
+        .iter()
+        .find_map(|s| match s {
+            FeatureSpecialization::Redefines(targets) => targets.first(),
+            _ => None,
+        })?;
+    match redefined {
+        TargetRef::Name(qn) => qn.segments.last().map(|s| s.value.clone()),
+        _ => None,
+    }
+}
+
+/// The types member `m` names, qualified as written: a usage's typings,
+/// a definition's specializations.
+fn written_types(m: &Member) -> Vec<QualifiedName> {
+    let name = |t: &TargetRef| match t {
+        TargetRef::Name(qn) => Some(qn.clone()),
+        _ => None,
+    };
+    if let MemberKind::Definition(d) = &m.kind {
+        return d.specializes.iter().filter_map(name).collect();
+    }
+    usage(m).map_or_else(Vec::new, |u| {
+        u.declaration
+            .specializations
+            .iter()
+            .flat_map(|s| match s {
+                FeatureSpecialization::TypedBy(types) => {
+                    types.iter().filter_map(|t| name(&t.target)).collect()
+                }
+                _ => Vec::new(),
+            })
+            .collect()
+    })
+}
+
+fn collect(
+    members: &[Member],
+    mapper: &Mapper<'_>,
+    out: &mut HashMap<lsp_types::Position, Declared>,
+) {
+    for m in members {
+        let Some((id, declared, body)) = declared(m) else {
+            continue;
+        };
+        out.insert(mapper.position(selection(id, m.span).start), declared);
+        if let Some(body) = body {
+            collect(body, mapper, out);
+        }
+    }
+}
+
+/// The measurement-unit types among `definitions` — (name, the names it
+/// specializes) pairs: the standard library's measurement-unit type,
+/// given by its `root` name, and every definition specializing one of
+/// them, transitively, following the specializations the declarations
+/// write. `known` holds unit types already established (the library's,
+/// when extending them with a workspace's definitions).
+pub(crate) fn unit_types<'a>(
+    root: Option<&str>,
+    known: &HashSet<String>,
+    definitions: impl IntoIterator<Item = (&'a str, &'a [String])>,
+) -> HashSet<String> {
+    let definitions: Vec<(&str, &[String])> = definitions.into_iter().collect();
+    let mut units: HashSet<String> = known.clone();
+    units.extend(root.map(str::to_string));
+    loop {
+        let before = units.len();
+        for &(name, supers) in &definitions {
+            if !units.contains(name) && supers.iter().any(|s| units.contains(s)) {
+                units.insert(name.to_string());
+            }
+        }
+        if units.len() == before {
+            return units;
+        }
+    }
+}
+
+/// The span the outline selects for a declaration: its name, else its
+/// short name, else the empty span at the member's start.
+fn selection(id: &Identification, member: Span) -> Span {
+    id.name
+        .as_ref()
+        .or(id.short_name.as_ref())
+        .map(|n| n.span)
+        .unwrap_or_else(|| Span::new(member.start, member.start))
+}
+
+/// The declaration kind of a feature from its abstract-syntax metaclass
+/// name (`AttributeUsage`, `ActionUsage`, `Feature`), for features a
+/// semantic session reports rather than the syntax tree.
+pub(crate) fn feature_decl(metaclass: &str) -> Decl {
+    use UsageKind as U;
+    let kind = match metaclass {
+        "AttributeUsage" => U::Attribute,
+        "EnumerationUsage" => U::Enum,
+        "OccurrenceUsage" => U::Occurrence,
+        "EventOccurrenceUsage" => U::Event,
+        "ItemUsage" => U::Item,
+        "MetadataUsage" | "MetadataFeature" => U::Metadata,
+        "PartUsage" => U::Part,
+        "PortUsage" => U::Port,
+        "ConnectionUsage" => U::Connection,
+        "InterfaceUsage" => U::Interface,
+        "AllocationUsage" => U::Allocation,
+        "FlowUsage" | "Flow" => U::Flow,
+        "SuccessionFlowUsage" | "SuccessionFlow" => U::SuccessionFlow,
+        "ActionUsage" => U::Action,
+        "PerformActionUsage" => U::Perform,
+        "StateUsage" => U::State,
+        "ExhibitStateUsage" => U::Exhibit,
+        "TransitionUsage" => U::Transition,
+        "CalculationUsage" => U::Calc,
+        "ConstraintUsage" => U::Constraint,
+        "AssertConstraintUsage" => U::AssertConstraint,
+        "RequirementUsage" => U::Requirement,
+        "SatisfyRequirementUsage" => U::Satisfy,
+        "ConcernUsage" => U::Concern,
+        "CaseUsage" => U::Case,
+        "AnalysisCaseUsage" => U::Analysis,
+        "VerificationCaseUsage" => U::Verification,
+        "UseCaseUsage" => U::UseCase,
+        "IncludeUseCaseUsage" => U::Include,
+        "ViewUsage" => U::View,
+        "ViewpointUsage" => U::Viewpoint,
+        "RenderingUsage" => U::Rendering,
+        "ReferenceUsage" => U::Ref,
+        "SuccessionAsUsage" | "Succession" => U::Succession,
+        "BindingConnectorAsUsage" | "BindingConnector" => U::Binding,
+        "AcceptActionUsage" => U::Accept,
+        "SendActionUsage" => U::Send,
+        "AssignmentActionUsage" => U::Assign,
+        "TerminateActionUsage" => U::Terminate,
+        "IfActionUsage" => U::IfNode,
+        "WhileLoopActionUsage" => U::WhileLoop,
+        "ForLoopActionUsage" => U::ForLoop,
+        "MergeNode" => U::Merge,
+        "DecisionNode" => U::Decide,
+        "JoinNode" => U::Join,
+        "ForkNode" => U::Fork,
+        "Step" => U::Step,
+        "Expression" => U::Expr,
+        "BooleanExpression" => U::BoolExpr,
+        "Invariant" => U::Invariant,
+        "Connector" => U::Connector,
+        "Feature" => U::Feature,
+        _ => return Decl::Other,
+    };
+    Decl::Usage(kind)
+}
+
+/// Every definition kind: what a reference usage, a KerML feature, or a
+/// parameter declared without a kind keyword may be typed by.
+pub(crate) const ALL_DEFINITIONS: &[DefKind] = &[
+    DefKind::Attribute,
+    DefKind::Enum,
+    DefKind::Occurrence,
+    DefKind::Individual,
+    DefKind::Item,
+    DefKind::Metadata,
+    DefKind::Part,
+    DefKind::Port,
+    DefKind::Connection,
+    DefKind::Interface,
+    DefKind::Allocation,
+    DefKind::Flow,
+    DefKind::Action,
+    DefKind::State,
+    DefKind::Calc,
+    DefKind::Constraint,
+    DefKind::Requirement,
+    DefKind::Concern,
+    DefKind::Case,
+    DefKind::Analysis,
+    DefKind::Verification,
+    DefKind::UseCase,
+    DefKind::View,
+    DefKind::Viewpoint,
+    DefKind::Rendering,
+    DefKind::Extended,
+    DefKind::Type,
+    DefKind::Classifier,
+    DefKind::Class,
+    DefKind::Struct,
+    DefKind::DataType,
+    DefKind::Assoc,
+    DefKind::AssocStruct,
+    DefKind::Behavior,
+    DefKind::Interaction,
+    DefKind::Function,
+    DefKind::Predicate,
+    DefKind::Metaclass,
+];
+
+/// The definitions that may be invoked in an expression
+/// (`KineticEnergy(m, v)`, `sqrt(2.0)`): calculations and functions,
+/// constraints and predicates, and the cases, which are calculations.
+pub(crate) const CALLABLES: &[DefKind] = &[
+    DefKind::Calc,
+    DefKind::Function,
+    DefKind::Constraint,
+    DefKind::Predicate,
+    DefKind::Case,
+    DefKind::Analysis,
+    DefKind::Verification,
+    DefKind::UseCase,
+];
+
+/// The definitions a usage of `kind` may be typed by: the metamodel's
+/// typing rule for the kind (an attribute usage's definitions are data
+/// types, a part usage's part definitions, an item usage's structures,
+/// an action or a state usage's behaviors, a calculation usage's
+/// functions, …), split into the kinds that fit best and the other kinds
+/// the rule admits. A part usage also takes the other structures, after
+/// the part definitions, and a connection usage plain associations,
+/// which the library types connections by. A reference usage, a KerML
+/// feature, and a usage declared without a kind keyword take any type.
+pub(crate) fn typed_by(kind: UsageKind) -> (&'static [DefKind], &'static [DefKind]) {
+    use DefKind as D;
+    use UsageKind as U;
+    match kind {
+        U::Attribute => (&[D::Attribute, D::Enum, D::DataType], &[]),
+        U::Enum => (&[D::Enum], &[]),
+        U::Occurrence | U::Event => (
+            &[D::Occurrence, D::Individual],
+            &[
+                D::Item,
+                D::Part,
+                D::Port,
+                D::Connection,
+                D::Interface,
+                D::Allocation,
+                D::Flow,
+                D::Action,
+                D::State,
+                D::Calc,
+                D::Constraint,
+                D::Requirement,
+                D::Concern,
+                D::Case,
+                D::Analysis,
+                D::Verification,
+                D::UseCase,
+                D::View,
+                D::Viewpoint,
+                D::Rendering,
+                D::Metadata,
+                D::Class,
+                D::Struct,
+                D::Behavior,
+                D::Function,
+                D::Predicate,
+                D::Interaction,
+                D::AssocStruct,
+                D::Metaclass,
+            ],
+        ),
+        U::Item => (
+            &[D::Item, D::Part],
+            &[
+                D::Port,
+                D::Connection,
+                D::Interface,
+                D::Allocation,
+                D::View,
+                D::Rendering,
+                D::Metadata,
+                D::Struct,
+                D::AssocStruct,
+                D::Metaclass,
+            ],
+        ),
+        U::Part => (
+            &[
+                D::Part,
+                D::Connection,
+                D::Interface,
+                D::Allocation,
+                D::View,
+                D::Rendering,
+            ],
+            &[
+                D::Item,
+                D::Port,
+                D::Metadata,
+                D::Struct,
+                D::AssocStruct,
+                D::Metaclass,
+            ],
+        ),
+        U::Port => (&[D::Port], &[]),
+        U::Connection => (
+            &[D::Connection, D::Interface, D::Allocation],
+            &[D::AssocStruct, D::Assoc],
+        ),
+        U::Interface => (&[D::Interface], &[]),
+        U::Allocation => (&[D::Allocation], &[]),
+        U::Flow | U::SuccessionFlow | U::Message => (&[D::Flow], &[D::Interaction]),
+        U::Action | U::Perform | U::Step => (
+            &[D::Action, D::Behavior],
+            &[
+                D::State,
+                D::Calc,
+                D::Case,
+                D::Analysis,
+                D::Verification,
+                D::UseCase,
+                D::Flow,
+                D::Constraint,
+                D::Requirement,
+                D::Concern,
+                D::Viewpoint,
+                D::Function,
+                D::Predicate,
+                D::Interaction,
+            ],
+        ),
+        U::State | U::Exhibit => (
+            &[D::State],
+            &[
+                D::Action,
+                D::Behavior,
+                D::Calc,
+                D::Case,
+                D::Analysis,
+                D::Verification,
+                D::UseCase,
+                D::Flow,
+                D::Constraint,
+                D::Requirement,
+                D::Concern,
+                D::Viewpoint,
+                D::Function,
+                D::Predicate,
+                D::Interaction,
+            ],
+        ),
+        U::Calc | U::Expr => (
+            &[D::Calc, D::Function],
+            &[
+                D::Case,
+                D::Analysis,
+                D::Verification,
+                D::UseCase,
+                D::Constraint,
+                D::Requirement,
+                D::Concern,
+                D::Viewpoint,
+                D::Predicate,
+            ],
+        ),
+        U::Constraint | U::AssertConstraint | U::BoolExpr | U::Invariant => (
+            &[D::Constraint, D::Predicate],
+            &[D::Requirement, D::Concern, D::Viewpoint],
+        ),
+        U::Requirement | U::Satisfy => (&[D::Requirement], &[D::Concern, D::Viewpoint]),
+        U::Concern => (&[D::Concern], &[]),
+        U::Case => (&[D::Case], &[D::Analysis, D::Verification, D::UseCase]),
+        U::Analysis => (&[D::Analysis], &[]),
+        U::Verification => (&[D::Verification], &[]),
+        U::UseCase | U::Include => (&[D::UseCase], &[]),
+        U::View => (&[D::View], &[]),
+        U::Viewpoint => (&[D::Viewpoint], &[]),
+        U::Rendering => (&[D::Rendering], &[]),
+        U::Metadata => (&[D::Metadata, D::Metaclass], &[]),
+        U::Connector => (
+            &[
+                D::Assoc,
+                D::AssocStruct,
+                D::Connection,
+                D::Interface,
+                D::Allocation,
+            ],
+            &[],
+        ),
+        _ => (ALL_DEFINITIONS, &[]),
+    }
+}
+
+/// Every kind of usage the syntax tells apart.
+const ALL_USAGES: &[UsageKind] = &[
+    UsageKind::Attribute,
+    UsageKind::Enum,
+    UsageKind::Occurrence,
+    UsageKind::Event,
+    UsageKind::Item,
+    UsageKind::Metadata,
+    UsageKind::Part,
+    UsageKind::Port,
+    UsageKind::Connection,
+    UsageKind::Interface,
+    UsageKind::Allocation,
+    UsageKind::Flow,
+    UsageKind::Message,
+    UsageKind::SuccessionFlow,
+    UsageKind::Action,
+    UsageKind::Perform,
+    UsageKind::State,
+    UsageKind::Exhibit,
+    UsageKind::Transition,
+    UsageKind::Calc,
+    UsageKind::Case,
+    UsageKind::Analysis,
+    UsageKind::Verification,
+    UsageKind::UseCase,
+    UsageKind::Include,
+    UsageKind::Constraint,
+    UsageKind::AssertConstraint,
+    UsageKind::Requirement,
+    UsageKind::Satisfy,
+    UsageKind::Concern,
+    UsageKind::Viewpoint,
+    UsageKind::View,
+    UsageKind::Rendering,
+    UsageKind::Accept,
+    UsageKind::Send,
+    UsageKind::Assign,
+    UsageKind::Terminate,
+    UsageKind::IfNode,
+    UsageKind::WhileLoop,
+    UsageKind::ForLoop,
+    UsageKind::Merge,
+    UsageKind::Decide,
+    UsageKind::Join,
+    UsageKind::Fork,
+    UsageKind::Ref,
+    UsageKind::Default,
+    UsageKind::Extended,
+    UsageKind::Succession,
+    UsageKind::Binding,
+    UsageKind::Feature,
+    UsageKind::Step,
+    UsageKind::Expr,
+    UsageKind::BoolExpr,
+    UsageKind::Invariant,
+    UsageKind::Connector,
+];
+
+/// The kinds of usage a usage of `kind` directly specializes in the
+/// metamodel (a part usage is an item usage, a state usage an action
+/// usage, a requirement usage a constraint usage, …); a message is a
+/// flow usage. A kind with none specializes a feature alone, which
+/// names no kind.
+fn usage_generals(kind: UsageKind) -> &'static [UsageKind] {
+    use UsageKind as U;
+    match kind {
+        U::Enum => &[U::Attribute],
+        U::Event | U::Item | U::Port => &[U::Occurrence],
+        U::Part | U::Metadata => &[U::Item],
+        U::Connection => &[U::Part, U::Connector],
+        U::Interface | U::Allocation => &[U::Connection],
+        U::View | U::Rendering => &[U::Part],
+        U::Flow => &[U::Action, U::Connector],
+        U::Message => &[U::Flow],
+        U::SuccessionFlow => &[U::Flow, U::Succession],
+        U::Action => &[U::Occurrence, U::Step],
+        U::Perform => &[U::Action, U::Event],
+        U::State
+        | U::Transition
+        | U::Accept
+        | U::Send
+        | U::Assign
+        | U::Terminate
+        | U::IfNode
+        | U::WhileLoop
+        | U::ForLoop
+        | U::Merge
+        | U::Decide
+        | U::Join
+        | U::Fork => &[U::Action],
+        U::Exhibit => &[U::State, U::Perform],
+        U::Calc => &[U::Action, U::Expr],
+        U::Case => &[U::Calc],
+        U::Analysis | U::Verification | U::UseCase => &[U::Case],
+        U::Include => &[U::UseCase, U::Perform],
+        U::Constraint => &[U::Occurrence, U::BoolExpr],
+        U::AssertConstraint => &[U::Constraint, U::Invariant],
+        U::Requirement => &[U::Constraint],
+        U::Satisfy => &[U::Requirement, U::AssertConstraint],
+        U::Concern | U::Viewpoint => &[U::Requirement],
+        U::Succession | U::Binding => &[U::Connector],
+        U::Expr => &[U::Step],
+        U::BoolExpr => &[U::Expr],
+        U::Invariant => &[U::BoolExpr],
+        U::Attribute
+        | U::Occurrence
+        | U::Ref
+        | U::Default
+        | U::Extended
+        | U::Feature
+        | U::Step
+        | U::Connector => &[],
+    }
+}
+
+/// The kinds of usage that are usages of `kind`: `kind`'s own — a
+/// message is a flow usage, and a flow usage may be declared as a
+/// message — and those of the kinds specializing it in the metamodel:
+/// an item usage may be a part usage, an action usage a state or a
+/// calculation usage.
+pub(crate) fn usages_of(kind: UsageKind) -> (Vec<UsageKind>, Vec<UsageKind>) {
+    let kind = if kind == UsageKind::Message {
+        UsageKind::Flow
+    } else {
+        kind
+    };
+    let own = |k: UsageKind| k == kind || (kind == UsageKind::Flow && k == UsageKind::Message);
+    let under = |k: UsageKind| {
+        let mut frontier = usage_generals(k).to_vec();
+        while let Some(g) = frontier.pop() {
+            if g == kind {
+                return true;
+            }
+            frontier.extend_from_slice(usage_generals(g));
+        }
+        false
+    };
+    ALL_USAGES
+        .iter()
+        .copied()
+        .filter(|&k| own(k) || under(k))
+        .partition(|&k| own(k))
+}
+
+/// The metaclasses a definition of `kind` directly specializes in the
+/// metamodel (a part definition is an item definition, a calculation
+/// definition an action definition and a KerML function, …).
+fn generals(kind: DefKind) -> &'static [DefKind] {
+    use DefKind as D;
+    match kind {
+        D::Attribute => &[D::DataType],
+        D::Enum => &[D::Attribute],
+        D::Occurrence => &[D::Class],
+        D::Individual => &[D::Occurrence],
+        D::Item => &[D::Occurrence, D::Struct],
+        D::Part => &[D::Item],
+        D::Port => &[D::Occurrence, D::Struct],
+        D::Connection => &[D::Part, D::AssocStruct],
+        D::Interface | D::Allocation => &[D::Connection],
+        D::Flow => &[D::Action, D::Interaction],
+        D::Action => &[D::Occurrence, D::Behavior],
+        D::State => &[D::Action],
+        D::Calc => &[D::Action, D::Function],
+        D::Constraint => &[D::Occurrence, D::Predicate],
+        D::Requirement => &[D::Constraint],
+        D::Concern | D::Viewpoint => &[D::Requirement],
+        D::Case => &[D::Calc],
+        D::Analysis | D::Verification | D::UseCase => &[D::Case],
+        D::View | D::Rendering => &[D::Part],
+        D::Metadata => &[D::Item, D::Metaclass],
+        D::Classifier => &[D::Type],
+        D::Class | D::DataType | D::Assoc => &[D::Classifier],
+        D::Struct | D::Behavior => &[D::Class],
+        D::AssocStruct => &[D::Assoc, D::Struct],
+        D::Interaction => &[D::Behavior, D::Assoc],
+        D::Function => &[D::Behavior],
+        D::Predicate => &[D::Function],
+        D::Metaclass => &[D::Struct],
+        D::Extended | D::Type => &[],
+    }
+}
+
+/// What a definition of `kind` may specialize: definitions of its own
+/// kind first, then those of the kinds its kind specializes, nearest
+/// first. A definition of a user-defined kind (`#Kind def`) or a KerML
+/// `type` may specialize any type, and an individual definition the
+/// occurrence definition it is an individual of, of whatever kind
+/// (`individual def Vehicle_1 :> Vehicle`).
+pub(crate) fn specializes(kind: DefKind) -> (Vec<DefKind>, Vec<DefKind>) {
+    if matches!(kind, DefKind::Extended | DefKind::Type) {
+        return (ALL_DEFINITIONS.to_vec(), Vec::new());
+    }
+    if kind == DefKind::Individual {
+        let occurrences = ALL_DEFINITIONS
+            .iter()
+            .copied()
+            .filter(|&k| k != kind && specializes(k).1.contains(&DefKind::Occurrence));
+        let above = specializes(DefKind::Occurrence).1;
+        return (
+            vec![kind],
+            [DefKind::Occurrence]
+                .into_iter()
+                .chain(occurrences)
+                .chain(above)
+                .collect(),
+        );
+    }
+    let mut compatible: Vec<DefKind> = Vec::new();
+    let mut frontier = vec![kind];
+    while let Some(k) = frontier.pop() {
+        for &g in generals(k) {
+            if g != kind && !compatible.contains(&g) {
+                compatible.push(g);
+                frontier.insert(0, g);
+            }
+        }
+    }
+    (vec![kind], compatible)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ALL_DEFINITIONS, Decl, declarations, specializes, typed_by, usages_of};
+    use crate::position::{Encoding, Mapper};
+    use sysmlv2_parser::ast::{DefKind, UsageKind};
+
+    /// The declaration recorded for the element named `name` in `text`.
+    fn declared_of(text: &str, name: &str, kerml: bool) -> Option<super::Declared> {
+        let parse = if kerml {
+            sysmlv2_parser::parser::parse_kerml_source(text)
+        } else {
+            sysmlv2_parser::parser::parse_source(text)
+        };
+        let mapper = Mapper::new(text, Encoding::Utf8);
+        let decls = declarations(&parse.unit, &mapper);
+        let at = (0..text.len())
+            .find(|&i| {
+                text[i..].starts_with(&format!(" {name}"))
+                    && !text[i + 1 + name.len()..].starts_with(|c: char| c.is_alphanumeric())
+            })
+            .expect("declared name")
+            + 1;
+        decls
+            .get(&mapper.position(crate::position::offset32(at)))
+            .cloned()
+    }
+
+    /// The kind recorded for the declaration named `name` in `text`.
+    fn decl_of(text: &str, name: &str, kerml: bool) -> Option<Decl> {
+        declared_of(text, name, kerml).map(|d| d.decl)
+    }
+
+    #[test]
+    fn declarations_record_their_kind() {
+        let text = "package P {\n    part def V {\n        attribute m : Real;\n        \
+                    port p : ~F;\n        x : T;\n    }\n    requirement def R {\n        \
+                    subject s : V;\n    }\n}\n";
+        for (name, decl) in [
+            ("P", Decl::Namespace),
+            ("V", Decl::Definition(DefKind::Part)),
+            ("m", Decl::Usage(UsageKind::Attribute)),
+            ("p", Decl::Usage(UsageKind::Port)),
+            ("x", Decl::Usage(UsageKind::Default)),
+            ("R", Decl::Definition(DefKind::Requirement)),
+            ("s", Decl::Usage(UsageKind::Ref)),
+        ] {
+            assert_eq!(decl_of(text, name, false), Some(decl), "{name}");
+        }
+        let text = "package K {\n    datatype D;\n    feature f : D;\n    function F;\n}\n";
+        assert_eq!(
+            decl_of(text, "D", true),
+            Some(Decl::Definition(DefKind::DataType))
+        );
+        assert_eq!(
+            decl_of(text, "f", true),
+            Some(Decl::Usage(UsageKind::Feature))
+        );
+        assert_eq!(
+            decl_of(text, "F", true),
+            Some(Decl::Definition(DefKind::Function))
+        );
+    }
+
+    /// A declaration records the types it names: a usage's typings, a
+    /// definition's specializations.
+    #[test]
+    fn declarations_record_the_types_they_name() {
+        let text = "package U {\n    attribute def ForceUnit :> Units::DerivedUnit, Other;\n    \
+                    attribute <N> newton : ForceUnit = kg*m/s^2;\n    part p :> q;\n}\n";
+        for (name, types) in [
+            ("ForceUnit", vec!["DerivedUnit", "Other"]),
+            ("newton", vec!["ForceUnit"]),
+            ("p", vec![]),
+        ] {
+            let declared = declared_of(text, name, false).expect(name);
+            assert_eq!(declared.types, types, "{name}");
+        }
+    }
+
+    /// The measurement-unit types: the root and every definition that
+    /// specializes one, however deep; nothing else.
+    #[test]
+    fn unit_types_follow_specializations() {
+        let definitions: Vec<(&str, Vec<String>)> = vec![
+            ("ForceUnit", vec!["DerivedUnit".to_string()]),
+            ("DerivedUnit", vec!["MeasurementUnit".to_string()]),
+            ("MassUnit", vec!["SimpleUnit".to_string()]),
+            ("SimpleUnit", vec!["MeasurementUnit".to_string()]),
+            ("MassValue", vec!["ScalarQuantityValue".to_string()]),
+            ("Unitless", vec![]),
+        ];
+        let pairs = || definitions.iter().map(|(n, s)| (*n, s.as_slice()));
+        let units = super::unit_types(Some("MeasurementUnit"), &Default::default(), pairs());
+        for name in [
+            "MeasurementUnit",
+            "SimpleUnit",
+            "DerivedUnit",
+            "MassUnit",
+            "ForceUnit",
+        ] {
+            assert!(units.contains(name), "{name}");
+        }
+        assert!(!units.contains("MassValue") && !units.contains("Unitless"));
+        // Extending known unit types with more definitions.
+        let more = [("PerMass", vec!["MassUnit".to_string()])];
+        let extended =
+            super::unit_types(None, &units, more.iter().map(|(n, s)| (*n, s.as_slice())));
+        assert!(extended.contains("PerMass") && extended.contains("ForceUnit"));
+    }
+
+    #[test]
+    fn features_take_their_metaclass_kind() {
+        use super::feature_decl;
+        assert_eq!(
+            feature_decl("AttributeUsage"),
+            Decl::Usage(UsageKind::Attribute)
+        );
+        assert_eq!(feature_decl("ActionUsage"), Decl::Usage(UsageKind::Action));
+        assert_eq!(feature_decl("Feature"), Decl::Usage(UsageKind::Feature));
+        assert_eq!(feature_decl("Package"), Decl::Other);
+    }
+
+    #[test]
+    fn typing_follows_the_metamodel() {
+        let (exact, compatible) = typed_by(UsageKind::Attribute);
+        for k in [DefKind::Attribute, DefKind::Enum, DefKind::DataType] {
+            assert!(exact.contains(&k), "{k:?}");
+        }
+        assert!(!exact.contains(&DefKind::Part) && !compatible.contains(&DefKind::Part));
+        let (exact, compatible) = typed_by(UsageKind::Part);
+        assert!(exact.contains(&DefKind::Part) && exact.contains(&DefKind::Interface));
+        assert_eq!(compatible[0], DefKind::Item);
+        assert!(!exact.contains(&DefKind::Attribute));
+        assert_eq!(typed_by(UsageKind::Port).0, &[DefKind::Port]);
+        assert_eq!(typed_by(UsageKind::Ref).0, ALL_DEFINITIONS);
+        assert_eq!(typed_by(UsageKind::Feature).0, ALL_DEFINITIONS);
+    }
+
+    /// The metamodel's typing properties: a state usage is typed by any
+    /// behavior, an action usage too — constraints and requirements are
+    /// predicates, and so functions and behaviors — a calculation by any
+    /// function, a connection by an association (the library types
+    /// connections by plain ones), and a part by part definitions
+    /// alongside any other structure.
+    #[test]
+    fn typing_admits_what_the_metamodel_allows() {
+        let admits = |u: UsageKind, d: DefKind| {
+            let (exact, compatible) = typed_by(u);
+            exact.contains(&d) || compatible.contains(&d)
+        };
+        for (u, d) in [
+            (UsageKind::State, DefKind::Action),
+            (UsageKind::State, DefKind::Constraint),
+            (UsageKind::Exhibit, DefKind::Behavior),
+            (UsageKind::Action, DefKind::Constraint),
+            (UsageKind::Action, DefKind::Requirement),
+            (UsageKind::Step, DefKind::Predicate),
+            (UsageKind::Calc, DefKind::Predicate),
+            (UsageKind::Calc, DefKind::Constraint),
+            (UsageKind::Expr, DefKind::Requirement),
+            (UsageKind::Connection, DefKind::Assoc),
+            (UsageKind::Part, DefKind::Port),
+            (UsageKind::Part, DefKind::Struct),
+        ] {
+            assert!(admits(u, d), "{u:?} typed by {d:?}");
+        }
+        for (u, d) in [
+            (UsageKind::State, DefKind::Part),
+            (UsageKind::Calc, DefKind::Action),
+            (UsageKind::Part, DefKind::Attribute),
+            (UsageKind::Connection, DefKind::Part),
+        ] {
+            assert!(!admits(u, d), "{u:?} typed by {d:?}");
+        }
+    }
+
+    /// The usages of a kind are those of the kinds specializing it in the
+    /// metamodel: an occurrence may be of any kind but an attribute, a
+    /// reference, or a plain connector; an action a state, a calculation,
+    /// a case, a flow; a constraint a requirement; a part a connection,
+    /// never a plain item.
+    #[test]
+    fn usages_descend_the_metamodel() {
+        use UsageKind as U;
+        let all = |k: U| {
+            let (own, under) = usages_of(k);
+            [own, under].concat()
+        };
+        let occurrences = all(U::Occurrence);
+        for k in [
+            U::Item,
+            U::Part,
+            U::Port,
+            U::Action,
+            U::Constraint,
+            U::Concern,
+            U::Event,
+        ] {
+            assert!(occurrences.contains(&k), "{k:?}");
+        }
+        for k in [
+            U::Attribute,
+            U::Enum,
+            U::Ref,
+            U::Succession,
+            U::Binding,
+            U::Step,
+        ] {
+            assert!(!occurrences.contains(&k), "{k:?}");
+        }
+        let actions = all(U::Action);
+        for k in [
+            U::State,
+            U::Exhibit,
+            U::Calc,
+            U::UseCase,
+            U::Include,
+            U::Flow,
+            U::Accept,
+        ] {
+            assert!(actions.contains(&k), "{k:?}");
+        }
+        assert!(!actions.contains(&U::Constraint) && !actions.contains(&U::Part));
+        let constraints = all(U::Constraint);
+        for k in [
+            U::Requirement,
+            U::Satisfy,
+            U::Concern,
+            U::Viewpoint,
+            U::AssertConstraint,
+        ] {
+            assert!(constraints.contains(&k), "{k:?}");
+        }
+        assert_eq!(usages_of(U::Attribute), (vec![U::Attribute], vec![U::Enum]));
+        assert!(!usages_of(U::Part).1.contains(&U::Item));
+        assert_eq!(usages_of(U::Message), usages_of(U::Flow));
+        assert_eq!(
+            usages_of(U::Flow),
+            (vec![U::Flow, U::Message], vec![U::SuccessionFlow])
+        );
+        assert_eq!(usages_of(U::Port), (vec![U::Port], vec![]));
+    }
+
+    #[test]
+    fn specialization_climbs_the_metamodel() {
+        let (exact, compatible) = specializes(DefKind::Part);
+        assert_eq!(exact, vec![DefKind::Part]);
+        assert_eq!(
+            compatible[0],
+            DefKind::Item,
+            "nearest first: {compatible:?}"
+        );
+        assert!(compatible.contains(&DefKind::Occurrence));
+        assert!(!compatible.contains(&DefKind::Attribute));
+        let (_, compatible) = specializes(DefKind::Attribute);
+        assert_eq!(
+            compatible,
+            vec![DefKind::DataType, DefKind::Classifier, DefKind::Type]
+        );
+        let (exact, _) = specializes(DefKind::Extended);
+        assert_eq!(exact, ALL_DEFINITIONS.to_vec());
+        // An individual definition: any occurrence definition, nearest
+        // first.
+        let (exact, compatible) = specializes(DefKind::Individual);
+        assert_eq!(exact, vec![DefKind::Individual]);
+        assert_eq!(compatible[0], DefKind::Occurrence);
+        for k in [
+            DefKind::Part,
+            DefKind::Item,
+            DefKind::Action,
+            DefKind::Class,
+        ] {
+            assert!(compatible.contains(&k), "{k:?}");
+        }
+        assert!(!compatible.contains(&DefKind::Attribute));
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/lib.rs b/crates/sysmlv2-lsp/src/lib.rs
index 6147f31..c7e03fb 100644
--- a/crates/sysmlv2-lsp/src/lib.rs
+++ b/crates/sysmlv2-lsp/src/lib.rs
@@ -28,7 +28,7 @@ use lsp_types::notification::{
 use lsp_types::request::{
     CodeActionRequest, CodeLensRequest, Completion, DocumentHighlightRequest,
     DocumentSymbolRequest, Formatting, GotoDefinition, HoverRequest, InlayHintRequest, References,
-    Rename, Request as _, SemanticTokensFullRequest, WorkspaceSymbolRequest,
+    Rename, Request as _, SemanticTokensFullRequest, SignatureHelpRequest, WorkspaceSymbolRequest,
 };
 use lsp_types::{
     DiagnosticSeverity, DidChangeTextDocumentParams, DidCloseTextDocumentParams,
@@ -44,8 +44,10 @@ use sysmlv2_parser::ast::Dialect;
 use sysmlv2_parser::check;
 use sysmlv2_parser::parser::{parse_kerml_source, parse_source};
 
+mod accept;
 mod autofix;
 mod autoimport;
+mod kinds;
 // lsp-types mandates `Uri` map keys (`WorkspaceEdit::changes`, the
 // document store), and `Uri` has interior mutability; nothing here
 // mutates one while it is a key.
@@ -54,7 +56,14 @@ mod nav;
 mod outline;
 mod position;
 mod push;
+mod receiver;
+mod reuse;
+mod salvage;
+#[allow(clippy::mutable_key_type)] // see the note on `mod nav`
+mod signature;
+mod site;
 pub mod tokens;
+mod units;
 mod worker;
 
 pub use outline::{document_symbols, spell_name, spell_symbols};
@@ -129,6 +138,8 @@ pub fn run_with_options(
     nav.set_hide_redundant_value_hints(hide_redundant_value_hints(&init).unwrap_or(true));
     nav.set_infer_unit_types(infer_unit_types(&init).unwrap_or(true));
     nav.set_snippet_completions(snippet_completions(&init));
+    nav.set_insert_replace_completions(insert_replace_completions(&init));
+    nav.set_signature_label_offsets(signature_label_offsets(&init));
     let client = connection.sender.clone();
     let server = Server {
         connection,
@@ -202,6 +213,33 @@ pub(crate) fn snippet_completions(init: &InitializeParams) -> bool {
         .unwrap_or(false)
 }
 
+/// The client's `completionItem.insertReplaceSupport` capability:
+/// whether a completion's main edit may carry both an insert and a
+/// replace range. Absent means no.
+pub(crate) fn insert_replace_completions(init: &InitializeParams) -> bool {
+    init.capabilities
+        .text_document
+        .as_ref()
+        .and_then(|t| t.completion.as_ref())
+        .and_then(|c| c.completion_item.as_ref())
+        .and_then(|i| i.insert_replace_support)
+        .unwrap_or(false)
+}
+
+/// The client's `signatureHelp.signatureInformation.parameterInformation.
+/// labelOffsetSupport` capability: whether a signature's parameters may
+/// be sent as offsets into its label. Absent means no.
+pub(crate) fn signature_label_offsets(init: &InitializeParams) -> bool {
+    init.capabilities
+        .text_document
+        .as_ref()
+        .and_then(|t| t.signature_help.as_ref())
+        .and_then(|s| s.signature_information.as_ref())
+        .and_then(|i| i.parameter_information.as_ref())
+        .and_then(|p| p.label_offset_support)
+        .unwrap_or(false)
+}
+
 /// UTF-8 when the client lists it in `general.positionEncodings`
 /// (LSP 3.17), else the mandatory UTF-16 default.
 pub(crate) fn negotiate_encoding(init: &InitializeParams) -> Encoding {
@@ -218,6 +256,46 @@ pub(crate) fn negotiate_encoding(init: &InitializeParams) -> Encoding {
     }
 }
 
+/// Keep the completion items the word typed before `offset` (its
+/// identifier characters, past leading digits, which start no word) can
+/// still match: its characters, case aside, in order in the item's
+/// filter text, its label when it has none. An editor's filter needs at
+/// least that — whatever text it matches from the item's own range
+/// start ends in the word — so dropping the rest changes nothing it
+/// shows.
+fn retain_typed_matches(items: &mut Vec<lsp_types::CompletionItem>, text: &str, offset: u32) {
+    let at = text.floor_char_boundary(offset as usize);
+    let start = text[..at]
+        .char_indices()
+        .rev()
+        .take_while(|&(_, c)| c.is_ascii_alphanumeric() || c == '_')
+        .last()
+        .map_or(at, |(i, _)| i);
+    let typed: Vec<char> = text[start..at]
+        .trim_start_matches(|c: char| c.is_ascii_digit())
+        .chars()
+        .flat_map(char::to_lowercase)
+        .collect();
+    if typed.is_empty() {
+        return;
+    }
+    items.retain(|item| {
+        let mut want = typed.iter().peekable();
+        for c in item
+            .filter_text
+            .as_deref()
+            .unwrap_or(&item.label)
+            .chars()
+            .flat_map(char::to_lowercase)
+        {
+            if want.peek() == Some(&&c) {
+                want.next();
+            }
+        }
+        want.peek().is_none()
+    });
+}
+
 pub(crate) fn capabilities(encoding: Encoding) -> ServerCapabilities {
     ServerCapabilities {
         position_encoding: Some(match encoding {
@@ -247,8 +325,16 @@ pub(crate) fn capabilities(encoding: Encoding) -> ServerCapabilities {
         )),
         completion_provider: Some(lsp_types::CompletionOptions {
             // `:` opens after a `::` qualifier, `.` after a feature
-            // chain step (member completions).
-            trigger_characters: Some(vec![":".to_string(), ".".to_string()]),
+            // chain step (member completions), `[` in a quantity's unit
+            // bracket (units; a multiplicity's `[` answers nothing).
+            trigger_characters: Some(vec![":".to_string(), ".".to_string(), "[".to_string()]),
+            ..Default::default()
+        }),
+        // `(` opens an invocation's argument list, `,` moves to the next
+        // argument, and `)` closes the list — the answer is then none.
+        signature_help_provider: Some(lsp_types::SignatureHelpOptions {
+            trigger_characters: Some(vec!["(".to_string(), ",".to_string()]),
+            retrigger_characters: Some(vec![")".to_string()]),
             ..Default::default()
         }),
         inlay_hint_provider: Some(OneOf::Left(true)),
@@ -463,8 +549,7 @@ impl Server {
                     .offset_of(&d.text_document.uri, d.position)
                     .and_then(|o| {
                         self.nav
-                            .references(&self.docs, &d.text_document.uri, o, true, self.encoding)
-                            .map(|locs| nav::highlights_in(locs, &d.text_document.uri))
+                            .highlights(&self.docs, &d.text_document.uri, o, self.encoding)
                     });
                 Response::new_ok(id, hl)
             }
@@ -518,10 +603,44 @@ impl Server {
                 let (id, p): (_, lsp_types::CompletionParams) = cast(req)?;
                 let d = &p.text_document_position;
                 let offset = self.offset_of(&d.text_document.uri, d.position);
-                let items =
+                let (mut items, incomplete) =
                     self.nav
                         .completions(&self.docs, &d.text_document.uri, offset, self.encoding);
-                Response::new_ok(id, Some(lsp_types::CompletionResponse::Array(items)))
+                let doc = self.docs.get(&d.text_document.uri);
+                if let (true, Some(offset), Some(doc)) =
+                    (self.nav.insert_replace_completions(), offset, doc)
+                {
+                    accept::word_edits(&mut items, &doc.text, offset, self.encoding);
+                }
+                if let (true, Some(offset), Some(doc)) = (incomplete, offset, doc) {
+                    // Asked for again at every keystroke, the list need
+                    // carry only what the word typed can still match.
+                    retain_typed_matches(&mut items, &doc.text, offset);
+                }
+                let list = if incomplete {
+                    lsp_types::CompletionResponse::List(lsp_types::CompletionList {
+                        is_incomplete: true,
+                        items,
+                    })
+                } else {
+                    lsp_types::CompletionResponse::Array(items)
+                };
+                Response::new_ok(id, Some(list))
+            }
+            SignatureHelpRequest::METHOD => {
+                let (id, p): (_, lsp_types::SignatureHelpParams) = cast(req)?;
+                let d = &p.text_document_position_params;
+                let help = self
+                    .offset_of(&d.text_document.uri, d.position)
+                    .and_then(|o| {
+                        signature::signature_help(
+                            &mut self.nav,
+                            &self.docs,
+                            &d.text_document.uri,
+                            o,
+                        )
+                    });
+                Response::new_ok(id, help)
             }
             InlayHintRequest::METHOD => {
                 let (id, p): (_, lsp_types::InlayHintParams) = cast(req)?;
@@ -552,7 +671,8 @@ impl Server {
                     };
                     let mapper = Mapper::new(&doc.text, self.encoding);
                     let symbols = outline::document_symbols(&parse.unit, &doc.text, &mapper);
-                    nav::flatten_symbols(&symbols, uri, &p.query, &mut out);
+                    let imports = outline::plumbing(&parse.unit, &mapper).imports;
+                    nav::flatten_symbols(&symbols, uri, &p.query, &imports, &mut out);
                 }
                 Response::new_ok(id, Some(out))
             }
@@ -812,6 +932,7 @@ impl Server {
             self.unused_import_fix(uri, d, &mut out);
             self.unresolved_reference_fixes(uri, d, &mut out);
             self.import_visibility_fixes(uri, d, &mut out);
+            self.stray_terminator_fix(uri, d, &mut out);
         }
         self.lint_fix_actions(params, &mut out);
         if requested(params, "source.organizeImports") {
@@ -856,6 +977,48 @@ impl Server {
         ));
     }
 
+    /// A `;` an error sits on, where no `;` belongs: after a body's
+    /// result expression (`mass <= limit; }`), or where a member would
+    /// start — doubling the terminator before it (`;;`), or after a body
+    /// or a comment that took none (`{ … };`). Removing it is the fix.
+    /// Not for an error expecting something else at the `;`: there the
+    /// `;` stands where the statement ends, and what is missing comes
+    /// before it — a body expression's closing `)` (`f({ in x; x };`).
+    fn stray_terminator_fix(
+        &self,
+        uri: &Uri,
+        d: &lsp_types::Diagnostic,
+        out: &mut Vec<lsp_types::CodeActionOrCommand>,
+    ) {
+        let Some(doc) = self.docs.get(uri) else {
+            return;
+        };
+        let mapper = Mapper::new(&doc.text, self.encoding);
+        let start = mapper.offset(d.range.start) as usize;
+        let end = mapper.offset(d.range.end) as usize;
+        if d.severity != Some(DiagnosticSeverity::ERROR) || doc.text.get(start..end) != Some(";") {
+            return;
+        }
+        let after_result = d.message == sysmlv2_parser::parser::RESULT_EXPRESSION_TERMINATOR;
+        if !after_result
+            && (d.message.starts_with("expected ") || !at_member_start(&doc.text[..start]))
+        {
+            return;
+        }
+        out.push(quick_fix(
+            "Remove `;`".to_string(),
+            d,
+            one_file_edit(
+                uri,
+                vec![TextEdit {
+                    range: d.range,
+                    new_text: String::new(),
+                }],
+            ),
+            true,
+        ));
+    }
+
     /// Unresolved references: intent-dependent suggestions — near-miss
     /// respellings ("Did you mean …?") and, when the qualifier names a
     /// workspace enum, declaring the missing literal. The name is
@@ -1451,6 +1614,25 @@ fn requested(params: &lsp_types::CodeActionParams, kind: &str) -> bool {
     })
 }
 
+/// Does the end of `prefix` stand where a member starts — after a
+/// terminator, a body's braces, or a comment, which is a member of its
+/// own — counted on the toolkit's tokens, so notes and whitespace in
+/// between do not matter?
+fn at_member_start(prefix: &str) -> bool {
+    use sysmlv2_parser::token::TokenKind;
+    let tokens = sysmlv2_parser::lexer::tokenize(prefix).0;
+    let last = tokens
+        .iter()
+        .rev()
+        .find(|t| t.kind != TokenKind::Eof && !t.kind.is_trivia());
+    last.is_none_or(|t| {
+        matches!(
+            t.kind,
+            TokenKind::Semi | TokenKind::LBrace | TokenKind::RBrace | TokenKind::RegularComment
+        )
+    })
+}
+
 /// A workspace edit confined to one document.
 #[allow(clippy::mutable_key_type)] // see the note on `mod nav`
 fn one_file_edit(uri: &Uri, edits: Vec<TextEdit>) -> lsp_types::WorkspaceEdit {
diff --git a/crates/sysmlv2-lsp/src/nav.rs b/crates/sysmlv2-lsp/src/nav.rs
index d44dd02..6263ea9 100644
--- a/crates/sysmlv2-lsp/src/nav.rs
+++ b/crates/sysmlv2-lsp/src/nav.rs
@@ -18,6 +18,7 @@
 //! *reject atomically* and surface as request errors instead of
 //! corrupting the model.
 
+use crate::accept::Accept;
 use crate::position::{Mapper, UnitMappers, offset32};
 use crate::{Document, Encoding, Report};
 use lsp_types::{Location, Position, Range, TextEdit, Uri, WorkspaceEdit};
@@ -30,9 +31,94 @@ use sysmlv2_parser::span::Span;
 use sysmlv2_parser::visit::Visit as _;
 use sysmlv2_transform::{Library, Session, SessionError};
 
+mod namespaces;
+#[cfg(test)]
+pub(crate) use namespaces::WORK;
+use namespaces::{Access, Links, SymbolTable};
+
+/// The document a workspace table is layered for, and every other open
+/// document's text — held, and compared by identity, so a document
+/// reopened with new text never passes for the one it replaces.
+struct RestKey {
+    current: String,
+    others: Vec<(String, Arc<str>)>,
+}
+
+impl RestKey {
+    fn same(&self, other: &RestKey) -> bool {
+        self.current == other.current
+            && self.others.len() == other.others.len()
+            && self
+                .others
+                .iter()
+                .zip(&other.others)
+                .all(|((a, x), (b, y))| a == b && Arc::ptr_eq(x, y))
+    }
+}
+
 /// The session fingerprint, the package, and the actions planned for it.
 type SplitCache = (Vec<(String, i32)>, ElementRef, Vec<(String, WorkspaceEdit)>);
 
+/// The session read-only navigation answers from while the strict one
+/// cannot build (see [`Nav::read_session`]): the strict session's
+/// sources, the units that do not parse salvaged, for one fingerprint —
+/// `None` when even that could not build.
+struct Tolerant {
+    fingerprint: Vec<(String, i32)>,
+    session: Option<Session>,
+    /// Each unit as written, in the order the session was built from:
+    /// positions in the session's units are read off these. Salvage
+    /// keeps every byte's offset, not every line break — it may write a
+    /// `;` over one.
+    written: Vec<(String, String)>,
+    /// Its build (see [`Nav::built`]).
+    build: u64,
+}
+
+/// A session read-only navigation answers from (see
+/// [`Nav::read_session`]), with the units as written when it is the
+/// tolerant one.
+struct ReadSession<'a> {
+    session: &'a mut Session,
+    written: Option<&'a [(String, String)]>,
+}
+
+impl ReadSession<'_> {
+    /// Where `span` of `unit` lies, read off the unit as written.
+    fn location(&self, unit: usize, span: Span, enc: Encoding) -> Option<Location> {
+        let written = self.session.units().find_map(|(i, name, _)| {
+            (i == unit)
+                .then(|| {
+                    self.written?
+                        .iter()
+                        .find(|(n, _)| n == name)
+                        .map(|(_, t)| (name, t))
+                })
+                .flatten()
+        });
+        match written {
+            Some((name, text)) => Some(Location {
+                uri: Uri::from_str(name).ok()?,
+                range: Mapper::new(text, enc).range(span),
+            }),
+            None => Nav::location_static(self.session, unit, span, enc),
+        }
+    }
+}
+
+/// A statement's sources key with where it starts, a session's build,
+/// and how the texts that session was built from differ from the
+/// statement's (see [`Nav::cut_answer`]).
+type ReusedChanges = ((u64, u32), u64, Option<Arc<crate::reuse::Changes>>);
+
+/// What a member-access receiver reaches (see
+/// `Nav::chain_member_completions`): its members as (name, kind,
+/// detail), and whether it is a package or another namespace.
+struct Reached {
+    members: Vec<(String, lsp_types::CompletionItemKind, Option<String>)>,
+    namespace: bool,
+}
+
 /// The package a split request names.
 pub enum SplitTarget {
     /// The declaration whose name spans `offset` of the unit `uri`.
@@ -88,11 +174,16 @@ pub struct SplitResponse {
 pub struct Nav {
     pub library: Option<Library>,
     /// Every named symbol in the standard library with its qualified
-    /// path — computed once per Nav from the library *texts* (a
-    /// syntax-tier parse; no model build), since structure is syntactic.
-    /// Feeds both the flat completion list (packages + direct members)
-    /// and the qualifier-filtered import/member completions.
-    library_symbols: Option<Vec<QualifiedSymbol>>,
+    /// path, and the library's imports — computed once per Nav from the
+    /// library *texts* (a syntax-tier parse; no model build), since
+    /// structure is syntactic. Feeds both the flat completion list
+    /// (packages + direct members) and the qualifier-filtered
+    /// import/member completions; shared with every workspace table,
+    /// which layers over it.
+    library_symbols: Option<Arc<SymbolTable>>,
+    /// The measurement-unit types the library declares (see
+    /// [`crate::kinds::unit_types`]), built with the library's table.
+    library_unit_types: std::collections::HashSet<String>,
     /// Workspace root: on-disk units under it join every session build
     /// (open documents overlaid), so navigation crosses into units the
     /// client never opened. Re-read at rebuild time — the worker tier's
@@ -104,13 +195,26 @@ pub struct Nav {
     /// same uri strings the client opens documents under. Takes the
     /// role of the root walk when set.
     workspace: Option<Arc<Vec<(String, String)>>>,
-    /// Qualified symbols of the seeded workspace units, parsed once per
-    /// seed (the [`Self::library_symbols`] pattern) — import fixes and
-    /// completions must see the whole workspace, not just what happens
-    /// to be open, without a per-keystroke full-workspace parse. Units
-    /// shadowed by an open document are filtered at query time.
-    workspace_seed_symbols: Option<Vec<QualifiedSymbol>>,
+    /// Qualified symbols and imports of the seeded workspace units,
+    /// parsed once per seed (the [`Self::library_symbols`] pattern) —
+    /// import fixes and completions must see the whole workspace, not
+    /// just what happens to be open, without a per-keystroke
+    /// full-workspace parse. Units shadowed by an open document are
+    /// filtered at query time.
+    workspace_seed_symbols: Option<(Vec<QualifiedSymbol>, Links)>,
+    /// The workspace below the document last completed in — every
+    /// other open document and the seed units not open — kept while the
+    /// key (that document, the others' texts) holds.
+    workspace_rest: Option<(RestKey, Arc<SymbolTable>)>,
     session: Option<Session>,
+    /// The fingerprint the strict session last failed to build for — a
+    /// unit that does not parse — so a request with the same documents
+    /// does not parse them all again to find that out.
+    strict_failed: Option<Vec<(String, i32)>>,
+    /// Read-only navigation's session while the strict one cannot build.
+    tolerant: Option<Tolerant>,
+    /// What the tolerant session's builds made of each unit.
+    tolerant_salvage: crate::salvage::SalvageCache,
     /// Failures behind an empty answer, waiting for the server to pass
     /// them to the client ([`Nav::take_reports`]).
     reports: Vec<Report>,
@@ -145,6 +249,18 @@ pub struct Nav {
     /// auto-inserted text. Off by default — a non-snippet client
     /// would render the stop literally.
     snippet_completions: bool,
+    /// The client declared `completionItem.insertReplaceSupport` at
+    /// `initialize`: with the cursor inside a word, a completion's main
+    /// edit carries an insert range (up to the cursor) and a replace
+    /// range (through the rest of the word), and the client's own
+    /// setting picks one. Off by default — other clients get the
+    /// insert range alone.
+    insert_replace_completions: bool,
+    /// The client declared `signatureHelp.signatureInformation.
+    /// parameterInformation.labelOffsetSupport` at `initialize`: a
+    /// signature's parameters are sent as offsets into its label rather
+    /// than as substrings the client searches for.
+    signature_label_offsets: bool,
     /// Accepting a unit completion inside the quantity bracket of an
     /// *untyped* attribute declaration also declares the type the unit
     /// determines (exactly one, or nothing is inserted). Default on;
@@ -157,6 +273,51 @@ pub struct Nav {
     /// everything *outside* the blanked statement, so keystrokes
     /// within one statement reuse the build.
     completion_session: Option<(u64, Session)>,
+    /// The key of the completion session build that failed last: the
+    /// same sources would fail again, so they are not rebuilt until they
+    /// change.
+    completion_failed: Option<u64>,
+    /// The key of the sources, the member the live text reads a
+    /// statement in cut out whole, whose model named no members last
+    /// (see [`Self::read_inherited`]): the same text would name none
+    /// again, so it is not built again until it changes.
+    member_cut_failed: Option<u64>,
+    /// Sessions built so far, of either kind, and the count at which
+    /// [`Self::session`] and [`Self::completion_session`] were built:
+    /// which of the two is the most recent.
+    builds: u64,
+    session_build: u64,
+    completion_build: u64,
+    /// The sources [`Self::session`] and [`Self::completion_session`]
+    /// were built from, as written (the statement being typed cut out of
+    /// the latter): what their answers are current for.
+    session_sources: Vec<(String, String)>,
+    completion_sources: Vec<(String, String)>,
+    /// The inherited members last named for enclosing elements, most
+    /// recent first, by the text they depend on (see
+    /// [`Self::inherited_members`]).
+    member_cache: Vec<(u64, Vec<ScopeMember>)>,
+    /// Each seeded unit's name and a hash of its text, taken once per
+    /// seed: what a named member's key holds for the units not open (see
+    /// [`Self::inherited_members`]).
+    seed_hashes: Vec<(String, u64)>,
+    /// The library's units in a session's model, classified once per
+    /// session build (see [`crate::units::UnitEntry`]), by library symbol
+    /// index, with the build they were classified in (see [`Read`]).
+    library_units: Option<(u64, Vec<(usize, crate::units::UnitEntry)>)>,
+    /// How the texts each of the last few sessions built was built from
+    /// differ from those a build for a statement would read (see
+    /// [`Self::cut_answer`]): the key of the statement's sources with
+    /// where it starts, the session's build, and the changes — `None`
+    /// where the check cannot place them. Most recent first.
+    reused: Vec<ReusedChanges>,
+    /// What the import and alias statements of the sessions built make
+    /// an answer read off them depend on (see [`crate::reuse::Imports`]),
+    /// by build.
+    reused_imports: Vec<(u64, Arc<crate::reuse::Imports>)>,
+    /// What the completion session's builds made of each workspace unit
+    /// (see [`crate::salvage::SalvageCache`]).
+    salvage: crate::salvage::SalvageCache,
 }
 
 impl Nav {
@@ -175,9 +336,11 @@ impl Nav {
         Nav {
             library,
             library_symbols: None,
+            library_unit_types: std::collections::HashSet::new(),
             root: None,
             workspace: None,
             workspace_seed_symbols: None,
+            workspace_rest: None,
             session: None,
             fingerprint: Vec::new(),
             verify: None,
@@ -185,8 +348,26 @@ impl Nav {
             split_cache: None,
             hide_redundant_value_hints: true,
             snippet_completions: false,
+            insert_replace_completions: false,
+            signature_label_offsets: false,
             infer_unit_types: true,
             completion_session: None,
+            completion_failed: None,
+            member_cut_failed: None,
+            builds: 0,
+            session_build: 0,
+            completion_build: 0,
+            session_sources: Vec::new(),
+            completion_sources: Vec::new(),
+            member_cache: Vec::new(),
+            seed_hashes: Vec::new(),
+            library_units: None,
+            reused: Vec::new(),
+            reused_imports: Vec::new(),
+            salvage: crate::salvage::SalvageCache::default(),
+            strict_failed: None,
+            tolerant: None,
+            tolerant_salvage: crate::salvage::SalvageCache::default(),
             reports: Vec::new(),
             config: LintConfig::under(None),
         }
@@ -205,6 +386,45 @@ impl Nav {
         self.snippet_completions = on;
     }
 
+    /// Set whether completion edits may carry insert and replace ranges
+    /// both — from the client's `completionItem.insertReplaceSupport`
+    /// capability at `initialize`.
+    pub fn set_insert_replace_completions(&mut self, on: bool) {
+        self.insert_replace_completions = on;
+    }
+
+    /// Whether completion edits may carry insert and replace ranges
+    /// both (see [`Self::set_insert_replace_completions`]).
+    pub fn insert_replace_completions(&self) -> bool {
+        self.insert_replace_completions
+    }
+
+    /// Set whether signature help may send parameters as offsets into
+    /// the signature's label — from the client's `labelOffsetSupport`
+    /// capability at `initialize`.
+    pub fn set_signature_label_offsets(&mut self, on: bool) {
+        self.signature_label_offsets = on;
+    }
+
+    /// Whether signature help may send parameters as label offsets (see
+    /// [`Self::set_signature_label_offsets`]).
+    pub fn signature_label_offsets(&self) -> bool {
+        self.signature_label_offsets
+    }
+
+    /// What accepting an item of a completion request in `uri` writes
+    /// (see [`Accept`]), as the client's capabilities allow.
+    fn accept<'a>(&self, text: &'a str, uri: &Uri, cx: &CompletionCx, enc: Encoding) -> Accept<'a> {
+        Accept::new(
+            text,
+            enc,
+            cx,
+            crate::dialect_of(uri),
+            self.snippet_completions,
+            self.insert_replace_completions,
+        )
+    }
+
     /// Set whether evaluated-value inlay hints that restate the
     /// declared expression verbatim are suppressed (they are by
     /// default). Answers change without any source changing, so the
@@ -224,34 +444,74 @@ impl Nav {
     /// Unit names must be the same uri strings the client opens
     /// documents under, or an open document duplicates its on-model
     /// unit instead of overlaying it.
+    ///
+    /// The completion tier's session stays: it is kept by the texts it
+    /// was built from, so a re-seed that leaves them as they were — the
+    /// host seeds every open document after each pause in typing —
+    /// leaves it current, and one that changes them has the next request
+    /// build another.
     pub fn set_workspace_sources(&mut self, units: Arc<Vec<(String, String)>>) {
         self.workspace = Some(units);
         self.workspace_seed_symbols = None;
-        self.invalidate();
+        self.workspace_rest = None;
+        self.seed_hashes = self
+            .workspace
+            .iter()
+            .flat_map(|units| units.iter())
+            .map(|(name, text)| {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                text.hash(&mut hasher);
+                (name.clone(), hasher.finish())
+            })
+            .collect();
+        self.invalidate_navigation();
     }
 
-    /// Drop the cached session (after a rename commit mutated it, the
+    /// Drop the cached sessions (after a rename commit mutated one, the
     /// client must re-sync before answers are trustworthy again).
     pub fn invalidate(&mut self) {
+        self.invalidate_navigation();
+        self.completion_session = None;
+        self.library_units = None;
+        self.completion_sources.clear();
+    }
+
+    /// Drop the navigation session and what was derived from it: it is
+    /// kept by the open documents' versions, which tell nothing of the
+    /// seeded units a re-seed replaces.
+    fn invalidate_navigation(&mut self) {
         self.session = None;
         self.fingerprint.clear();
+        self.strict_failed = None;
+        self.tolerant = None;
         self.verify = None;
         self.lint = None;
         self.split_cache = None;
-        self.completion_session = None;
+        self.session_sources.clear();
     }
 
-    /// Completions for a feature-chain step (`tank.|`, `tank.liq|`,
-    /// `a.b.|`): the members the step could reach. The chain resolves
-    /// the way the evaluator resolves chains — the head from the
-    /// innermost enclosing declaration outward (inherited members
-    /// included, via [`ResolvedModel::member_of`]), later segments as
-    /// members of the segment before them — and enumeration walks the
-    /// reached feature's own body, its declared types, and their
-    /// explicit specialization closure, nearest declaration winning a
-    /// name. `None` when the prefix does not resolve or reaches
-    /// something memberless: the caller falls back to the
-    /// position-blind list.
+    /// Completions for a member access (`tank.|`, `tank.liq|`, `a.b.|`,
+    /// `wheels#(1).|`, `f(x).|`): the members the receiver could reach.
+    /// The receiver resolves the way the evaluator resolves it — a head
+    /// name from the innermost enclosing declaration outward (inherited
+    /// members included, via [`ResolvedModel::member_of`]), each step as
+    /// a member of the one before it, an indexed feature as its elements
+    /// (which have the feature's type), an invocation as its callee's
+    /// result — and enumeration takes the reached element's own features
+    /// and those it inherits through its written specializations (its
+    /// declared types, conjugated port types included, and their
+    /// specialization closure), nearest declaration winning a name. The
+    /// inheritance is the model's own (`Type::inheritedMemberships`):
+    /// a feature an owned feature redefines is not inherited, though a
+    /// chain step naming it still resolves, and a protected member is
+    /// listed even where a step from outside its type cannot reach it.
+    /// A receiver named by a reference (`x.`, `P::x.`) also takes the
+    /// `metadata` keyword of a metadata access, sorted after its members
+    /// — unless it is a package, whose dot is usually a slip for `::`.
+    /// `None` when the cursor does not follow a member-access dot. A
+    /// receiver that does not resolve answers an empty list: after a dot
+    /// the position-blind list is never what is wanted.
     ///
     /// [`ResolvedModel::member_of`]: sysmlv2_parser::json::ResolvedModel::member_of
     fn chain_member_completions(
@@ -260,128 +520,401 @@ impl Nav {
         uri: &Uri,
         cx: &CompletionCx,
         enc: Encoding,
-        snippets: bool,
     ) -> Option<Vec<lsp_types::CompletionItem>> {
-        // The statement being typed, cut for the session build (its
-        // parse error would refuse the whole session): statement start
-        // to the end of the cursor's line.
         let text = &docs.get(uri)?.text;
-        let line_end = text[(cx.offset as usize).min(text.len())..]
-            .find('\n')
-            .map(|i| cx.offset + offset32(i))
-            .unwrap_or(offset32(text.len()));
-        let session = self.completion_session(docs, uri, Span::new(cx.stmt_start, line_end))?;
-        let unit = Self::unit_of_static(uri, session)?;
-        let resolved = session.resolved();
-        // The declarations enclosing the statement, innermost first:
-        // the scopes the chain head resolves from. Queried at the
-        // statement's start — the same scopes as the cursor, at an
-        // offset the cut cannot have shifted.
-        let at = cx.stmt_start;
-        let mut enclosing: Vec<(ElementRef, u32)> = resolved
-            .user_elements()
-            .filter_map(|e| {
-                let (u, span) = resolved.member_extent(e)?;
-                (u == unit && span.start <= at && at <= span.end).then(|| (e, span.len()))
-            })
-            .collect();
-        enclosing.sort_by_key(|&(_, len)| len);
-        let qn = |name: &str| sysmlv2_parser::ast::QualifiedName {
-            is_global: false,
-            segments: vec![sysmlv2_parser::ast::Name {
-                value: name.to_string(),
-                span: Span::new(0, 0),
-            }],
-            span: Span::new(0, 0),
-        };
-        let root = resolved.root_scope();
-        let head = qn(&cx.dot_chain[0]);
-        let mut cur = enclosing
-            .iter()
-            .find_map(|&(e, _)| resolved.member_of(e, &head).map(|(hit, _)| hit))
-            .or_else(|| resolved.resolve_in(root, &head))?;
-        for seg in &cx.dot_chain[1..] {
-            cur = resolved.member_of(cur, &qn(seg))?.0;
-        }
-        // Enumerate: own body first, then declared types and their
-        // specialization closure (breadth-first, so the nearest
-        // declaration of a name shadows farther ones).
-        let mut members: Vec<(String, ElementRef)> = Vec::new();
-        let mut seen = std::collections::HashSet::new();
-        let mut visited = std::collections::HashSet::new();
-        let mut frontier = std::collections::VecDeque::from([cur]);
-        while let Some(scope_el) = frontier.pop_front() {
-            if !visited.insert(scope_el) {
-                continue;
-            }
-            for m in resolved.owned_features(scope_el) {
-                if let Some(n) = resolved.element_name(m) {
-                    if seen.insert(n.to_string()) {
-                        members.push((n.to_string(), m));
-                    }
-                }
+        // A member typed quoted (`q.'max|`): the receiver is read where the
+        // quote opens; the accept still replaces the quoted name.
+        let after_quote = cx
+            .quoted
+            .map(|q| q.open())
+            .filter(|&open| open > 0 && text.as_bytes().get(open as usize - 1) == Some(&b'.'))
+            .map(|open| completion_context(text, open, crate::dialect_of(uri)));
+        let at = after_quote.as_ref().unwrap_or(cx);
+        // The receiver: the name chain the context read, else — for a
+        // chain ending in an index or an invocation, or one whose head is
+        // qualified (`P::part.`), where that scan stops short — the
+        // receiver read off the tokens.
+        let chain_len: usize = at.dot_chain.iter().map(|link| link.len() + 1).sum();
+        let head = (at.partial_start as usize).saturating_sub(chain_len);
+        let qualified_head = text.get(..head).is_some_and(|t| t.ends_with("::"));
+        let receiver = match at.dot_chain.as_slice() {
+            chain if !chain.is_empty() && !qualified_head => {
+                Some(crate::receiver::chain_expr(chain))
             }
-            for t in resolved.typings(scope_el) {
-                frontier.push_back(t);
-            }
-            for s in resolved.explicit_supertypes(scope_el) {
-                frontier.push_back(s);
+            _ => {
+                // A dot after a name is a member access even where the
+                // tokens spell no receiver: it answers nothing, never the
+                // position-blind list.
+                let Some(span) =
+                    crate::receiver::postfix_receiver(text, at.stmt_start, at.partial_start)
+                else {
+                    return (!at.dot_chain.is_empty()).then(Vec::new);
+                };
+                crate::receiver::parse_receiver(
+                    &text[span.start as usize..span.end as usize],
+                    crate::dialect_of(uri),
+                )
             }
-        }
-        if members.is_empty() {
-            return None;
-        }
-        // Kind + detail while the session borrow lasts; items after.
-        let details: Vec<(String, lsp_types::CompletionItemKind, Option<String>)> = members
-            .into_iter()
-            .map(|(n, m)| {
-                let kind = member_kind(resolved.element_type(m));
-                let detail = resolved.element_qualified_name(m);
-                (n, kind, detail)
-            })
-            .collect();
+        };
+        // `x.metadata` reads an element's metadata: a receiver named by a
+        // reference takes the keyword once it resolves — but not a
+        // package, whose dot is usually a slip for `::`, nor where a name
+        // is typed quoted.
+        let by_reference = after_quote.is_none()
+            && receiver
+                .as_ref()
+                .is_some_and(|r| matches!(r.kind, sysmlv2_parser::ast::ExprKind::Ref(_)));
+        let reached = receiver.and_then(|receiver| {
+            self.receiver_members(docs, uri, at.stmt_start, cx.offset, &receiver)
+        });
+        let metadata = by_reference && reached.as_ref().is_some_and(|r| !r.namespace);
         let d = docs.get(uri)?;
-        let mapper = Mapper::new(&d.text, enc);
-        Some(
-            details
-                .into_iter()
-                .map(|(name, kind, detail)| {
-                    let (text_edit, repair, insert_text_format) = item_edits(
-                        &d.text,
-                        &mapper,
-                        cx,
-                        crate::dialect_of(uri),
-                        &name,
-                        snippets,
-                    );
+        let accept = self.accept(&d.text, uri, cx, enc);
+        let mut items: Vec<lsp_types::CompletionItem> = reached
+            .map(|r| r.members)
+            .unwrap_or_default()
+            .into_iter()
+            .map(|(name, kind, detail)| {
+                let label = crate::outline::spell_name(&name);
+                accept.name(&name).fill(
                     lsp_types::CompletionItem {
-                        label: crate::outline::spell_name(&name),
+                        // The members in the order of their labels, as
+                        // with no sort text; the keyword after them all.
+                        sort_text: Some(format!("0{label}")),
+                        label,
                         kind: Some(kind),
                         detail,
-                        text_edit,
-                        additional_text_edits: repair.map(|e| vec![e]),
-                        insert_text_format,
                         ..Default::default()
-                    }
+                    },
+                    Vec::new(),
+                )
+            })
+            .collect();
+        if metadata {
+            items.push(lsp_types::CompletionItem {
+                label: "metadata".to_string(),
+                kind: Some(lsp_types::CompletionItemKind::KEYWORD),
+                sort_text: Some("1metadata".to_string()),
+                ..Default::default()
+            });
+        }
+        Some(items)
+    }
+
+    /// What `receiver` reaches (see [`Reached`] and
+    /// [`Self::chain_member_completions`]), read in a model without the
+    /// statement starting at `stmt_start` (see
+    /// [`Self::statement_answer`]); the declarations enclosing the
+    /// statement's start are the scopes a head name resolves from. `None`
+    /// when no session can be built or the receiver does not resolve.
+    fn receiver_members(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        stmt_start: u32,
+        cursor: u32,
+        receiver: &sysmlv2_parser::ast::Expr,
+    ) -> Option<Reached> {
+        self.statement_answer(docs, uri, stmt_start, cursor, |at| {
+            let resolved = at.session.resolved();
+            let enclosing = crate::receiver::enclosing_declarations(resolved, at.unit, at.at);
+            at.needs.scopes(&enclosing);
+            at.needs.expr(receiver);
+            let mut reached = Vec::new();
+            let target =
+                crate::receiver::receiver_reached(resolved, &enclosing, receiver, &mut reached)?;
+            reached.into_iter().for_each(|e| at.needs.read(e));
+            let mut seen = std::collections::HashSet::new();
+            let mut members = Vec::new();
+            for m in resolved.effective_features(target, false) {
+                let Some(name) = resolved.element_lookup_name(m) else {
+                    continue;
+                };
+                if seen.insert(name.clone()) {
+                    let kind = member_kind(resolved.element_type(m));
+                    members.push((name, kind, resolved.element_qualified_name(m)));
+                }
+            }
+            Some(Reached {
+                members,
+                namespace: matches!(
+                    resolved.element_type(target),
+                    "Package" | "LibraryPackage" | "Namespace"
+                ),
+            })
+        })
+    }
+
+    /// Completions inside a `[` (see [`crate::units::bracket_at`]). In
+    /// a quantity's unit bracket, the units: those of the quantity the
+    /// value is declared as first (a `DurationValue` takes `s`, `min`,
+    /// `h`, `d`) — for a value no declaration's whole, the quantity of
+    /// the operand it is compared with or added to, or of the parameter
+    /// it binds as an argument (see [`crate::units::unit_context`]) —
+    /// each group's short symbols ahead of its long names,
+    /// the other units after them — a factor of a compound unit (`m` in
+    /// `[m/s]`) measures something else than the whole — each carrying
+    /// its import and an untyped declaration's inferred typing like any
+    /// other name. In any other bracket — a multiplicity, a filter —
+    /// nothing while nothing or a number is typed there; nothing either
+    /// right after a `[` that opens no bracket (one in a comment or a
+    /// string) or an import's filter condition. `None` outside a
+    /// bracket, after a qualifier, once a name is typed in any bracket
+    /// but a unit's (a bound may name a feature, `[1..numberOfBolts]`),
+    /// or in a unit bracket no model can be built for.
+    fn bracket_completions(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cx: &CompletionCx,
+        enc: Encoding,
+        unit_type_cx: Option<&UnitTypeCx>,
+    ) -> Option<Vec<lsp_types::CompletionItem>> {
+        let text = &docs.get(uri)?.text;
+        let after_bracket = text
+            .get(..cx.offset as usize)
+            .is_some_and(|t| t.ends_with('['));
+        // An import's filter condition (`::*[@Safe`) lists the import's
+        // names once a word is typed: a `[` alone offers nothing.
+        if cx.import {
+            return after_bracket.then(Vec::new);
+        }
+        let dialect = crate::dialect_of(uri);
+        // A qualified name in a unit bracket (`[SI::k`) is a unit of that
+        // namespace; anywhere else in a bracket (`[1..Limits::`), a member
+        // of it like any other.
+        let qualified = (!cx.qualifier.is_empty()).then(|| cx.qualifier.join("::"));
+        let (open, header) = match crate::units::bracket_at(text, cx, dialect) {
+            Some(crate::units::Bracket::Unit { open, header }) => (open, header),
+            _ if qualified.is_some() => return None,
+            // A bound or a filter: quiet while nothing or a number is
+            // typed; a name typed there (`[1..count`, `[@Safe`) is
+            // completed like one anywhere else.
+            Some(crate::units::Bracket::Other) => {
+                let typed = &text.as_bytes()[cx.partial_start as usize..cx.offset as usize];
+                return typed.first().is_none_or(u8::is_ascii_digit).then(Vec::new);
+            }
+            None => return after_bracket.then(Vec::new),
+        };
+        let accept = self.accept(text, uri, cx, enc);
+        // Only a name accepted as the whole bracket content, not as a
+        // factor of a compound unit, is measured by the declared
+        // quantity: nothing but blanks between the `[` and where
+        // accepting it starts replacing (a typed quote, or the typed
+        // spelling of the name, it absorbs).
+        let replacement = crate::accept::Replacement::new(text, cx);
+        let written = qualified.as_ref().map(|path| format!("{path}::"));
+        let whole = |name: &str| {
+            text.get(open as usize + 1..replacement.start_for(text, name) as usize)
+                .is_some_and(|s| {
+                    let s = s.trim();
+                    s.is_empty()
+                        || written
+                            .as_deref()
+                            .is_some_and(|w| s == w || s.strip_prefix("$::") == Some(w))
                 })
-                .collect(),
+        };
+        let workspace = self.all_workspace_symbols(docs, uri, enc);
+        let library_table = self.library_table();
+        let library: &[QualifiedSymbol] = library_table.symbols();
+        let parsed = if crate::is_kerml(uri.path().as_str()) {
+            sysmlv2_parser::parser::parse_kerml_source(text)
+        } else {
+            sysmlv2_parser::parser::parse_source(text)
+        };
+        let auto = crate::autoimport::AutoImport::new(
+            text,
+            &parsed.unit,
+            cx.offset,
+            Span::new(cx.partial_start, cx.offset),
         )
+        .with_reexports(&workspace);
+        let cut = crate::salvage::typed_statement_cut(text, cx.stmt_start, cx.offset);
+        // Rank: the declared quantity's short symbols, its long names,
+        // then the other units' — within a group the workspace's units
+        // ahead of the library's, then by package, in declaration order.
+        // A unit not visible here claims no name; after a qualifier, the
+        // namespace's own units and those it re-exports are the ones,
+        // needing no import.
+        let reexported: std::collections::HashSet<&str> = qualified
+            .as_deref()
+            .map(|path| {
+                workspace
+                    .reexported_members(path, Access::Clients)
+                    .into_iter()
+                    .map(|s| s.qualified.as_str())
+                    .collect()
+            })
+            .unwrap_or_default();
+        let mut ranked = self.cut_answer(docs, uri, cut, |at| {
+            let unit_of: HashMap<String, usize> = at
+                .session
+                .units()
+                .map(|(i, name, _)| (name.to_string(), i))
+                .collect();
+            let resolved = at.session.resolved();
+            let enclosing = crate::receiver::enclosing_declarations(resolved, at.unit, at.at);
+            at.needs.scopes(&enclosing);
+            at.needs.units();
+            let declared = match header {
+                Some(h) => {
+                    let header = &text[h.start as usize..h.end as usize];
+                    at.needs.declaration(resolved, &enclosing, header, dialect);
+                    crate::units::declared_measure(resolved, &enclosing, header, dialect)
+                }
+                None => crate::units::unit_context(text, cx).and_then(|context| {
+                    at.needs
+                        .context(resolved, &enclosing, text, &context, dialect);
+                    crate::units::context_measure(resolved, &enclosing, text, &context, dialect)
+                }),
+            };
+            // The workspace's units, classified per request, by what their
+            // declarations say; the library's, once per session build.
+            let mut units = crate::units::Units::new(resolved);
+            let mut tops = None;
+            let mut workspace_units: Vec<(&QualifiedSymbol, crate::units::UnitEntry)> = Vec::new();
+            for s in workspace.iter().filter(|s| !s.effective) {
+                let site = s.site.as_ref().map(|(uri, _)| uri.as_str());
+                let Some(element) =
+                    declared_element(resolved, &s.qualified, site, &unit_of, &mut tops)
+                else {
+                    continue;
+                };
+                if let Some(entry) = units.entry_of(resolved, element, &s.name) {
+                    at.needs.read(element);
+                    workspace_units.push((s, entry));
+                }
+            }
+            if at
+                .library_units
+                .as_ref()
+                .is_none_or(|(build, _)| *build != at.build)
+            {
+                *at.library_units = Some((
+                    at.build,
+                    library
+                        .iter()
+                        .enumerate()
+                        .filter(|(_, s)| s.depth <= 1)
+                        .filter_map(|(i, s)| {
+                            Some((i, units.entry(resolved, &s.qualified, &s.name)?))
+                        })
+                        .collect(),
+                ));
+            }
+            let library_units = &at.library_units.as_ref()?.1;
+            let mut seen = std::collections::HashSet::new();
+            let mut ranked = Vec::new();
+            for (from_library, s, entry) in workspace_units
+                .iter()
+                .map(|(s, entry)| (false, *s, entry))
+                .chain(
+                    library_units
+                        .iter()
+                        .map(|(i, entry)| (true, &library[*i], entry)),
+                )
+            {
+                if seen.contains(s.name.as_str()) {
+                    continue;
+                }
+                let import = match qualified.as_deref() {
+                    Some(path)
+                        if s.is_member_of(path) || reexported.contains(s.qualified.as_str()) =>
+                    {
+                        None
+                    }
+                    Some(_) => continue,
+                    None => match reach(&auto, s) {
+                        Some(import) => import,
+                        None => continue,
+                    },
+                };
+                seen.insert(s.name.as_str());
+                let fits = whole(&s.name)
+                    && declared
+                        .as_ref()
+                        .is_some_and(|d| crate::units::Units::fits(resolved, entry, d));
+                let package = s
+                    .qualified
+                    .strip_suffix(s.name.as_str())
+                    .unwrap_or_default();
+                ranked.push((
+                    (
+                        u8::from(!fits) * 2 + u8::from(!entry.short),
+                        from_library,
+                        package,
+                    ),
+                    s,
+                    import,
+                ));
+            }
+            Some(ranked)
+        })?;
+        ranked.sort_by_key(|&(key, ..)| key);
+        // Where the declared quantity puts its own units first, only they
+        // keep the typed word's whole match of a symbol of one or two
+        // characters (see [`unmatched_whole`]): `k` ranks `kg` ahead of
+        // kelvin's `K`.
+        let fitting = ranked.first().is_some_and(|((rank, ..), ..)| *rank < 2);
+        let mapper = Mapper::new(text, enc);
+        let mut out = Vec::with_capacity(ranked.len());
+        let mut meta = Vec::with_capacity(ranked.len());
+        for (i, ((rank, ..), s, import)) in ranked.into_iter().enumerate() {
+            let (imports, label_details) =
+                match import.and_then(|edit| import_for(&mapper, dialect, s, edit)) {
+                    Some((edits, details)) => (edits, Some(details)),
+                    None => (Vec::new(), None),
+                };
+            meta.push(offered(i, s));
+            let mut edits = accept.name(&s.name);
+            let label = crate::outline::spell_name(&s.name);
+            if fitting && rank >= 2 && label.chars().count() <= 2 {
+                edits.filter_text = Some(unmatched_whole(
+                    edits.filter_text.as_deref().unwrap_or(&label),
+                    s.long.as_deref().unwrap_or(&label),
+                ));
+            }
+            out.push(edits.fill(
+                lsp_types::CompletionItem {
+                    label: crate::outline::spell_name(&s.name),
+                    kind: Some(s.kind),
+                    detail: Some(s.qualified.clone()),
+                    documentation: s.documentation(),
+                    label_details,
+                    // A client ranks equally good matches by this: the
+                    // order above.
+                    sort_text: Some(format!("{i:05}")),
+                    ..Default::default()
+                },
+                imports,
+            ));
+        }
+        if let Some(tcx) = unit_type_cx {
+            self.append_unit_type_edits(docs, uri, enc, (cx, tcx), &meta, &mut out);
+        }
+        Some(out)
     }
 
     /// The session over the current open documents, rebuilding if any
-    /// version moved. `None` when a document fails to build a session
-    /// (never expected — sessions tolerate parse errors — but a broken
-    /// library directory reports here).
+    /// version moved. `None` when a unit does not parse (see
+    /// [`Self::build_session`]) — found once per fingerprint — or the
+    /// library cannot be read.
     fn session(&mut self, docs: &BTreeMap<Uri, Document>) -> Option<&mut Session> {
-        let mut fp: Vec<(String, i32)> = docs
-            .iter()
-            .map(|(u, d)| (u.to_string(), d.version))
-            .collect();
-        fp.sort();
+        let fp = Self::fingerprint_of(docs);
         if self.session.is_none() || fp != self.fingerprint {
+            if self.strict_failed.as_ref() == Some(&fp) {
+                return None;
+            }
             let sources = self.assemble_sources(docs, &fp);
-            let session = self.build_session(sources)?;
+            let Some(session) = self.build_session(sources.clone()) else {
+                self.strict_failed = Some(fp);
+                return None;
+            };
             self.session = Some(session);
+            self.session_sources = sources;
+            self.tolerant = None;
+            self.builds += 1;
+            self.session_build = self.builds;
             self.fingerprint = fp;
             self.verify = None;
             self.lint = None;
@@ -390,6 +923,73 @@ impl Nav {
         self.session.as_mut()
     }
 
+    /// The models held right now: the strict session, read-only
+    /// navigation's tolerant one, the completion session.
+    #[cfg(test)]
+    pub(crate) fn sessions_held(&self) -> usize {
+        usize::from(self.session.is_some())
+            + usize::from(self.tolerant.as_ref().is_some_and(|t| t.session.is_some()))
+            + usize::from(self.completion_session.is_some())
+    }
+
+    /// (uri string, version) per open document, sorted: what a session
+    /// is current for.
+    fn fingerprint_of(docs: &BTreeMap<Uri, Document>) -> Vec<(String, i32)> {
+        let mut fp: Vec<(String, i32)> = docs
+            .iter()
+            .map(|(u, d)| (u.to_string(), d.version))
+            .collect();
+        fp.sort();
+        fp
+    }
+
+    /// The session read-only navigation — hover, definition, document
+    /// highlights — answers from: the strict session, else, while a unit
+    /// does not parse, one the units that do not parse join salvaged
+    /// (see [`crate::salvage`]) or, when they cannot be, stay out of. It
+    /// answers for everything outside what salvage blanks, which is
+    /// enough to show and to jump; references, rename, code actions and
+    /// refactors plan over every reference and keep the strict session.
+    /// Built once per fingerprint, reusing what the last build made of
+    /// each unit.
+    fn read_session(&mut self, docs: &BTreeMap<Uri, Document>) -> Option<ReadSession<'_>> {
+        if self.session(docs).is_some() {
+            return self.session.as_mut().map(|session| ReadSession {
+                session,
+                written: None,
+            });
+        }
+        let fp = Self::fingerprint_of(docs);
+        if self.tolerant.as_ref().is_none_or(|t| t.fingerprint != fp) {
+            self.tolerant = None;
+            // The strict session is for versions these documents have
+            // left, and answers nothing for them: let it go rather than
+            // hold a third model beside this one and the completion
+            // session's. The next strict build replaces it anyway.
+            self.session = None;
+            self.session_sources = Vec::new();
+            self.verify = None;
+            self.lint = None;
+            self.split_cache = None;
+            let sources = self.assemble_sources(docs, &fp);
+            let written = sources.clone();
+            let salvaged = self.tolerant_salvage.salvage_all(sources);
+            let session = self.build_parsed_session(salvaged);
+            self.builds += 1;
+            self.tolerant = Some(Tolerant {
+                fingerprint: fp,
+                session,
+                written,
+                build: self.builds,
+            });
+        }
+        let t = self.tolerant.as_mut()?;
+        Some(ReadSession {
+            session: t.session.as_mut()?,
+            written: Some(&t.written),
+        })
+    }
+
     /// The session source list: workspace units first (in-memory seed,
     /// else a root walk), open documents overlaid — the worker tier's
     /// convention, so imports into units that are not open still
@@ -414,24 +1014,67 @@ impl Nav {
     /// A session over `sources`, the configured library loaded. `None`
     /// when any unit fails to parse (sessions refuse parse errors) —
     /// the ordinary state of a document mid-edit, and the syntax tier
-    /// already shows those errors. A library that cannot be read is not
-    /// ordinary and is recorded for the client: without it every
-    /// model-backed answer here is silently empty.
+    /// already shows those errors; the units are parsed ahead of the
+    /// library, so that refusal costs no model build. A library that
+    /// cannot be read is not ordinary and is recorded for the client:
+    /// without it every model-backed answer here is silently empty.
     fn build_session(&mut self, sources: Vec<(String, String)>) -> Option<Session> {
-        let mut session = match Session::from_sources(sources) {
-            Ok(session) => session,
-            Err(e) => {
-                self.note_failure(&e, false);
-                return None;
-            }
+        let parses = |(name, text): &(String, String)| {
+            let parse = if crate::is_kerml(name) {
+                sysmlv2_parser::parser::parse_kerml_source(text)
+            } else {
+                sysmlv2_parser::parser::parse_source(text)
+            };
+            !parse.has_errors()
         };
-        if let Some(lib) = &self.library {
-            if let Err(e) = session.load_library_from(lib.clone()) {
-                self.note_failure(&e, true);
-                return None;
+        if !sources.iter().all(parses) {
+            return None;
+        }
+        self.build_parsed_session(sources)
+    }
+
+    /// [`Self::build_session`] for the completion tier, where one unit's
+    /// syntax errors must not take the rest of the workspace down with
+    /// them: a unit that does not parse joins salvaged — a missing `;`
+    /// written, the other members in error blanked, the braces they
+    /// leave open closed (see [`crate::salvage`]) — or, when it cannot
+    /// be salvaged, stays out.
+    /// Its errors still reach the client through the syntax tier.
+    /// Navigation that plans over references keeps the strict build — a
+    /// rename planned over a salvaged unit would miss the references the
+    /// salvage blanked; read-only navigation falls back to a salvaged
+    /// session of its own (see [`Self::read_session`]).
+    fn build_tolerant_session(&mut self, sources: Vec<(String, String)>) -> Option<Session> {
+        let sources = self.salvage.salvage_all(sources);
+        self.build_parsed_session(sources)
+    }
+
+    /// A session over `sources`, every one of which parses, built in one
+    /// pass with the configured library — resolving the units, then
+    /// loading the library into the session, would resolve them twice.
+    fn build_parsed_session(&mut self, sources: Vec<(String, String)>) -> Option<Session> {
+        #[cfg(test)]
+        SESSION_BUILDS.with(|n| n.set(n.get() + 1));
+        // The outcomes the most recent session settled on: the units this
+        // one shares with it start from them.
+        let settled = self
+            .built_by_recency()
+            .first()
+            .and_then(|&kind| self.built(kind))
+            .and_then(|(session, _)| session.settled_outcomes());
+        match Session::from_sources_settled(sources, self.library.clone(), settled) {
+            Ok(session) => Some(session),
+            Err(e) => {
+                // With every unit parsing, what refuses the session is the
+                // library — or a blank unit name.
+                let library = !matches!(
+                    e,
+                    SessionError::Parse { .. } | SessionError::InvalidUnitName(_)
+                );
+                self.note_failure(&e, library);
+                None
             }
         }
-        Some(session)
     }
 
     /// Record a session failure for the client, unless it is a unit
@@ -447,22 +1090,243 @@ impl Nav {
         std::mem::take(&mut self.reports)
     }
 
+    /// The kinds of session built, the most recent first.
+    fn built_by_recency(&self) -> Vec<Built> {
+        let mut kinds: Vec<(u64, Built)> = Built::ALL
+            .into_iter()
+            .filter_map(|kind| Some((self.built(kind)?.1, kind)))
+            .collect();
+        kinds.sort_by_key(|&(build, _)| std::cmp::Reverse(build));
+        kinds.into_iter().map(|(_, kind)| kind).collect()
+    }
+
+    /// The session of `kind` built, if one is, and its build.
+    fn built(&self, kind: Built) -> Option<(&Session, u64)> {
+        match kind {
+            Built::Navigation => Some((self.session.as_ref()?, self.session_build)),
+            Built::Tolerant => {
+                let t = self.tolerant.as_ref()?;
+                Some((t.session.as_ref()?, t.build))
+            }
+            Built::Completion => {
+                Some((&self.completion_session.as_ref()?.1, self.completion_build))
+            }
+        }
+    }
+
+    /// [`Self::built`]'s session to read, with the sources it was built
+    /// from as they were read — read-only navigation's tolerant one's as
+    /// written, before salvage; the completion tier's with its statement
+    /// cut out.
+    fn built_mut(&mut self, kind: Built) -> Option<(&mut Session, &[(String, String)])> {
+        match kind {
+            Built::Navigation => Some((self.session.as_mut()?, &self.session_sources)),
+            Built::Tolerant => {
+                let t = self.tolerant.as_mut()?;
+                Some((t.session.as_mut()?, &t.written))
+            }
+            Built::Completion => Some((
+                &mut self.completion_session.as_mut()?.1,
+                &self.completion_sources,
+            )),
+        }
+    }
+
+    /// The answer `read` gives for the statement being typed in `uri` —
+    /// it starts at `stmt_start`, the cursor at `cursor` — in a model the
+    /// statement is cut out of (see [`crate::salvage::typed_statement_cut`]
+    /// and [`Self::cut_answer`]).
+    fn statement_answer<T>(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        stmt_start: u32,
+        cursor: u32,
+        read: impl FnMut(&mut Read<'_>) -> Option<T>,
+    ) -> Option<T> {
+        let cut = crate::salvage::typed_statement_cut(&docs.get(uri)?.text, stmt_start, cursor);
+        self.cut_answer(docs, uri, cut, read)
+    }
+
+    /// The answer `read` gives in a model of the workspace with `cut`
+    /// taken out of `uri` (see [`Self::completion_session`]): off the
+    /// completion session built from exactly those texts, else off the
+    /// most recent session built, of either kind, whose texts differ from
+    /// them only where the answer does not look (see [`crate::reuse`]) —
+    /// so the next statement builds nothing where what it reads is as it
+    /// was — else off a completion session built for them now. `None`
+    /// when no session can be built or `read` answers nothing.
+    fn cut_answer<T>(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cut: Span,
+        mut read: impl FnMut(&mut Read<'_>) -> Option<T>,
+    ) -> Option<T> {
+        let (sources, key) = self.cut_sources(docs, uri, cut);
+        if self.completion_session.as_ref().map(|(k, _)| *k) != Some(key) {
+            if self.completion_failed == Some(key) {
+                return None;
+            }
+            let mut fresh = None;
+            if let Some(answer) =
+                self.reused_answer(uri, cut, (&sources, key), &mut fresh, &mut read)
+            {
+                return Some(answer);
+            }
+            let fresh = fresh.unwrap_or_else(|| self.salvage.salvage_all(sources.clone()));
+            let Some(session) = self.build_parsed_session(fresh) else {
+                self.completion_failed = Some(key);
+                return None;
+            };
+            self.completion_session = Some((key, session));
+            self.completion_sources = sources;
+            self.builds += 1;
+            self.completion_build = self.builds;
+        }
+        let (_, session) = self.completion_session.as_mut()?;
+        let unit = Self::unit_of_static(uri, session)?;
+        read(&mut Read {
+            session,
+            unit,
+            at: cut.start,
+            needs: crate::reuse::Needs::default(),
+            library_units: &mut self.library_units,
+            build: self.completion_build,
+        })
+    }
+
+    /// [`Self::cut_answer`] off a session built from other texts than
+    /// `sources` (keyed `key`), the most recent first, when what the
+    /// answer read there is unchanged in them (see
+    /// [`crate::reuse::Changes::allow`]). `fresh` holds the texts a build
+    /// for the statement would read once they are worked out.
+    fn reused_answer<T>(
+        &mut self,
+        uri: &Uri,
+        cut: Span,
+        (sources, key): (&[(String, String)], u64),
+        fresh: &mut Option<Vec<(String, String)>>,
+        read: &mut impl FnMut(&mut Read<'_>) -> Option<T>,
+    ) -> Option<T> {
+        let name = uri.to_string();
+        for kind in self.built_by_recency() {
+            let Some((_, build)) = self.built(kind) else {
+                continue;
+            };
+            // Worked out once per statement and session.
+            let known = self
+                .reused
+                .iter()
+                .find(|m| m.0 == (key, cut.start) && m.1 == build)
+                .map(|(_, _, changes)| changes.clone());
+            let changes = match known {
+                Some(changes) => changes,
+                None => {
+                    if fresh.is_none() {
+                        *fresh = Some(self.salvage.salvage_all(sources.to_vec()));
+                    }
+                    let (built, _) = self.built(kind)?;
+                    let changes = crate::reuse::Changes::between(
+                        built.units().map(|(_, n, t)| (n, t)),
+                        fresh.as_deref()?,
+                        &name,
+                        cut.start,
+                    )
+                    .map(Arc::new);
+                    self.reused
+                        .insert(0, ((key, cut.start), build, changes.clone()));
+                    self.reused.truncate(REUSED);
+                    changes
+                }
+            };
+            let Some(changes) = changes else {
+                continue;
+            };
+            let imports = match self.reused_imports.iter().find(|(b, _)| *b == build) {
+                Some((_, imports)) => Arc::clone(imports),
+                None => {
+                    let (session, _) = self.built_mut(kind)?;
+                    let imports = Arc::new(crate::reuse::Imports::of(session));
+                    self.reused_imports.insert(0, (build, Arc::clone(&imports)));
+                    self.reused_imports.truncate(Built::ALL.len());
+                    imports
+                }
+            };
+            let mut library_units = self.library_units.take();
+            let answer = self.built_mut(kind).and_then(|(session, _)| {
+                let unit = Self::unit_of_static(uri, session)?;
+                let mut at = Read {
+                    session,
+                    unit,
+                    at: changes.at,
+                    needs: crate::reuse::Needs::default(),
+                    library_units: &mut library_units,
+                    build,
+                };
+                let answer = read(&mut at);
+                let Read { session, needs, .. } = at;
+                answer.filter(|_| changes.allow(session, &needs, &imports))
+            });
+            self.library_units = library_units;
+            if answer.is_some() {
+                #[cfg(test)]
+                REUSED_ANSWERS.with(|n| n.set(n.get() + 1));
+                return answer;
+            }
+        }
+        None
+    }
+
     /// The completion tier's session: [`Self::assemble_sources`] with
-    /// `cut` (the statement being typed, in `uri`) removed outright —
+    /// `cut` (the statement being typed, in `uri`; see
+    /// [`crate::salvage::typed_statement_cut`]) removed outright —
     /// a mid-statement cursor nearly always means a parse error, which
     /// sessions refuse, and the statement itself contributes nothing a
     /// member listing needs. The reduced text is identical for every
     /// keystroke inside the statement, so the cache (keyed by a hash
     /// of the reduced sources) rebuilds only when something *outside*
-    /// the statement changes. Position queries against this session
-    /// must use offsets at or before `cut.start` — later spans shifted.
-    /// `None` when the rest of the workspace does not parse either.
+    /// the statement changes. Syntax errors elsewhere — in this document
+    /// or any other unit — are salvaged around
+    /// ([`Self::build_tolerant_session`]), which moves no offset.
+    /// Position queries against this session must use offsets at or
+    /// before `cut.start` — later spans shifted. A document that cannot
+    /// be salvaged is not in the session at all. A build that fails —
+    /// the library's, above all — is not tried again until the sources
+    /// change: every keystroke would parse them all again for nothing.
     fn completion_session(
         &mut self,
         docs: &BTreeMap<Uri, Document>,
         uri: &Uri,
         cut: Span,
     ) -> Option<&mut Session> {
+        let (sources, key) = self.cut_sources(docs, uri, cut);
+        if self.completion_session.as_ref().map(|(k, _)| *k) != Some(key) {
+            if self.completion_failed == Some(key) {
+                return None;
+            }
+            let Some(session) = self.build_tolerant_session(sources.clone()) else {
+                self.completion_failed = Some(key);
+                return None;
+            };
+            self.completion_session = Some((key, session));
+            self.completion_sources = sources;
+            self.builds += 1;
+            self.completion_build = self.builds;
+            self.library_units = None;
+        }
+        self.completion_session.as_mut().map(|(_, s)| s)
+    }
+
+    /// The sources a session for a statement in `uri` reads — every
+    /// unit, with `cut` taken out of `uri`'s text outright (see
+    /// [`Self::completion_session`]) — and the key they are kept under.
+    fn cut_sources(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cut: Span,
+    ) -> (Vec<(String, String)>, u64) {
         use std::hash::{Hash, Hasher};
         let mut fp: Vec<(String, i32)> = docs
             .iter()
@@ -485,12 +1349,7 @@ impl Nav {
             n.hash(&mut hasher);
             text.hash(&mut hasher);
         }
-        let key = hasher.finish();
-        if self.completion_session.as_ref().map(|(k, _)| *k) != Some(key) {
-            let session = self.build_session(sources)?;
-            self.completion_session = Some((key, session));
-        }
-        self.completion_session.as_mut().map(|(_, s)| s)
+        (sources, hasher.finish())
     }
 
     /// The element under `offset` in `uri`: a reference site's target
@@ -523,11 +1382,45 @@ impl Nav {
         offset: u32,
         enc: Encoding,
     ) -> Option<Location> {
-        let session = self.session(docs)?;
-        let unit = Self::unit_of_static(uri, session)?;
-        let (target, _) = Self::element_at(session, unit, offset)?;
-        let (dunit, dspan) = session.resolved().declaration_site(target)?;
-        Self::location_static(session, dunit, dspan, enc)
+        let read = self.read_session(docs)?;
+        let unit = Self::unit_of_static(uri, read.session)?;
+        let (target, _) = Self::element_at(read.session, unit, offset)?;
+        let (dunit, dspan) = read.session.resolved().declaration_site(target)?;
+        read.location(dunit, dspan, enc)
+    }
+
+    /// document highlights: where the element under the cursor is
+    /// declared and referenced in `uri` — off the read-only session, so
+    /// they hold while a unit does not parse (see [`Self::read_session`]).
+    pub fn highlights(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        offset: u32,
+        enc: Encoding,
+    ) -> Option<Vec<lsp_types::DocumentHighlight>> {
+        let read = self.read_session(docs)?;
+        let unit = Self::unit_of_static(uri, read.session)?;
+        let (target, _) = Self::element_at(read.session, unit, offset)?;
+        let resolved = read.session.resolved();
+        let spans: Vec<Span> = resolved
+            .declaration_site(target)
+            .filter(|(u, _)| *u == unit)
+            .map(|(_, span)| span)
+            .into_iter()
+            .chain(
+                resolved
+                    .references_to(target)
+                    .into_iter()
+                    .filter(|s| s.unit == unit)
+                    .map(|s| s.name_span),
+            )
+            .collect();
+        let locations = spans
+            .into_iter()
+            .filter_map(|span| read.location(unit, span, enc))
+            .collect();
+        Some(highlights_in(locations, uri))
     }
 
     /// references (find-usages): every site resolving to the element
@@ -652,7 +1545,8 @@ impl Nav {
         offset: u32,
         enc: Encoding,
     ) -> Option<(String, Range)> {
-        let session = self.session(docs)?;
+        let read = self.read_session(docs)?;
+        let session = &mut *read.session;
         let unit = Self::unit_of_static(uri, session)?;
         let (target, site) = Self::element_at(session, unit, offset)?;
         let resolved = session.resolved();
@@ -666,13 +1560,18 @@ impl Nav {
         // with a signature the way a function hover does: a fenced
         // block (editor font), parameter names with their types (`in`
         // implied, `out`/`inout` spelled), and the return type after
-        // `→`. Types render exactly as the declaration spells them
-        // (`:>` subsetting included), so the reader sees the author's
-        // qualification. The fence is tagged `sysml-signature` — the
-        // notation is not SysML source, so clients colorize it with a
-        // dedicated signature grammar (plain monospace where none is
-        // registered).
-        let parts = def_signature(resolved, target, metaclass);
+        // `→`. Types render as the declaration spells them (a subsetted
+        // feature standing in for a type not written: `in a :> isp`),
+        // so the reader sees the author's qualification; parameters
+        // inherited come after the callable's own (see
+        // [`crate::receiver::parameters`]); a library callable's types,
+        // whose text the session does not carry, are spelled from the
+        // model the shortest way that resolves here (see [`SigTypes`]).
+        // The fence is tagged `sysml-signature` — the notation is not
+        // SysML source, so clients colorize it with a dedicated
+        // signature grammar (plain monospace where none is registered).
+        let at = SigAt::in_unit(resolved, unit, offset, crate::dialect_of(uri));
+        let parts = def_signature(resolved, target, metaclass, &at);
         // Slicing the spelled types needs the unit texts — the resolved
         // borrow ends here and is re-acquired after.
         let sig = parts.map(|p| render_signature(p, session));
@@ -799,9 +1698,99 @@ impl Nav {
                 .filter(|(u, _)| *u == unit)
                 .map(|(_, s)| s)
         })?;
-        let (_, _, src) = session.units().find(|(i, _, _)| *i == unit)?;
-        let mapper = Mapper::new(src, enc);
-        Some((text, mapper.range(span)))
+        let range = ReadSession {
+            session,
+            written: read.written,
+        }
+        .location(unit, span, enc)?
+        .range;
+        Some((text, range))
+    }
+
+    /// The signature of what `callee` — a name, or a feature chain's
+    /// step on its receiver (`vehicle.ke`) — invoked in the statement
+    /// being typed (`cut`, see [`crate::salvage::typed_statement_cut`])
+    /// in `uri`, calls — the hover card's signature line, with where each
+    /// parameter sits in it — and the callable's documentation, else
+    /// the nearest its written heritage carries (see
+    /// [`crate::receiver::nearest_in_heritage`]). The callee resolves as
+    /// the evaluator resolves an invocation's target (see
+    /// [`crate::receiver::receiver_element`]), in a model with the
+    /// statement cut out (see [`Self::cut_answer`]); its parameters
+    /// include those it inherits (`calc c : F;`, `calc def G :> F;`, see
+    /// [`crate::receiver::parameters`]), and a feature typed by a
+    /// function answers with the function's, under its own name. `None`
+    /// when the callee does not resolve, or not to something an
+    /// invocation can call.
+    pub(crate) fn invocation_signature(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cut: Span,
+        callee: &sysmlv2_parser::ast::Expr,
+    ) -> Option<(SignatureLine, Option<String>)> {
+        self.cut_answer(docs, uri, cut, |at| {
+            let resolved = at.session.resolved();
+            let enclosing = crate::receiver::enclosing_declarations(resolved, at.unit, at.at);
+            at.needs.scopes(&enclosing);
+            at.needs.expr(callee);
+            let mut reached = Vec::new();
+            let target =
+                crate::receiver::receiver_reached(resolved, &enclosing, callee, &mut reached)?;
+            reached.into_iter().for_each(|e| at.needs.read(e));
+            let sig_at = SigAt::in_unit(resolved, at.unit, at.at, crate::dialect_of(uri));
+            let (source, mut parts) = std::iter::once(target)
+                .chain(resolved.typings(target))
+                .find_map(|e| {
+                    def_signature(resolved, e, resolved.element_type(e), &sig_at).map(|p| (e, p))
+                })?;
+            at.needs.read(source);
+            // A type spelled from the model is spelled the shortest way
+            // that resolves where the signature is read: by the names of
+            // its owners, or under `ISQ` — the types of the parameters
+            // shown, inherited ones included (declared in the general
+            // types read with the source), and of the result, each with
+            // what it redefines: one redefining without a type is spelled
+            // with the type of what it redefines (see [`spelled_types`]).
+            at.needs.name("ISQ");
+            let parameters: Vec<ElementRef> = crate::receiver::parameters(resolved, source)
+                .into_iter()
+                .map(|(p, _)| p)
+                .chain(crate::receiver::result_parameter(resolved, source))
+                .collect();
+            let mut seen = std::collections::HashSet::new();
+            let mut chain = parameters;
+            while let Some(p) = chain.pop() {
+                if !seen.insert(p) {
+                    continue;
+                }
+                chain.extend(resolved.redefinition_targets(p));
+                for t in resolved.explicit_supertypes(p) {
+                    let mut owner = Some(t);
+                    while let Some(e) = owner {
+                        if let Some(name) = resolved.element_name(e) {
+                            at.needs.name(name);
+                        }
+                        owner = resolved.owner(e);
+                    }
+                }
+            }
+            if source != target {
+                if let Some(own) = crate::receiver::feature_name(resolved, target) {
+                    parts.name = own;
+                }
+            }
+            let doc = crate::receiver::nearest_in_heritage(resolved, target, |resolved, e| {
+                let bodies: Vec<String> = resolved
+                    .element_docs(e)
+                    .into_iter()
+                    .map(|(_, b)| doc_markdown(&b))
+                    .filter(|b| !b.is_empty())
+                    .collect();
+                (!bodies.is_empty()).then(|| bodies.join("\n\n"))
+            });
+            Some((signature_line(parts, at.session), doc))
+        })
     }
 
     /// rename: through the Session edit engine (declaration + every
@@ -1423,30 +2412,55 @@ impl Nav {
         }
     }
 
+    /// The standard library's qualified symbols ([`Self::library_table_ref`]).
+    fn library_symbols(&mut self) -> &[QualifiedSymbol] {
+        self.library_table_ref().symbols()
+    }
+
     /// The standard library's qualified symbol table, built once per Nav
     /// from a syntax-tier parse of the library texts. Model-free by
     /// design: structure is syntactic, and this must not add a
     /// per-keystroke model build.
-    fn library_symbols(&mut self) -> &[QualifiedSymbol] {
+    fn library_table_ref(&mut self) -> &SymbolTable {
         if self.library_symbols.is_none() {
             let mut symbols: Vec<QualifiedSymbol> = Vec::new();
+            let mut links = Links::default();
             if let Some(lib) = &self.library {
                 for (name, text) in Self::library_sources(lib) {
-                    let parse = if crate::is_kerml(name.as_str()) {
-                        sysmlv2_parser::parser::parse_kerml_source(&text)
-                    } else {
-                        sysmlv2_parser::parser::parse_source(&text)
-                    };
-                    let mapper = Mapper::new(&text, Encoding::Utf8);
-                    let roots = crate::document_symbols(&parse.unit, &text, &mapper);
-                    let bodies = crate::outline::doc_bodies(&parse.unit, &mapper);
-                    let shorts = crate::outline::short_names(&parse.unit, &mapper);
-                    collect_qualified(&roots, "", 0, true, None, &bodies, &shorts, &mut symbols);
+                    let kerml = crate::is_kerml(name.as_str());
+                    collect_unit(&text, kerml, None, Encoding::Utf8, &mut symbols, &mut links);
                 }
             }
-            self.library_symbols = Some(symbols);
+            let table = SymbolTable::new(symbols, links, None);
+            // The library's measurement-unit type, and the definitions
+            // specializing it — aliases of them too, as the table takes
+            // them.
+            let root = table
+                .symbols()
+                .iter()
+                .find(|s| {
+                    s.qualified == "MeasurementReferences::MeasurementUnit"
+                        && matches!(s.decl, crate::kinds::Decl::Definition(_))
+                })
+                .map(|s| s.name.as_str());
+            self.library_unit_types = crate::kinds::unit_types(
+                root,
+                &std::collections::HashSet::new(),
+                definitions(table.symbols()),
+            );
+            self.library_symbols = Some(Arc::new(table));
         }
-        self.library_symbols.as_deref().unwrap_or(&[])
+        self.library_symbols.as_deref().expect("built above")
+    }
+
+    /// [`Self::library_symbols`]' table, shared.
+    fn library_table(&mut self) -> Arc<SymbolTable> {
+        self.library_table_ref();
+        Arc::clone(
+            self.library_symbols
+                .as_ref()
+                .expect("built by library_symbols"),
+        )
     }
 
     /// Workspace symbols across BOTH tiers: fresh parses of the open
@@ -1454,49 +2468,78 @@ impl Nav {
     /// is not open (an open document's live text shadows its seed
     /// copy). Everything that offers or auto-inserts an import must use
     /// this — the open-documents map alone hides most of the workspace.
+    ///
+    /// Layered for the request's document `uri`: that document's
+    /// symbols, over the rest of the workspace, over the library. The
+    /// rest is kept between requests while no other document changes,
+    /// so typing in one document neither re-parses the others nor
+    /// forgets what their namespaces make visible. A re-exporting import
+    /// elsewhere that resolves only with `uri` taken into account has
+    /// the whole workspace built as one layer instead.
     fn all_workspace_symbols(
         &mut self,
         docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
         enc: Encoding,
-    ) -> Vec<QualifiedSymbol> {
-        let mut out = workspace_symbols(docs, enc);
+    ) -> SymbolTable {
+        let library = self.library_table();
         if self.workspace_seed_symbols.is_none() {
             if let Some(units) = &self.workspace {
-                let mut symbols: Vec<QualifiedSymbol> = Vec::new();
+                let mut seed: Vec<QualifiedSymbol> = Vec::new();
+                let mut seed_links = Links::default();
                 for (name, text) in units.iter() {
-                    let parse = if crate::is_kerml(name) {
-                        sysmlv2_parser::parser::parse_kerml_source(text)
-                    } else {
-                        sysmlv2_parser::parser::parse_source(text)
-                    };
-                    let mapper = Mapper::new(text, enc);
-                    let roots = crate::document_symbols(&parse.unit, text, &mapper);
-                    let bodies = crate::outline::doc_bodies(&parse.unit, &mapper);
-                    let shorts = crate::outline::short_names(&parse.unit, &mapper);
-                    collect_qualified(
-                        &roots,
-                        "",
-                        0,
-                        true,
-                        Some(name.as_str()),
-                        &bodies,
-                        &shorts,
-                        &mut symbols,
-                    );
+                    let kerml = crate::is_kerml(name);
+                    collect_unit(text, kerml, Some(name), enc, &mut seed, &mut seed_links);
                 }
-                self.workspace_seed_symbols = Some(symbols);
+                self.workspace_seed_symbols = Some((seed, seed_links));
             }
         }
-        if let Some(seed) = &self.workspace_seed_symbols {
-            let open: std::collections::HashSet<String> =
-                docs.keys().map(|u| u.to_string()).collect();
-            out.extend(
-                seed.iter()
-                    .filter(|s| s.site.as_ref().is_none_or(|(u, _)| !open.contains(u)))
-                    .cloned(),
-            );
+        let current = uri.to_string();
+        let key = RestKey {
+            others: docs
+                .iter()
+                .map(|(u, d)| (u.to_string(), Arc::clone(&d.text)))
+                .filter(|(u, _)| *u != current)
+                .collect(),
+            current,
+        };
+        let current = &key.current;
+        let rest = match &self.workspace_rest {
+            Some((known, rest)) if known.same(&key) => Arc::clone(rest),
+            _ => {
+                let (mut symbols, mut links) =
+                    workspace_symbols(docs.iter().filter(|(u, _)| u.to_string() != *current), enc);
+                if let Some((seed, seed_links)) = &self.workspace_seed_symbols {
+                    let open: std::collections::HashSet<String> =
+                        docs.keys().map(|u| u.to_string()).collect();
+                    symbols.extend(
+                        seed.iter()
+                            .filter(|s| s.site.as_ref().is_none_or(|(u, _)| !open.contains(u)))
+                            .cloned(),
+                    );
+                    links.imports.extend(
+                        seed_links
+                            .imports
+                            .iter()
+                            .filter(|i| i.unit.as_ref().is_none_or(|u| !open.contains(u)))
+                            .cloned(),
+                    );
+                }
+                let rest = Arc::new(SymbolTable::new(symbols, links, Some(Arc::clone(&library))));
+                self.workspace_rest = Some((key, Arc::clone(&rest)));
+                rest
+            }
+        };
+        let (symbols, links) = workspace_symbols(docs.get_key_value(uri).into_iter(), enc);
+        let table = SymbolTable::new(symbols, links, Some(Arc::clone(&rest)));
+        if !rest.resolves_above(&table) {
+            return table;
         }
-        out
+        let (mut symbols, mut links) = table.parts();
+        let (rest_symbols, rest_links) = rest.parts();
+        symbols.extend(rest_symbols);
+        links.imports.extend(rest_links.imports);
+        SymbolTable::new(symbols, links, Some(library))
     }
 
     /// "Optimize imports": every provably-unused private import in
@@ -1742,14 +2785,15 @@ impl Nav {
         if crate::autoimport::within_import(&parse.unit.members, offset) {
             return;
         }
+        let ws = self.all_workspace_symbols(docs, uri, enc);
         let auto = crate::autoimport::AutoImport::new(
             text,
             &parse.unit,
             offset,
             Span::new(offset, offset + token_len),
-        );
+        )
+        .with_reexports(&ws);
         let mapper = Mapper::new(text, enc);
-        let ws = self.all_workspace_symbols(docs, enc);
         let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
         for s in ws.iter().chain(self.library_symbols()) {
             if out.len() >= 5 {
@@ -1759,14 +2803,16 @@ impl Nav {
             {
                 continue;
             }
-            let Some((at, new_text)) = auto.import_edit(&s.name, &s.qualified) else {
+            let Some(Some(edit)) = reach(&auto, s) else {
                 continue;
             };
+            let title = format!(
+                "Add import {}",
+                edit.spelled(crate::dialect_of(uri), &s.qualified)
+            );
+            let (at, new_text) = (edit.at, edit.text);
             out.push((
-                format!(
-                    "Add import {}",
-                    crate::autoimport::escape_qualified(crate::dialect_of(uri), &s.qualified)
-                ),
+                title,
                 uri.clone(),
                 TextEdit {
                     range: mapper.range(Span::new(at, at)),
@@ -1784,83 +2830,105 @@ impl Nav {
     /// quantity type, accepting the completion also inserts a
     /// `: <Type>` typing after the attribute's name — spelled as the
     /// shortest reference that resolves at the declaration's scope.
-    /// `meta` pairs each item index with the symbol's (name,
-    /// qualified) it was built from.
+    /// `meta` holds what each item was built from (see [`Offered`]).
     fn append_unit_type_edits(
         &mut self,
         docs: &BTreeMap<Uri, Document>,
         uri: &Uri,
         enc: Encoding,
         (cx, tcx): (&CompletionCx, &UnitTypeCx),
-        meta: &[(usize, String, String)],
+        meta: &[Offered],
         out: &mut [lsp_types::CompletionItem],
     ) {
         let Some(doc) = docs.get(uri) else { return };
         let text = &doc.text;
-        let at_cursor = (cx.offset as usize).min(text.len());
-        let line_end = text[at_cursor..]
+        let replacement = crate::accept::Replacement::new(text, cx);
+        let after = (replacement.end() as usize).min(text.len());
+        let line_end = text[after..]
             .find('\n')
-            .map(|i| at_cursor + i)
+            .map(|i| after + i)
             .unwrap_or(text.len());
-        // Anything after the cursor other than the closing bracket
-        // means the accepted name is only a factor of a larger unit
-        // expression — its type says nothing about the whole.
-        let rest = text[at_cursor..line_end].trim_start();
-        if !(rest.is_empty() || rest.starts_with(']')) {
+        // Anything after the accepted name other than the closing
+        // bracket — or the end of the line or of the statement, where the
+        // accept writes that bracket behind the name — means it is only a
+        // factor of a larger unit expression: its type says nothing
+        // about the whole. The accept writes the bracket only where
+        // nothing but blanks follows the statement's `;` on the line (see
+        // [`crate::autofix::statement_repairs`]); before a `}` or a
+        // comment there the bracket stays open, and a typing would
+        // declare the type of a value that does not parse.
+        let rest = text[after..line_end].trim_start();
+        let closed = rest.is_empty()
+            || rest.starts_with(']')
+            || rest
+                .strip_prefix(';')
+                .is_some_and(|tail| tail.trim().is_empty());
+        if !closed {
             return;
         }
         let mapper = Mapper::new(text, enc);
         let insert_at = mapper.range(Span::new(tcx.name_end, tcx.name_end));
-        let Some(session) =
-            self.completion_session(docs, uri, Span::new(cx.stmt_start, offset32(line_end)))
-        else {
-            return;
-        };
-        let Some(unit) = Self::unit_of_static(uri, session) else {
-            return;
-        };
-        let resolved = session.resolved();
-        // The declaration's resolution scope: the innermost enclosing
-        // declaration's body, the root namespace as the fallback.
-        let at = cx.stmt_start;
-        let mut enclosing: Vec<(ElementRef, u32)> = resolved
-            .user_elements()
-            .filter_map(|e| {
-                let (u, span) = resolved.member_extent(e)?;
-                (u == unit && span.start <= at && at <= span.end).then(|| (e, span.len()))
-            })
-            .collect();
-        enclosing.sort_by_key(|&(_, len)| len);
-        let scope = enclosing
-            .iter()
-            .find_map(|&(e, _)| resolved.element_scope(e))
-            .unwrap_or_else(|| resolved.root_scope());
-        for (idx, name, qualified) in meta {
-            let range =
-                crate::autoimport::replace_range_for(text, cx.partial_start, cx.offset, name);
-            let interior = text
-                .get(tcx.bracket_open as usize + 1..range.start as usize)
-                .map(str::trim);
-            if interior != Some("") {
-                continue;
-            }
-            let Some(elem) = resolved.resolve_qualified(qualified) else {
-                continue;
-            };
-            let mut types: Vec<ElementRef> = Vec::new();
-            for def in resolved.typings(elem) {
-                for t in resolved.quantity_types_for_unit_def(def) {
-                    if !types.contains(&t) {
-                        types.push(t);
+        let cut = crate::salvage::typed_statement_cut(text, cx.stmt_start, cx.offset);
+        let dialect = crate::dialect_of(uri);
+        let spellings = self.cut_answer(docs, uri, cut, |at| {
+            let unit_of: HashMap<String, usize> = at
+                .session
+                .units()
+                .map(|(i, name, _)| (name.to_string(), i))
+                .collect();
+            let resolved = at.session.resolved();
+            let enclosing = crate::receiver::enclosing_declarations(resolved, at.unit, at.at);
+            at.needs.scopes(&enclosing);
+            // The declaration's resolution scope: the innermost enclosing
+            // declaration's body, the root namespace as the fallback.
+            let scope = enclosing
+                .iter()
+                .find_map(|&e| resolved.element_scope(e))
+                .unwrap_or_else(|| resolved.root_scope());
+            let mut spellings = Vec::new();
+            let mut tops = None;
+            for (idx, name, qualified, site) in meta {
+                let start = replacement.start_for(text, name);
+                let interior = text
+                    .get(tcx.bracket_open as usize + 1..start as usize)
+                    .map(str::trim);
+                if interior != Some("") {
+                    continue;
+                }
+                let site = site.as_deref();
+                let Some(elem) = declared_element(resolved, qualified, site, &unit_of, &mut tops)
+                else {
+                    continue;
+                };
+                at.needs.read(elem);
+                let mut types: Vec<ElementRef> = Vec::new();
+                for def in resolved.typings(elem) {
+                    for t in resolved.quantity_types_for_unit_def(def) {
+                        if !types.contains(&t) {
+                            types.push(t);
+                        }
+                    }
+                }
+                let [target] = types[..] else { continue };
+                // The spellings tried: the type's name under each of its
+                // owners', and under `ISQ`.
+                at.needs.read(target);
+                at.needs.name("ISQ");
+                let mut owner = Some(target);
+                while let Some(e) = owner {
+                    if let Some(name) = resolved.element_name(e) {
+                        at.needs.name(name);
                     }
+                    owner = resolved.owner(e);
+                }
+                if let Some(spelling) = resolved.type_spelling_at(Some(dialect), scope, target) {
+                    spellings.push((*idx, spelling));
                 }
             }
-            let [target] = types[..] else { continue };
-            let dialect = Some(crate::dialect_of(uri));
-            let Some(spelling) = resolved.type_spelling_at(dialect, scope, target) else {
-                continue;
-            };
-            out[*idx]
+            Some(spellings)
+        });
+        for (idx, spelling) in spellings.unwrap_or_default() {
+            out[idx]
                 .additional_text_edits
                 .get_or_insert_with(Vec::new)
                 .push(TextEdit {
@@ -1870,27 +2938,334 @@ impl Nav {
         }
     }
 
+    /// The features in scope at the statement being completed that a
+    /// position names besides the symbol tables' names (see
+    /// [`crate::site::Members`]): those the enclosing element inherits —
+    /// through its specializations and typings, and from the library
+    /// base every element of its kind implicitly specializes — and, for
+    /// [`crate::site::Members::Scope`], its own.
+    ///
+    /// The element's own body is read off the live text: its own
+    /// features are the ones it declares now, and a feature an earlier
+    /// statement redefines — explicitly, or by declaring the same name —
+    /// is no inherited member any longer. What it inherits depends on
+    /// the text outside its body alone (see [`Self::inherited_members`]).
+    /// Empty when the statement sits in no declaration.
+    fn scope_members(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cx: &CompletionCx,
+        members: crate::site::Members,
+    ) -> Vec<ScopeMember> {
+        use crate::site::Members;
+        if members == Members::None {
+            return Vec::new();
+        }
+        let Some(doc) = docs.get(uri) else {
+            return Vec::new();
+        };
+        let text = Arc::clone(&doc.text);
+        let parse = if crate::is_kerml(uri.path().as_str()) {
+            sysmlv2_parser::parser::parse_kerml_source(&text)
+        } else {
+            sysmlv2_parser::parser::parse_source(&text)
+        };
+        let (around, body) = crate::kinds::enclosing(&parse.unit, cx.stmt_start);
+        // At a unit's top level no type encloses the statement: nothing
+        // to name, and no session to build for it.
+        let Some(innermost) = around.last() else {
+            return Vec::new();
+        };
+        // A package inherits nothing.
+        let inherited = if innermost.decl == crate::kinds::Decl::Namespace {
+            Vec::new()
+        } else {
+            // The member the live text reads the statement in.
+            let statement = body
+                .iter()
+                .find(|m| m.span.start <= cx.stmt_start && cx.stmt_start < m.span.end)
+                .map(|m| m.span);
+            self.inherited_members(docs, uri, cx, &text, &around, statement)
+        };
+        let own = crate::kinds::body_features(body, cx.stmt_start);
+        let mut out = Vec::new();
+        if members == Members::Scope {
+            let path: Option<Vec<&str>> = around.iter().map(|e| e.name.as_deref()).collect();
+            let path = path.map(|p| p.join("::"));
+            for (name, decl) in &own {
+                // A redefinition declaring no kind of its own (`ref :>>
+                // start`) ranks, and shows, as the feature it redefines.
+                let redefined = inherited.iter().find(|m| m.name == *name);
+                use sysmlv2_parser::ast::UsageKind as U;
+                let kindless = matches!(
+                    decl,
+                    crate::kinds::Decl::Usage(U::Default | U::Ref | U::Feature)
+                );
+                let (decl, kind) = match redefined {
+                    Some(m) if kindless => (m.decl, m.kind),
+                    Some(m) => (*decl, m.kind),
+                    None => (*decl, lsp_types::CompletionItemKind::PROPERTY),
+                };
+                out.push(ScopeMember {
+                    qualified: path.as_ref().map(|p| format!("{p}::{name}")),
+                    name: name.clone(),
+                    decl,
+                    kind,
+                    library: false,
+                });
+            }
+        }
+        // What the live body redefines — explicitly, or by declaring the
+        // same name — is no inherited member any longer.
+        let mut redefined = crate::kinds::redefined_names(body, cx.stmt_start);
+        redefined.extend(own.into_iter().map(|(name, _)| name));
+        out.extend(
+            inherited
+                .into_iter()
+                .filter(|m| !redefined.contains(&m.name)),
+        );
+        out
+    }
+
+    /// What the innermost of the declarations `around` the statement
+    /// being completed in `uri` inherits (see [`Self::scope_members`]).
+    ///
+    /// That depends on the text outside the element's own body alone —
+    /// its header, its supertypes wherever they are declared — so the
+    /// answer is kept by that text: the other open documents', the
+    /// seeded units' no open document shadows, and this one's before and
+    /// after the body. Edits inside the body, session rebuilds, and a
+    /// re-seed changing only open documents' copies leave it; any edit
+    /// outside asks again. The units a workspace root's walk reads from
+    /// disk are not in the key: a change there, made outside the editor,
+    /// surfaces with the next edit elsewhere. It is
+    /// read off the most recent session already built — the completion
+    /// tier's or navigation's — whose text outside the body is the live
+    /// one, finding the element by the qualified name the live text
+    /// gives it (one with no name, or where the lookup fails, by where
+    /// it is declared), else off a completion session built for the
+    /// statement (see [`Self::completion_session`]), which salvages
+    /// syntax errors elsewhere. Empty when that does not build either.
+    fn inherited_members(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cx: &CompletionCx,
+        text: &str,
+        around: &[crate::kinds::Enclosing],
+        statement: Option<Span>,
+    ) -> Vec<ScopeMember> {
+        let Some(innermost) = around.last() else {
+            return Vec::new();
+        };
+        let (before, after) = outside_body(text, innermost.span);
+        let key = member_key(docs, uri, text, (before, after), around, &self.seed_hashes);
+        if let Some(i) = self.member_cache.iter().position(|(k, _)| *k == key) {
+            let entry = self.member_cache.remove(i);
+            let found = entry.1.clone();
+            self.member_cache.insert(0, entry);
+            return found;
+        }
+        let Some(found) = self.read_inherited(docs, uri, cx, around, statement, (before, after))
+        else {
+            return Vec::new();
+        };
+        self.member_cache.insert(0, (key, found.clone()));
+        self.member_cache.truncate(MEMBER_CACHE);
+        found
+    }
+
+    /// [`Self::inherited_members`] off a session: a built one whose text
+    /// outside the element's body — `before` and `after` bytes of this
+    /// document, every other unit whole — is the live one's, the most
+    /// recent first, else one built for the statement. The element is
+    /// the one the live text encloses the statement in (see
+    /// [`built_inherited`]).
+    fn read_inherited(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cx: &CompletionCx,
+        around: &[crate::kinds::Enclosing],
+        statement: Option<Span>,
+        (before, after): (usize, usize),
+    ) -> Option<Vec<ScopeMember>> {
+        let mut fp: Vec<(String, i32)> = docs
+            .iter()
+            .map(|(u, d)| (u.to_string(), d.version))
+            .collect();
+        fp.sort();
+        let now = self.assemble_sources(docs, &fp);
+        let name = uri.to_string();
+        // The text outside the body tells nothing of a statement salvaged
+        // into the body itself.
+        for kind in self
+            .built_by_recency()
+            .into_iter()
+            .filter(|kind| !kind.salvages_statements())
+        {
+            let Some((session, built)) = self.built_mut(kind) else {
+                continue;
+            };
+            if !outside_unchanged(built, &now, &name, before, after) {
+                continue;
+            }
+            let unit = Self::unit_of_static(uri, session);
+            if let Some(found) = built_inherited(session.resolved(), around, unit) {
+                return Some(found);
+            }
+        }
+        let typed =
+            crate::salvage::typed_statement_cut(&docs.get(uri)?.text, cx.stmt_start, cx.offset);
+        // A build that fails is not tried again with another cut: what
+        // failed it is elsewhere.
+        let session = self.completion_session(docs, uri, typed)?;
+        if let Some(unit) = Self::unit_of_static(uri, session) {
+            if let Some(found) = built_inherited(session.resolved(), around, Some(unit)) {
+                return Some(found);
+            }
+        }
+        // Cut where its tokens end it, the statement can leave the rest of
+        // the document past salvaging, out of the model — a transition's
+        // `then` after the `}` of its `do` action reads as a statement of
+        // its own, and the transition is left without it — or the element
+        // out of it: then the member the live text reads the statement in
+        // goes whole, in a session of its own, for the statement's stays
+        // where the other tiers read it; and where that one names nothing
+        // either, it is not built again for the same text.
+        let member = statement.filter(|&s| s != typed)?;
+        let (sources, key) = self.cut_sources(docs, uri, member);
+        if self.member_cut_failed == Some(key) {
+            return None;
+        }
+        let found = self
+            .build_tolerant_session(sources)
+            .and_then(|mut session| {
+                let unit = Self::unit_of_static(uri, &session)?;
+                built_inherited(session.resolved(), around, Some(unit))
+            });
+        if found.is_none() {
+            self.member_cut_failed = Some(key);
+        }
+        found
+    }
+
     /// Completion. Position-aware where it matters:
+    /// - nothing inside a comment, a note, a documentation body, or a
+    ///   string literal, nor inside a number or at a range bound
+    ///   (`5.`, `[0..`) — not even when a trigger character opened the
+    ///   request;
+    /// - where the word being typed is a name the statement declares
+    ///   (`part def Boat`, `in item fuel`, an enumeration literal),
+    ///   only the keywords that may stand in its place (`part` →
+    ///   `def`), never an existing element's name;
+    /// - after a member-access dot (`tank.`, `wheels#(1).`, `f(x).`),
+    ///   only the members the receiver reaches — none when it does not
+    ///   resolve (see [`Self::chain_member_completions`]);
+    /// - inside a quantity's unit bracket (`5.5 [`), only units, those of
+    ///   the declared quantity first; inside any other bracket, a
+    ///   multiplicity above all, nothing until a name is typed (see
+    ///   [`Self::bracket_completions`]);
+    /// - elsewhere the position decides which keywords of the
+    ///   document's dialect and which kinds of element are offered, and
+    ///   ranks them (`sortText`): after `part p :` the part definitions,
+    ///   then the other structures, then namespaces; after `=` features,
+    ///   invocable definitions, and literal keywords, measurement units
+    ///   last — first where the statement's type is a unit type; at a
+    ///   statement's start the keywords its body takes (see
+    ///   [`crate::site`]); where it names the enclosing element's
+    ///   features — a redefinition, a succession, a usage's subsetting, a
+    ///   metadata body — those first: its body read off the live text,
+    ///   what it inherits off a model current outside that body (see
+    ///   [`Self::scope_members`]); within a group, shorter names first;
     /// - after a qualifier (`Foo::`), only the members of `Foo`
     ///   (workspace and library), matched by qualified-path suffix;
     /// - inside an `import` statement's path, symbols at any depth are
     ///   offered by simple name and accepting one inserts its full
     ///   qualified path over the typed partial word (a `textEdit`), so
     ///   the import actually resolves;
-    /// - everywhere else, the position-blind list: keyword
-    ///   vocabulary + workspace names + library packages and their
-    ///   direct members.
+    /// - a position the statement does not tell apart takes every
+    ///   keyword of the dialect, every workspace name, and the library's
+    ///   packages and their direct members.
+    ///
+    /// Multi-word library names — units and the like, see
+    /// [`QualifiedSymbol::is_multiword_library_name`] — are offered
+    /// only inside an open bracket, where a unit is written; never in
+    /// an import path. A qualifier (`Foo::`) still lists them.
+    ///
+    /// Operator functions (`'+'`, `'not'`, see
+    /// [`QualifiedSymbol::is_operator_function`]) are written as
+    /// operators, never by name: only a qualifier lists them.
+    ///
+    /// With the items comes whether the list is to be sent incomplete,
+    /// for the client to ask again as the user types: in a quantity's
+    /// unit bracket, a list read with a `]` right after the cursor
+    /// closing the bracket, since what its accepts write depends on that
+    /// `]` — the bracket's repair, whether a unit is the bracket's whole
+    /// content. Editors add the `]` with the `[`, and the user may delete
+    /// it and type on; a client refiltering the list it has would accept
+    /// an item read with the `]` still there.
     pub fn completions(
         &mut self,
         docs: &BTreeMap<Uri, Document>,
         uri: &Uri,
         offset: Option<u32>,
         enc: Encoding,
+    ) -> (Vec<lsp_types::CompletionItem>, bool) {
+        let dialect = crate::dialect_of(uri);
+        let cx = offset.and_then(|o| {
+            docs.get(uri)
+                .map(|d| completion_context(&d.text, o, dialect))
+        });
+        // Only a quantity's unit bracket: a name typed into a bound or a
+        // filter would ask again for the flat list — thousands of names —
+        // at every keystroke.
+        let incomplete = cx.as_ref().zip(docs.get(uri)).is_some_and(|(cx, d)| {
+            cx.in_bracket
+                && {
+                    let end = crate::accept::Replacement::new(&d.text, cx).end() as usize;
+                    d.text
+                        .get(end..)
+                        .is_some_and(|rest| rest.trim_start_matches([' ', '\t']).starts_with(']'))
+                }
+                && matches!(
+                    crate::units::bracket_at(&d.text, cx, dialect),
+                    Some(crate::units::Bracket::Unit { .. })
+                )
+        });
+        (self.completion_items(docs, uri, cx, enc), incomplete)
+    }
+
+    /// The items [`Self::completions`] offers with the cursor where `cx`
+    /// reads it.
+    fn completion_items(
+        &mut self,
+        docs: &BTreeMap<Uri, Document>,
+        uri: &Uri,
+        cx: Option<CompletionCx>,
+        enc: Encoding,
     ) -> Vec<lsp_types::CompletionItem> {
         use lsp_types::{CompletionItem, CompletionItemKind};
-        // Copied out: the symbol iterators below hold `self` borrows.
-        let snippets = self.snippet_completions;
-        let cx = offset.and_then(|o| docs.get(uri).map(|d| completion_context(&d.text, o)));
+        let dialect = crate::dialect_of(uri);
+        // What the position takes: the default list below offers only
+        // these keywords and names, in this order.
+        let open = crate::site::Want::open(dialect);
+        let want = match cx.as_ref().map(|cx| &cx.slot) {
+            Some(crate::site::Slot::Quiet) => return Vec::new(),
+            Some(crate::site::Slot::Declared(keywords)) => {
+                return keywords
+                    .iter()
+                    .map(|kw| CompletionItem {
+                        label: kw.to_string(),
+                        kind: Some(CompletionItemKind::KEYWORD),
+                        ..Default::default()
+                    })
+                    .collect();
+            }
+            Some(crate::site::Slot::Want(want)) => want,
+            Some(crate::site::Slot::Open) | None => &open,
+        };
         // Unit-typing context (see `append_unit_type_edits`), decided
         // once per request.
         let unit_type_cx = self
@@ -1914,46 +3289,168 @@ impl Nav {
         let is_phantom =
             |s: &QualifiedSymbol| partial_pos.is_some_and(|pos| s.declared_at(&uri_str, pos));
 
-        // Feature-chain context (`tank.` / `tank.liq`): the members the
-        // chain step could actually reach, from the semantic session. A
-        // prefix the session cannot resolve falls through to the
-        // position-blind list below.
-        if let Some(cx) = cx.as_ref().filter(|cx| !cx.dot_chain.is_empty()) {
-            if let Some(items) = self.chain_member_completions(docs, uri, cx, enc, snippets) {
-                return items;
-            }
+        // Member access (`tank.` / `tank.liq` / `wheels#(1).` / `f(x).`):
+        // the members the receiver could actually reach, from the
+        // semantic session — nothing when it reaches none.
+        if let Some(items) = cx
+            .as_ref()
+            .and_then(|cx| self.chain_member_completions(docs, uri, cx, enc))
+        {
+            return items;
         }
 
-        // Qualifier context: members of the qualified namespace only.
+        // Inside a `[`: a quantity's unit bracket lists units, the
+        // declared quantity's first; a multiplicity lists nothing.
+        if let Some(items) = cx
+            .as_ref()
+            .and_then(|cx| self.bracket_completions(docs, uri, cx, enc, unit_type_cx.as_ref()))
+        {
+            return items;
+        }
+
+        // Qualifier context: the members the qualified namespace makes
+        // visible — its own first, since they hide what an import
+        // brings in under the same name, then what its public imports
+        // bring in (`ISQ::` lists `MassValue`, which `ISQ` re-exports
+        // from `ISQBase`). A re-exported member carries no documentation
+        // here — a facade re-exports thousands, and each is documented
+        // where its own namespace lists it.
         if let Some(cx) = cx.as_ref().filter(|cx| !cx.qualifier.is_empty()) {
             let path = cx.qualifier.join("::");
-            let quoting = docs.get(uri).map(|d| (Mapper::new(&d.text, enc), &d.text));
+            let accept = docs.get(uri).map(|d| self.accept(&d.text, uri, cx, enc));
             let mut out: Vec<CompletionItem> = Vec::new();
-            let mut meta: Vec<(usize, String, String)> = Vec::new();
+            let mut meta: Vec<Offered> = Vec::new();
             let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
-            let ws = self.all_workspace_symbols(docs, enc);
-            for s in ws.iter().chain(self.library_symbols()) {
+            let ws = self.all_workspace_symbols(docs, uri, enc);
+            // An `import all` names the members whatever their visibility,
+            // and what every import of the namespace brings in.
+            let import_all = docs
+                .get(uri)
+                .is_some_and(|d| imports_all(&d.text, cx.partial_start));
+            // A private member only from inside its namespace, and a
+            // member of a private one only from inside the namespace
+            // owning that: the document is read for that only when one
+            // comes up.
+            let parsed = std::cell::OnceCell::new();
+            let inside = |ns: &str| {
+                let Some(doc) = docs.get(uri) else {
+                    return false;
+                };
+                let parse = parsed.get_or_init(|| {
+                    if crate::is_kerml(uri.path().as_str()) {
+                        sysmlv2_parser::parser::parse_kerml_source(&doc.text)
+                    } else {
+                        sysmlv2_parser::parser::parse_source(&doc.text)
+                    }
+                });
+                let partial = Span::new(cx.partial_start, cx.offset);
+                crate::autoimport::AutoImport::new(&doc.text, &parse.unit, cx.offset, partial)
+                    .inside(ns)
+            };
+            let visible = |s: &QualifiedSymbol| {
+                if s.enclosed().is_some_and(|ns| !inside(ns)) {
+                    return false;
+                }
+                if s.public || import_all {
+                    return true;
+                }
+                s.site.is_some() && s.parent().is_some_and(inside)
+            };
+            self.library_symbols();
+            let unit_types =
+                crate::kinds::unit_types(None, &self.library_unit_types, definitions(ws.iter()));
+            let unit_group = want.unit_group(&unit_types);
+            let owned = ws
+                .iter()
+                .chain(self.library_symbols())
+                .filter(|s| s.is_member_of(&path) && visible(s))
+                .map(|s| (s, true));
+            let access = if import_all {
+                Access::Inside
+            } else {
+                Access::Clients
+            };
+            let reexported = ws
+                .reexported_members(&path, access)
+                .into_iter()
+                .map(|s| (s, false));
+            // Ranked as names anywhere else, the position read off the
+            // text ahead of the qualified name: by its groups — measurement
+            // units by the statement's type at an operand — what it does
+            // not take after everything it does, then the workspace's
+            // ahead of the library's, then shorter labels first
+            // (`attribute x : ISQ::` puts `MassValue` among the first, its
+            // quantity features after every definition). A qualifier names
+            // the namespace: none of its members is left out.
+            let mut ranked: Vec<(u8, Option<&str>)> = Vec::new();
+            for (s, own) in owned.chain(reexported) {
                 if is_phantom(s) {
                     continue;
                 }
-                if s.is_member_of(&path) && seen.insert(s.name.clone()) {
-                    let (text_edit, repair, insert_text_format) = match &quoting {
-                        Some((mapper, text)) => {
-                            item_edits(text, mapper, cx, crate::dialect_of(uri), &s.name, snippets)
-                        }
-                        None => (None, None, None),
-                    };
-                    meta.push((out.len(), s.name.clone(), s.qualified.clone()));
-                    out.push(CompletionItem {
-                        label: crate::outline::spell_name(&s.name),
-                        kind: Some(s.kind),
-                        detail: Some(s.qualified.clone()),
-                        documentation: s.documentation(),
-                        text_edit,
-                        additional_text_edits: repair.map(|e| vec![e]),
-                        insert_text_format,
-                        ..Default::default()
+                let workspace = s.site.is_some();
+                let group = want
+                    .group(s.decl, workspace)
+                    .map_or(9, |group| match unit_group {
+                        Some(units) if s.is_unit(&unit_types) => units,
+                        _ => group,
                     });
+                if seen.insert(s.name.clone()) {
+                    let edits = accept.as_ref().map(|a| a.name(&s.name)).unwrap_or_default();
+                    meta.push(offered(out.len(), s));
+                    let source = if workspace { 0 } else { 2 };
+                    let label = crate::outline::spell_name(&s.name);
+                    ranked.push((group, s.long.as_deref()));
+                    out.push(edits.fill(
+                        CompletionItem {
+                            sort_text: Some(crate::site::sort_text(
+                                crate::site::name_key(group, source, want.tier(s.decl)),
+                                &label,
+                            )),
+                            label,
+                            kind: Some(s.kind),
+                            detail: Some(s.qualified.clone()),
+                            documentation: own.then(|| s.documentation()).flatten(),
+                            ..Default::default()
+                        },
+                        Vec::new(),
+                    ));
+                }
+            }
+            // Only the best group keeps the typed word's whole match of a
+            // label of one or two characters (see [`unmatched_whole`]).
+            if let Some(best) = ranked.iter().map(|&(group, _)| group).min() {
+                for (item, &(group, long)) in out.iter_mut().zip(&ranked) {
+                    if group > best && item.label.chars().count() <= 2 {
+                        item.filter_text = Some(unmatched_whole(
+                            item.filter_text.as_deref().unwrap_or(&item.label),
+                            long.unwrap_or(&item.label),
+                        ));
+                    }
+                }
+            }
+            // An import or expose path can name the members themselves:
+            // `*`, and `**` for everything below them.
+            let path_statement = docs
+                .get(uri)
+                .is_some_and(|d| in_import_path(&d.text, cx.partial_start));
+            if path_statement && !out.is_empty() {
+                for (wildcard, detail) in [
+                    ("*", format!("every member of {path}")),
+                    ("**", format!("every member of {path}, recursively")),
+                ] {
+                    let edits = accept
+                        .as_ref()
+                        .map(|a| a.spelled(wildcard, wildcard.to_string()))
+                        .unwrap_or_default();
+                    out.push(edits.fill(
+                        CompletionItem {
+                            label: wildcard.to_string(),
+                            kind: Some(CompletionItemKind::OPERATOR),
+                            detail: Some(detail),
+                            ..Default::default()
+                        },
+                        Vec::new(),
+                    ));
                 }
             }
             if let Some(tcx) = unit_type_cx.as_ref() {
@@ -1963,71 +3460,76 @@ impl Nav {
         }
 
         // Import context: everything importable, inserted as its full
-        // qualified path so the reference resolves from the root.
+        // qualified path so the reference resolves from the root — the
+        // path the symbol tables choose, which may run through a
+        // re-exporting package (`ISQ::MassValue`).
         if let (Some(cx), Some(doc)) = (cx.as_ref().filter(|cx| cx.import), docs.get(uri)) {
-            let mapper = Mapper::new(&doc.text, enc);
-            let replace = mapper.range(Span::new(cx.partial_start, cx.offset));
-            // Statement repairs (the import statement's own `;`) —
-            // identical for every item: the replace range is the
-            // partial word regardless of candidate.
-            let repairs = crate::autofix::statement_repairs(
-                &doc.text,
-                cx.stmt_start,
-                cx.partial_start,
-                cx.offset,
-            );
-            let (suffix, repair) = match repairs {
-                Some(r) => (
-                    r.suffix,
-                    r.insert.map(|(at, fix)| TextEdit {
-                        range: mapper.range(Span::new(at, at)),
-                        new_text: fix,
-                    }),
-                ),
-                None => (String::new(), None),
-            };
-            // The repair suffix rides every item's main edit the same
-            // way — snippet-stop the cursor ahead of it where the
-            // client allows (see `item_edits`).
-            let snippet = snippets && !suffix.is_empty();
+            let accept = self.accept(&doc.text, uri, cx, enc);
             let mut out: Vec<CompletionItem> = Vec::new();
             let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
-            let ws = self.all_workspace_symbols(docs, enc);
+            let ws = self.all_workspace_symbols(docs, uri, enc);
             for s in ws.iter().chain(self.library_symbols()) {
                 // Depth cap: packages, their members, and one level
                 // below — deeper targets are reached by typing the
                 // qualifier (the branch above). Keeps the unfiltered
                 // import list from carrying the whole stdlib tree.
-                if is_phantom(s) || s.depth > 2 || !seen.insert(s.qualified.clone()) {
+                // Only what packages own: a definition's features are
+                // not imported by path.
+                if is_phantom(s)
+                    || s.depth > 2
+                    || !s.importable
+                    || s.is_multiword_library_name()
+                    || s.is_operator_function()
+                {
                     continue;
                 }
-                let qualified =
-                    crate::autoimport::escape_qualified(crate::dialect_of(uri), &s.qualified);
-                out.push(CompletionItem {
-                    label: crate::outline::spell_name(&s.name),
-                    kind: Some(s.kind),
-                    detail: Some(if s.depth == 0 {
-                        "standard library".to_string()
-                    } else {
-                        s.qualified.clone()
-                    }),
-                    documentation: s.documentation(),
-                    text_edit: Some(lsp_types::CompletionTextEdit::Edit(TextEdit {
-                        range: replace,
-                        new_text: if snippet {
-                            format!("{}$0{suffix}", snippet_escape(&qualified))
-                        } else {
-                            format!("{qualified}{suffix}")
+                // A symbol its own or an ancestor's visibility confines
+                // only through a package re-exporting it.
+                let path = ws.import_path(&s.name, &s.qualified);
+                if (s.confined().is_some() && path == s.qualified)
+                    || !seen.insert(s.qualified.clone())
+                {
+                    continue;
+                }
+                let qualified = crate::autoimport::escape_qualified(crate::dialect_of(uri), &path);
+                let label = crate::outline::spell_name(&s.name);
+                // An import path usually names a package: packages sort
+                // ahead of the members the same word matches.
+                let package = s.kind == CompletionItemKind::MODULE;
+                out.push(accept.spelled(&s.name, qualified).fill(
+                    CompletionItem {
+                        sort_text: Some(format!("{}{label}", if package { 0 } else { 1 })),
+                        label,
+                        kind: Some(s.kind),
+                        detail: match (s.depth, &s.site) {
+                            (0, None) => Some("standard library".to_string()),
+                            (0, Some(_)) => None,
+                            _ => Some(path),
                         },
-                    })),
-                    additional_text_edits: repair.clone().map(|e| vec![e]),
-                    insert_text_format: snippet.then_some(lsp_types::InsertTextFormat::SNIPPET),
-                    ..Default::default()
-                });
+                        documentation: s.documentation(),
+                        ..Default::default()
+                    },
+                    Vec::new(),
+                ));
             }
             return out;
         }
 
+        // A position taking keywords alone — a statement's start in a
+        // body that takes no names — needs no symbol table.
+        if want.names.is_none() {
+            return want
+                .keywords
+                .iter()
+                .map(|&(kw, key)| CompletionItem {
+                    label: kw.to_string(),
+                    kind: Some(CompletionItemKind::KEYWORD),
+                    sort_text: Some(crate::site::sort_text(key, kw)),
+                    ..Default::default()
+                })
+                .collect();
+        }
+
         // Position-blind default, with an auto-import tier: a
         // syntax parse of the current document tells which offered
         // names would not resolve at the cursor, and those items carry
@@ -2044,119 +3546,263 @@ impl Nav {
             }),
             _ => None,
         };
+        let ws = self.all_workspace_symbols(docs, uri, enc);
         let auto = match (cx.as_ref(), parsed.as_ref().zip(doc)) {
-            (Some(cx), Some((p, d))) => Some(crate::autoimport::AutoImport::new(
-                &d.text,
-                &p.unit,
-                cx.offset,
-                Span::new(cx.partial_start, cx.offset),
-            )),
+            (Some(cx), Some((p, d))) => Some(
+                crate::autoimport::AutoImport::new(
+                    &d.text,
+                    &p.unit,
+                    cx.offset,
+                    Span::new(cx.partial_start, cx.offset),
+                )
+                .with_reexports(&ws),
+            ),
             _ => None,
         };
         let mapper = doc.map(|d| Mapper::new(&d.text, enc));
-        // The import edit + source annotation for a symbol offered by
-        // simple name, `None` when accepting it needs no import.
-        let import_extras = |s: &QualifiedSymbol| {
-            let (auto, mapper) = auto.as_ref().zip(mapper.as_ref())?;
-            if s.depth == 0 || !s.importable {
-                return None;
-            }
-            let (at, new_text) = auto.import_edit(&s.name, &s.qualified)?;
-            let parent = s
-                .qualified
-                .strip_suffix(s.name.as_str())?
-                .strip_suffix("::")?;
-            Some((
-                vec![TextEdit {
-                    range: mapper.range(Span::new(at, at)),
-                    new_text,
-                }],
-                lsp_types::CompletionItemLabelDetails {
-                    detail: None,
-                    description: Some(format!("import {parent}")),
-                },
-            ))
+        // The names the statement being typed declares ahead of the
+        // cursor (`attribute zz = `): none is what it names itself.
+        let statement = cx
+            .as_ref()
+            .zip(mapper.as_ref())
+            .map(|(cx, m)| (m.position(cx.stmt_start), m.position(cx.offset)));
+        let own_statement = |s: &QualifiedSymbol| {
+            statement.is_some_and(|(from, to)| s.declared_within(&uri_str, from, to))
+        };
+        // What accepting a symbol offered by simple name takes to resolve
+        // (see [`reach`]): `None` when nothing inserted gives it, so it
+        // is not offered; nothing to tell without a cursor.
+        let reached = |s: &QualifiedSymbol| match auto.as_ref() {
+            Some(auto) => reach(auto, s),
+            None => Some(None),
         };
         // Restricted names insert quoted, replacing the typed spelling.
         // The main edit (quoting + repair suffix) and the repair
-        // insertion, per item; merged with the import edit below.
-        let edits_for = |s: &QualifiedSymbol| match cx.as_ref().zip(mapper.as_ref().zip(doc)) {
-            Some((cx, (mapper, d))) => item_edits(
-                &d.text,
-                mapper,
-                cx,
-                crate::dialect_of(uri),
-                &s.name,
-                snippets,
-            ),
-            None => (None, None, None),
-        };
-        let assemble = |s: &QualifiedSymbol| {
-            let (text_edit, repair, insert_text_format) = edits_for(s);
-            let (import_edits, label_details) = match import_extras(s) {
-                Some((e, d)) => (Some(e), Some(d)),
-                None => (None, None),
+        // insertion, per item, with the import edit ahead of the repair.
+        let accept = cx
+            .as_ref()
+            .zip(doc)
+            .map(|(cx, d)| self.accept(&d.text, uri, cx, enc));
+        let assemble = |s: &QualifiedSymbol,
+                        import: Option<crate::autoimport::ImportEdit>,
+                        item: CompletionItem| {
+            let edits = accept.as_ref().map(|a| a.name(&s.name)).unwrap_or_default();
+            let extras = import
+                .zip(mapper.as_ref())
+                .and_then(|(edit, mapper)| import_for(mapper, crate::dialect_of(uri), s, edit));
+            let (imports, label_details) = match extras {
+                Some((e, d)) => (e, Some(d)),
+                None => (Vec::new(), None),
             };
-            let additional: Vec<TextEdit> =
-                import_edits.into_iter().flatten().chain(repair).collect();
-            (
-                text_edit,
-                (!additional.is_empty()).then_some(additional),
-                label_details,
-                insert_text_format,
+            edits.fill(
+                CompletionItem {
+                    label_details,
+                    ..item
+                },
+                imports,
             )
         };
-        let mut out: Vec<CompletionItem> = crate::tokens::VOCABULARY
+        // The position's keywords and names only, ranked by the
+        // position's groups (`sortText`), then by source: workspace
+        // names before the library's, and among each, names that
+        // resolve as they stand before those needing an import.
+        let mut out: Vec<CompletionItem> = want
+            .keywords
             .iter()
-            .map(|kw| CompletionItem {
+            .map(|&(kw, key)| CompletionItem {
                 label: kw.to_string(),
                 kind: Some(CompletionItemKind::KEYWORD),
+                sort_text: Some(crate::site::sort_text(key, kw)),
                 ..Default::default()
             })
             .collect();
-        let mut meta: Vec<(usize, String, String)> = Vec::new();
+        let mut meta: Vec<Offered> = Vec::new();
         let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
-        for s in &self.all_workspace_symbols(docs, enc) {
+        // Measurement units rank by the statement's type at an
+        // expression operand (see `Want::unit_group`); the unit types are
+        // the library's and those the workspace derives from them.
+        self.library_symbols();
+        let unit_types =
+            crate::kinds::unit_types(None, &self.library_unit_types, definitions(ws.iter()));
+        let unit_group = want.unit_group(&unit_types);
+        let group_of = |s: &QualifiedSymbol, workspace: bool| {
+            let group = want.group(s.decl, workspace)?;
+            Some(match unit_group {
+                Some(units) if s.is_unit(&unit_types) => units,
+                _ => group,
+            })
+        };
+        // The enclosing element's features the position names, those of
+        // the kinds it prefers ahead of every other name: names in
+        // scope, needing no import.
+        let members = match cx.as_ref() {
+            Some(cx) => self.scope_members(docs, uri, cx, want.members()),
+            None => Vec::new(),
+        };
+        // A member the symbol tables hold too takes their documentation
+        // and kind, as the same name offered from them would: the
+        // workspace's table finds the library's symbols as well.
+        let tabled = |m: &ScopeMember| ws.symbol_at(m.qualified.as_deref()?);
+        let before_members = out.len();
+        for m in &members {
+            if want.group(m.decl, !m.library) != Some(1) || !seen.insert(m.name.clone()) {
+                continue;
+            }
+            let edits = accept.as_ref().map(|a| a.name(&m.name)).unwrap_or_default();
+            let source = if m.library { 2 } else { 0 };
+            let label = crate::outline::spell_name(&m.name);
+            let known = tabled(m);
+            out.push(edits.fill(
+                CompletionItem {
+                    sort_text: Some(crate::site::sort_text(
+                        crate::site::name_key(0, source, want.tier(m.decl)),
+                        &label,
+                    )),
+                    label,
+                    kind: Some(known.map_or(m.kind, |s| s.kind)),
+                    detail: m.qualified.clone(),
+                    documentation: known.and_then(QualifiedSymbol::documentation),
+                    ..Default::default()
+                },
+                Vec::new(),
+            ));
+        }
+        // An editor ranks a label the typed word matches whole ahead of
+        // every other (`m` for `m`, ahead of `mass`), whatever the order
+        // given: where the enclosing element's features are named, only
+        // they keep that for a label of one or two characters, which a
+        // letter or two typed matches whole by chance — every other such
+        // name is filtered by more than its label (see
+        // [`unmatched_whole`]). A longer name typed whole keeps its match
+        // (`mass` at `attribute m :> mass`, ahead of `massFlow`).
+        let members_named = out.len() > before_members;
+        let unit_position = cx.as_ref().zip(doc).is_some_and(|(cx, d)| {
+            matches!(
+                crate::units::bracket_at(&d.text, cx, crate::dialect_of(uri)),
+                Some(crate::units::Bracket::Unit { .. })
+            )
+        });
+        // An expression's operand outside a unit bracket takes no unit
+        // spelled apart from the names around it, one only a quoted name
+        // writes (`m/s`, `m²/(V⋅s)`): a `)` or an operator typed after a
+        // name matches its symbol, and would accept it. Its plain symbols
+        // (`kg`, `N`) stay, and while a quoted name is typed every unit
+        // does: a derived unit's definition names them so (`Btu_IT/'°F'`,
+        // `referenceUnit = 'm⋅s⁻²'`).
+        let operand = matches!(want.names, Some(crate::site::Names::Operands { .. }));
+        let typing_quoted = cx.as_ref().is_some_and(|cx| cx.quoted.is_some());
+        let spelled_apart = |s: &QualifiedSymbol| {
+            operand
+                && !unit_position
+                && !typing_quoted
+                && s.is_unit(&unit_types)
+                && sysmlv2_parser::ast::escape_name(&s.name).starts_with('\'')
+        };
+        let outranked = |s: &QualifiedSymbol, item: CompletionItem| {
+            if !members_named || item.label.chars().count() > 2 {
+                return item;
+            }
+            let filter_text = unmatched_whole(
+                item.filter_text.as_deref().unwrap_or(&item.label),
+                s.long.as_deref().unwrap_or(&item.label),
+            );
+            CompletionItem {
+                filter_text: Some(filter_text),
+                ..item
+            }
+        };
+        for s in ws.iter() {
+            let Some(group) = group_of(s, true) else {
+                continue;
+            };
+            // The statement being typed names an unnamed usage by the
+            // word typed (`satisfy Max`): that one is no candidate.
+            if seen.contains(&s.name)
+                || (s.effective && auto.is_none())
+                || is_phantom(s)
+                || own_statement(s)
+                || s.is_operator_function()
+                || spelled_apart(s)
+            {
+                continue;
+            }
+            let Some(import) = reached(s) else {
+                continue;
+            };
             if seen.insert(s.name.clone()) {
-                let (text_edit, additional_text_edits, label_details, insert_text_format) =
-                    assemble(s);
-                meta.push((out.len(), s.name.clone(), s.qualified.clone()));
+                meta.push(offered(out.len(), s));
+                let item = assemble(
+                    s,
+                    import,
+                    CompletionItem {
+                        label: crate::outline::spell_name(&s.name),
+                        kind: Some(s.kind),
+                        detail: (!s.qualified.eq(&s.name)).then(|| s.qualified.clone()),
+                        documentation: s.documentation(),
+                        ..Default::default()
+                    },
+                );
+                let source = u8::from(item.label_details.is_some());
+                let item = outranked(s, item);
                 out.push(CompletionItem {
-                    label: crate::outline::spell_name(&s.name),
-                    kind: Some(s.kind),
-                    detail: (!s.qualified.eq(&s.name)).then(|| s.qualified.clone()),
-                    documentation: s.documentation(),
-                    text_edit,
-                    additional_text_edits,
-                    label_details,
-                    insert_text_format,
-                    ..Default::default()
+                    sort_text: Some(crate::site::sort_text(
+                        crate::site::name_key(group, source, want.tier(s.decl)),
+                        &item.label,
+                    )),
+                    ..item
                 });
             }
         }
         // Standard-library names last: workspace names shadow them. Kept
         // to packages + direct members — the full table would flood the
-        // unfiltered list.
+        // unfiltered list. Multi-word names only where a unit is written:
+        // inside a quantity's unit bracket the statement leaves open
+        // ahead of the word being completed — not a multiplicity's.
+        // Operator functions never.
         for s in self.library_symbols() {
-            if s.depth > 1 || !seen.insert(s.name.clone()) {
+            // The cheap tests first: most symbols are deeper members,
+            // and many a name is offered already.
+            if s.depth > 1 || seen.contains(&s.name) {
+                continue;
+            }
+            let Some(group) = group_of(s, false) else {
+                continue;
+            };
+            if spelled_apart(s)
+                || (!unit_position && s.is_multiword_library_name())
+                || s.is_operator_function()
+                || (auto.is_none() && s.is_private_library_member())
+            {
                 continue;
             }
-            let (text_edit, additional_text_edits, label_details, insert_text_format) = assemble(s);
-            meta.push((out.len(), s.name.clone(), s.qualified.clone()));
+            let Some(import) = reached(s) else {
+                continue;
+            };
+            seen.insert(s.name.clone());
+            meta.push(offered(out.len(), s));
+            let item = assemble(
+                s,
+                import,
+                CompletionItem {
+                    label: crate::outline::spell_name(&s.name),
+                    kind: Some(s.kind),
+                    detail: Some(if s.depth == 0 {
+                        "standard library".to_string()
+                    } else {
+                        s.qualified.clone()
+                    }),
+                    documentation: s.documentation(),
+                    ..Default::default()
+                },
+            );
+            let source = 2 + u8::from(item.label_details.is_some());
+            let item = outranked(s, item);
             out.push(CompletionItem {
-                label: crate::outline::spell_name(&s.name),
-                kind: Some(s.kind),
-                detail: Some(if s.depth == 0 {
-                    "standard library".to_string()
-                } else {
-                    s.qualified.clone()
-                }),
-                documentation: s.documentation(),
-                text_edit,
-                additional_text_edits,
-                label_details,
-                insert_text_format,
-                ..Default::default()
+                sort_text: Some(crate::site::sort_text(
+                    crate::site::name_key(group, source, want.tier(s.decl)),
+                    &item.label,
+                )),
+                ..item
             });
         }
         if let (Some(cx), Some(tcx)) = (cx.as_ref(), unit_type_cx.as_ref()) {
@@ -2556,15 +4202,24 @@ pub struct LintFixSet {
 }
 
 /// Flatten one document's outline into (name, kind, range) triples for
-/// `workspace/symbol`.
+/// `workspace/symbol`. The `import` and `expose` members (`imports`, by
+/// start; see [`crate::outline::Plumbing`]) declare nothing and are
+/// left out, and so are anonymous members (`«part»`), which have no
+/// name to search for — the named members inside them stay. The
+/// outline keeps both.
 pub fn flatten_symbols(
     symbols: &[lsp_types::DocumentSymbol],
     uri: &Uri,
     query: &str,
+    imports: &std::collections::HashSet<Position>,
     out: &mut Vec<lsp_types::SymbolInformation>,
 ) {
     for s in symbols {
-        if query.is_empty() || s.name.to_lowercase().contains(&query.to_lowercase()) {
+        if imports.contains(&s.range.start) {
+            continue;
+        }
+        let named = !s.name.starts_with('«');
+        if named && (query.is_empty() || s.name.to_lowercase().contains(&query.to_lowercase())) {
             #[allow(deprecated)]
             out.push(lsp_types::SymbolInformation {
                 name: crate::outline::spell_name(&s.name),
@@ -2579,7 +4234,7 @@ pub fn flatten_symbols(
             });
         }
         if let Some(children) = &s.children {
-            flatten_symbols(children, uri, query, out);
+            flatten_symbols(children, uri, query, imports, out);
         }
     }
 }
@@ -2857,13 +4512,28 @@ fn collect_import_runs(
     }
 }
 
+/// The filter text of an item ranked below the best group a list holds:
+/// `filter` — its label, or the text it is filtered by already — then
+/// `_` and `tail`, the name it is spelled for (`K_kelvin`, `m_metre`) or
+/// its label again. An editor ranks a label the typed word matches whole
+/// ahead of every other (`K` for `k`, ahead of `kg`), whatever the order
+/// the server gives; this one the word matches no more than in part, so
+/// the order given decides. No whitespace: a typed space still closes
+/// the list.
+fn unmatched_whole(filter: &str, tail: &str) -> String {
+    format!("{filter}_{}", tail.replace(char::is_whitespace, "_"))
+}
+
 /// A named symbol with its `::`-qualified path, flattened from an
 /// outline tree. `depth` counts nesting from the unit root (0 = a
 /// top-level package). Workspace symbols carry their declaration site
-/// (`uri` + name span) so completion can drop the phantom symbol the
-/// half-typed statement itself declares — `private import Real` parses
-/// as a member named `Real`, and offering it back (qualified into its
-/// accidental owner) would outrank the real target.
+/// (`uri` + name span) so the import and qualifier branches of
+/// completion can drop the phantom symbol the half-typed statement
+/// itself declares — an import missing its `;` runs on into the next
+/// statement (`private import Kit::*` ⏎ `part def Widg|;`), which
+/// declares the very word being typed, and offering that back
+/// (qualified into its accidental owner) would outrank the real
+/// target.
 #[derive(Clone)]
 pub(crate) struct QualifiedSymbol {
     name: String,
@@ -2879,9 +4549,46 @@ pub(crate) struct QualifiedSymbol {
     site: Option<(String, lsp_types::Range)>,
     /// The declaration's `doc` body, display-normalized.
     doc: Option<String>,
+    /// Named by an operator and naming a function
+    /// ([`Self::is_operator_function`]).
+    operator: bool,
+    /// Declared without `private` or `protected`: a member of its
+    /// namespace for clients outside it too, which a public import of
+    /// the namespace re-exports.
+    public: bool,
+    /// What the declaration is: completion admits and ranks candidates
+    /// by it.
+    decl: crate::kinds::Decl,
+    /// The types the declaration names, last segment only (see
+    /// [`crate::kinds::Declared::types`]).
+    types: Vec<String>,
+    /// The declared name, for an entry spelled by its short name (`m`
+    /// for `metre`).
+    long: Option<String>,
+    /// What an alias names, as written: the symbol table it is indexed
+    /// in takes it as its target (see [`SymbolTable`]).
+    alias: Option<Box<crate::outline::Written>>,
+    /// The length of the path, a prefix of `qualified`, of the
+    /// namespace owning the innermost of the symbol's ancestors that is
+    /// private or protected: outside it, no path through that ancestor
+    /// names the symbol (see [`Self::enclosed`]).
+    enclosed: Option<u32>,
+    /// A usage without a name of its own, found by the name of the
+    /// feature it redefines or references (see
+    /// [`crate::outline::Plumbing::effective`]): a recursive import
+    /// brings it in, but nothing it holds.
+    effective: bool,
 }
 
 impl QualifiedSymbol {
+    /// Does this symbol name a measurement unit — a usage typed by one
+    /// of `unit_types` (see [`crate::kinds::unit_types`]), or an alias
+    /// of one?
+    fn is_unit(&self, unit_types: &std::collections::HashSet<String>) -> bool {
+        matches!(self.decl, crate::kinds::Decl::Usage(_))
+            && self.types.iter().any(|t| unit_types.contains(t))
+    }
+
     /// The symbol's doc body as completion-item documentation.
     fn documentation(&self) -> Option<lsp_types::Documentation> {
         self.doc.as_ref().map(|d| {
@@ -2891,6 +4598,61 @@ impl QualifiedSymbol {
             })
         })
     }
+
+    /// A library name containing whitespace. In the standard library
+    /// these are measurement vocabulary: units and their aliases
+    /// (`'metric ton'`), measurement scales, and the systems of units
+    /// and quantities; a library a host supplies is held to the same
+    /// rule. Offered only where a unit is written: anywhere else they
+    /// are noise, some 380 labels in every response.
+    fn is_multiword_library_name(&self) -> bool {
+        self.site.is_none() && self.name.chars().any(char::is_whitespace)
+    }
+
+    /// The qualified path of the namespace owning the symbol; `None` at
+    /// the root.
+    fn parent(&self) -> Option<&str> {
+        self.qualified
+            .strip_suffix(self.name.as_str())?
+            .strip_suffix("::")
+    }
+
+    /// The namespace outside which an ancestor's visibility keeps the
+    /// symbol from being named by its path: the one owning the innermost
+    /// ancestor that is private or protected. `None` when none is.
+    fn enclosed(&self) -> Option<&str> {
+        self.enclosed.map(|n| &self.qualified[..n as usize])
+    }
+
+    /// The namespace outside which the symbol cannot be named by its
+    /// path: its own when it is private or protected, else the one its
+    /// ancestors keep it in ([`Self::enclosed`]). `None` when it can be
+    /// named anywhere.
+    fn confined(&self) -> Option<&str> {
+        if self.public {
+            self.enclosed()
+        } else {
+            Some(self.parent().unwrap_or_default())
+        }
+    }
+
+    /// A private or protected member of a library namespace: no name a
+    /// model can use.
+    fn is_private_library_member(&self) -> bool {
+        self.site.is_none() && !self.public
+    }
+
+    /// A function named by an operator of the expression notation —
+    /// a run of punctuation (`'+'`, `'['`, `'..'`) or a reserved word
+    /// (`'not'`, `'xor'`, `'implies'`) — or an alias naming one
+    /// (`alias '*' for scalarVectorMult;`). The notation writes it as
+    /// that operator and never by name, so only a qualifier offers it.
+    /// The element decides, not the spelling: a unit spelled with a
+    /// symbol is no function, and a function whose quoted name holds a
+    /// word (`'cartesian+'`) is a name like any other.
+    fn is_operator_function(&self) -> bool {
+        self.operator
+    }
 }
 
 impl QualifiedSymbol {
@@ -2902,6 +4664,19 @@ impl QualifiedSymbol {
             None => false,
         }
     }
+
+    /// Is the symbol declared in `uri` between `from` and `to`?
+    fn declared_within(
+        &self,
+        uri: &str,
+        from: lsp_types::Position,
+        to: lsp_types::Position,
+    ) -> bool {
+        match &self.site {
+            Some((u, range)) => u == uri && from <= range.start && range.end <= to,
+            None => false,
+        }
+    }
 }
 
 impl QualifiedSymbol {
@@ -2916,7 +4691,9 @@ impl QualifiedSymbol {
         else {
             return false;
         };
-        parent == path || parent.ends_with(&format!("::{path}"))
+        parent
+            .strip_suffix(path)
+            .is_some_and(|rest| rest.is_empty() || rest.ends_with("::"))
     }
 }
 
@@ -2942,15 +4719,24 @@ fn completion_kind(k: lsp_types::SymbolKind) -> lsp_types::CompletionItemKind {
         SymbolKind::FIELD => CompletionItemKind::FIELD,
         SymbolKind::CONSTANT => CompletionItemKind::CONSTANT,
         SymbolKind::FILE => CompletionItemKind::FILE,
-        SymbolKind::KEY => CompletionItemKind::KEYWORD,
+        // Metadata definitions and usages: keywords alone carry the
+        // keyword kind, and no other symbol completes as a reference.
+        SymbolKind::KEY => CompletionItemKind::REFERENCE,
         SymbolKind::OBJECT | SymbolKind::STRING => CompletionItemKind::VALUE,
         _ => CompletionItemKind::VARIABLE,
     }
 }
 
-/// Flatten an outline tree into qualified symbols. Anonymous
+/// Flatten an outline tree into qualified symbols, the nodes at this
+/// level kept by their ancestors inside the namespace `enclosed` gives
+/// the length of (see [`QualifiedSymbol::enclosed`]). Anonymous
 /// (`«keyword»`) members have no referenceable name — their subtrees
 /// are skipped, since a qualified path through them would not resolve.
+/// Neither are the `import` and `expose` members (see
+/// [`crate::outline::Plumbing`]): the outline lists them under their
+/// target's spelling, but they declare nothing — an `import SI::m;` in
+/// `P` is no member `P::SI::m`. The imports are recorded in `links`
+/// instead, against the namespace they sit in.
 #[allow(clippy::too_many_arguments)] // one recursive walk, one context set
 fn collect_qualified(
     nodes: &[lsp_types::DocumentSymbol],
@@ -2960,45 +4746,102 @@ fn collect_qualified(
     uri: Option<&str>,
     docs: &HashMap<lsp_types::Position, String>,
     shorts: &HashMap<lsp_types::Position, String>,
+    plumbing: &mut crate::outline::Plumbing,
+    links: &mut Links,
+    decls: &HashMap<lsp_types::Position, crate::kinds::Declared>,
+    enclosed: Option<u32>,
     out: &mut Vec<QualifiedSymbol>,
 ) {
     for s in nodes {
-        if s.name.starts_with('«') {
+        // An unnamed usage is found by the name of what it redefines or
+        // references, and what it holds by paths through that name.
+        let effective = plumbing.effective.get(&s.range.start);
+        if s.name.starts_with('«') && effective.is_none() {
+            continue;
+        }
+        // Such a usage's name is where the text spells what names it.
+        let (name, spelled) = effective.map_or((&s.name, s.selection_range), |(n, r)| (n, *r));
+        if plumbing.imports.contains(&s.range.start) {
+            if let Some(form) = plumbing.import_forms.get(&s.range.start) {
+                links.import(prefix, form, uri);
+            }
             continue;
         }
+        // What completion shows, admits, and ranks the symbol as. An
+        // alias is what it names, which the symbol table it is indexed in
+        // finds; until then, and when the target does not resolve, it
+        // keeps the module kind of its outline node and may name
+        // anything.
+        let alias = plumbing.aliases.get(&s.range.start).cloned().map(Box::new);
+        let kind = completion_kind(s.kind);
+        let function = alias.is_none()
+            && matches!(
+                s.kind,
+                lsp_types::SymbolKind::FUNCTION
+                    | lsp_types::SymbolKind::OPERATOR
+                    | lsp_types::SymbolKind::BOOLEAN
+            );
         let qualified = if prefix.is_empty() {
-            s.name.clone()
+            name.clone()
         } else {
-            format!("{prefix}::{}", s.name)
+            format!("{prefix}::{name}")
         };
+        let decl = decl_at(decls, s.selection_range.start);
+        let types = types_at(decls, s.selection_range.start);
         out.push(QualifiedSymbol {
-            name: s.name.clone(),
+            name: name.clone(),
             qualified: qualified.clone(),
-            kind: completion_kind(s.kind),
+            kind,
             depth,
             importable: in_packages,
-            site: uri.map(|u| (u.to_string(), s.selection_range)),
+            site: uri.map(|u| (u.to_string(), spelled)),
             doc: docs.get(&s.selection_range.start).cloned(),
+            operator: is_operator_spelling(name) && function,
+            public: !plumbing.hidden.contains(&s.range.start),
+            decl,
+            types: types.clone(),
+            long: None,
+            alias: alias.clone(),
+            enclosed,
+            effective: effective.is_some(),
         });
+        // What it specializes, as written, goes to the links, the short
+        // symbol below sharing it.
+        let bases = plumbing.bases.remove(&s.range.start);
         // A short symbol (`<'m/s²'>`) alongside the regular name is its
         // own referenceable spelling — its own entry, same everything
         // else. Nothing nests under it: children path through the
         // regular name.
         if let Some(short) = shorts.get(&s.selection_range.start) {
+            let path = if prefix.is_empty() {
+                short.clone()
+            } else {
+                format!("{prefix}::{short}")
+            };
+            if let Some(bases) = &bases {
+                links.bases.push((path.clone(), bases.clone()));
+            }
             out.push(QualifiedSymbol {
                 name: short.clone(),
-                qualified: if prefix.is_empty() {
-                    short.clone()
-                } else {
-                    format!("{prefix}::{short}")
-                },
-                kind: completion_kind(s.kind),
+                qualified: path,
+                kind,
                 depth,
                 importable: in_packages,
                 site: uri.map(|u| (u.to_string(), s.selection_range)),
                 doc: docs.get(&s.selection_range.start).cloned(),
+                operator: is_operator_spelling(short) && function,
+                public: !plumbing.hidden.contains(&s.range.start),
+                decl,
+                types,
+                long: Some(s.name.clone()),
+                alias,
+                enclosed,
+                effective: false,
             });
         }
+        if let Some(bases) = bases {
+            links.bases.push((qualified.clone(), bases));
+        }
         if let Some(children) = &s.children {
             let nested = in_packages
                 && matches!(
@@ -3013,42 +4856,463 @@ fn collect_qualified(
                 uri,
                 docs,
                 shorts,
+                plumbing,
+                links,
+                decls,
+                // A private or protected member keeps what it holds
+                // inside the namespace owning it.
+                if plumbing.hidden.contains(&s.range.start) {
+                    Some(u32::try_from(prefix.len()).unwrap_or(u32::MAX))
+                } else {
+                    enclosed
+                },
                 out,
             );
         }
     }
 }
 
-/// Every open document's outline, flattened to qualified symbols.
-fn workspace_symbols(docs: &BTreeMap<Uri, Document>, enc: Encoding) -> Vec<QualifiedSymbol> {
+/// A name the expression notation spells as an operator: a run of
+/// punctuation (`+`, `[`, `..`) or a reserved word (`not`, `xor`) of
+/// the kernel language, whose expression notation both dialects share.
+fn is_operator_spelling(name: &str) -> bool {
+    let punctuation =
+        !name.is_empty() && name.chars().all(|c| c.is_ascii_punctuation() && c != '_');
+    punctuation || sysmlv2_parser::parser::is_reserved(sysmlv2_parser::ast::Dialect::Kerml, name)
+}
+
+/// The definitions among `symbols`, with the names they specialize.
+fn definitions<'a>(
+    symbols: impl IntoIterator<Item = &'a QualifiedSymbol>,
+) -> impl Iterator<Item = (&'a str, &'a [String])> {
+    symbols
+        .into_iter()
+        .filter(|s| matches!(s.decl, crate::kinds::Decl::Definition(_)))
+        .map(|s| (s.name.as_str(), s.types.as_slice()))
+}
+
+/// The declaration kind recorded at an outline selection position.
+fn decl_at(
+    decls: &HashMap<lsp_types::Position, crate::kinds::Declared>,
+    at: lsp_types::Position,
+) -> crate::kinds::Decl {
+    decls.get(&at).map_or(crate::kinds::Decl::Other, |d| d.decl)
+}
+
+/// The types the declaration at an outline selection position names.
+fn types_at(
+    decls: &HashMap<lsp_types::Position, crate::kinds::Declared>,
+    at: lsp_types::Position,
+) -> Vec<String> {
+    decls.get(&at).map(|d| d.types.clone()).unwrap_or_default()
+}
+
+/// Open documents' outlines, flattened to qualified symbols, and the
+/// documents' imports.
+fn workspace_symbols<'d>(
+    docs: impl Iterator<Item = (&'d Uri, &'d Document)>,
+    enc: Encoding,
+) -> (Vec<QualifiedSymbol>, Links) {
     let mut out = Vec::new();
+    let mut links = Links::default();
     for (uri, doc) in docs {
-        let parse = if crate::is_kerml(uri.path().as_str()) {
-            sysmlv2_parser::parser::parse_kerml_source(&doc.text)
-        } else {
-            sysmlv2_parser::parser::parse_source(&doc.text)
-        };
-        let mapper = Mapper::new(&doc.text, enc);
-        let roots = crate::document_symbols(&parse.unit, &doc.text, &mapper);
-        let bodies = crate::outline::doc_bodies(&parse.unit, &mapper);
-        let shorts = crate::outline::short_names(&parse.unit, &mapper);
-        collect_qualified(
-            &roots,
-            "",
-            0,
-            true,
-            Some(uri.to_string().as_str()),
-            &bodies,
-            &shorts,
-            &mut out,
-        );
+        let kerml = crate::is_kerml(uri.path().as_str());
+        let uri = uri.to_string();
+        collect_unit(&doc.text, kerml, Some(&uri), enc, &mut out, &mut links);
+    }
+    (out, links)
+}
+
+/// Flatten one unit's outline into `symbols` and record its imports in
+/// `links`. `uri` is the declaration site of a workspace unit's symbols.
+fn collect_unit(
+    text: &str,
+    kerml: bool,
+    uri: Option<&str>,
+    enc: Encoding,
+    symbols: &mut Vec<QualifiedSymbol>,
+    links: &mut Links,
+) {
+    let parse = if kerml {
+        sysmlv2_parser::parser::parse_kerml_source(text)
+    } else {
+        sysmlv2_parser::parser::parse_source(text)
+    };
+    let mapper = Mapper::new(text, enc);
+    let roots = crate::document_symbols(&parse.unit, text, &mapper);
+    let bodies = crate::outline::doc_bodies(&parse.unit, &mapper);
+    let shorts = crate::outline::short_names(&parse.unit, &mapper);
+    let mut plumbing = crate::outline::plumbing(&parse.unit, &mapper);
+    let decls = crate::kinds::declarations(&parse.unit, &mapper);
+    collect_qualified(
+        &roots,
+        "",
+        0,
+        true,
+        uri,
+        &bodies,
+        &shorts,
+        &mut plumbing,
+        links,
+        &decls,
+        None,
+        symbols,
+    );
+}
+
+/// What `owner` inherits (see [`Nav::inherited_members`]), whatever
+/// its body holds. The model's inheritance leaves out what the owner's
+/// own features redefine — explicitly, by position (a parameter, an
+/// end, a calculation's `return`, a `subject`), or by declaring the same
+/// name — and the body the model was built from need not be the live
+/// one (see [`Nav::scope_members`]): the statement being typed is cut
+/// out of it, which moves the parameters after it. So what it left out
+/// comes back: the features of the types the element is typed by,
+/// specializes, subsets, or redefines, and of the library bases it
+/// specializes implicitly (an action's `Actions::Action`, whose `start`
+/// and `done` every action has), each as its type has them — but for
+/// those another feature of the heritage redefines and those private to
+/// their type. A redefinition's target may be more general than the
+/// feature inherited (`:>> elements` names a collection's), and one not
+/// inherited at all stays out. The live body then takes out what it
+/// redefines by name; what it redefines by position alone stays
+/// offered, whichever of its statements was typed first. A metadata
+/// usage inherits nothing in the model: its body names the features of
+/// the metadata definition it is typed by.
+fn inherited_of(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    owner: ElementRef,
+) -> Vec<ScopeMember> {
+    use std::collections::HashSet;
+    let mut features = resolved.inherited_features(owner, true);
+    // With no feature of its own, the owner loses nothing to its body —
+    // and one inheriting nothing then is a metadata usage, whose members
+    // are its definition's.
+    if resolved.owned_features(owner).is_empty() {
+        if features.is_empty() {
+            for t in resolved.typings(owner) {
+                features.extend(resolved.effective_features(t, true));
+            }
+        }
+        return scope_members_of(resolved, features);
+    }
+    let mut general = resolved.typings(owner);
+    for g in resolved.explicit_supertypes(owner) {
+        if !general.contains(&g) {
+            general.push(g);
+        }
+    }
+    // The features of the general types, each once.
+    let mut candidates = Vec::new();
+    let mut seen = HashSet::new();
+    for &g in &general {
+        for f in resolved.effective_features(g, true) {
+            if seen.insert(f) {
+                candidates.push(f);
+            }
+        }
+    }
+    // The implied library bases, which no written relationship names:
+    // the types the inherited features beyond those come from.
+    let mut implied = Vec::new();
+    for &f in &features {
+        if seen.contains(&f) {
+            continue;
+        }
+        if let Some(t) = resolved.owner(f) {
+            if !general.contains(&t) && !implied.contains(&t) {
+                implied.push(t);
+            }
+        }
+    }
+    for t in implied {
+        for f in resolved.effective_features(t, true) {
+            if seen.insert(f) {
+                candidates.push(f);
+            }
+        }
+    }
+    // What a feature of the heritage redefines, directly or not, is not
+    // inherited.
+    let mut covered = HashSet::new();
+    for &f in features.iter().chain(&candidates) {
+        covered.extend(redefined_closure(resolved, f));
+    }
+    let inherited: HashSet<ElementRef> = features.iter().copied().collect();
+    for f in candidates {
+        if !inherited.contains(&f)
+            && !covered.contains(&f)
+            && resolved.member_visibility(f) != Some("private")
+        {
+            features.push(f);
+        }
+    }
+    scope_members_of(resolved, features)
+}
+
+/// What `f` redefines, directly or through the features it redefines.
+fn redefined_closure(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    f: ElementRef,
+) -> std::collections::HashSet<ElementRef> {
+    let mut out = std::collections::HashSet::new();
+    let mut walk = vec![f];
+    while let Some(g) = walk.pop() {
+        for t in resolved.redefinition_targets(g) {
+            if out.insert(t) {
+                walk.push(t);
+            }
+        }
     }
     out
 }
 
+/// The element declared where `innermost` is, in `unit` of a model built
+/// from a text whose part ahead of its body is the live one: an element
+/// with no name of its own, or where the qualified-name lookup fails —
+/// not the innermost element holding the statement, which may be deeper
+/// than it (a feature whose value holds an expression's body, `?{in p :>
+/// …}`), and whose members would be kept for the element's. A statement
+/// led by `then` records its succession over the same text, ahead of
+/// what it declares: the last is the declaration.
+fn declared_where(
+    resolved: &sysmlv2_parser::json::ResolvedModel,
+    unit: usize,
+    innermost: &crate::kinds::Enclosing,
+) -> Option<ElementRef> {
+    let start = innermost.span.start;
+    resolved
+        .user_elements()
+        .filter(|&e| {
+            resolved
+                .member_extent(e)
+                .is_some_and(|(u, span)| u == unit && span.start == start)
+        })
+        .last()
+}
+
+/// [`inherited_of`] in a model built from an earlier text, of the
+/// innermost of the declarations `around` a statement (see
+/// [`crate::kinds::enclosing`]): found by their qualified name, else —
+/// an element with no name (`@Safety { … }`, `part :> slot : Q { … }`),
+/// or where the lookup fails — by where it is declared in `unit`, the
+/// document's unit in that model (see [`declared_where`]). `None` when
+/// the model holds no such element.
+fn built_inherited(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    around: &[crate::kinds::Enclosing],
+    unit: Option<usize>,
+) -> Option<Vec<ScopeMember>> {
+    let qualified: Option<Vec<String>> = around
+        .iter()
+        .map(|e| e.name.as_deref().map(sysmlv2_parser::ast::escape_name))
+        .collect();
+    let owner = qualified
+        .and_then(|names| resolved.resolve_qualified(&names.join("::")))
+        .or_else(|| declared_where(resolved, unit?, around.last()?))?;
+    Some(inherited_of(resolved, owner))
+}
+
+/// How many enclosing elements' inherited members are kept (see
+/// [`Nav::inherited_members`]).
+const MEMBER_CACHE: usize = 8;
+
+/// How many statements' changes against the sessions built are kept
+/// (see [`Nav::cut_answer`]).
+const REUSED: usize = 4;
+
+/// A kind of session built (see [`Nav::built`]). An answer read off
+/// one is checked against the texts that one was built from — salvaged,
+/// or with a statement cut out, as they are — so any of them serves the
+/// completion tier, which reads a salvaged model of its own; what plans
+/// edits over every reference, and read-only navigation, read only the
+/// sessions [`Nav::session`] and [`Nav::read_session`] give them.
+#[derive(Clone, Copy)]
+enum Built {
+    /// Navigation's, over the documents as written.
+    Navigation,
+    /// Read-only navigation's while the strict one cannot build, the
+    /// units that do not parse salvaged.
+    Tolerant,
+    /// The completion tier's, the statement it was built for cut out.
+    Completion,
+}
+
+impl Built {
+    /// Every kind: one session of each is kept.
+    const ALL: [Built; 3] = [Built::Navigation, Built::Tolerant, Built::Completion];
+
+    /// Whether the session's model may hold the statement being typed as
+    /// something else: the tolerant session salvages a statement left
+    /// unfinished into the declaration it reads as, which the members an
+    /// element inherits — read off any session whose text outside the
+    /// element's body is the live one (see [`Nav::inherited_members`]) —
+    /// would be named after.
+    fn salvages_statements(self) -> bool {
+        matches!(self, Built::Tolerant)
+    }
+}
+
+/// A model a statement's answer is read off (see [`Nav::cut_answer`]).
+pub(crate) struct Read<'a> {
+    pub session: &'a mut Session,
+    /// The session's unit for the document.
+    pub unit: usize,
+    /// Where the statement starts in the session's text of that unit —
+    /// the text before it is the document's own when the session was
+    /// built for the statement, and holds the same declarations around
+    /// it otherwise.
+    pub at: u32,
+    /// What the answer read there (see [`crate::reuse::Needs`]).
+    pub needs: crate::reuse::Needs,
+    /// The library's units as last classified, with the build of the
+    /// session they were classified in (see [`Nav::library_units`]).
+    pub library_units: &'a mut Option<(u64, Vec<(usize, crate::units::UnitEntry)>)>,
+    /// This session's build.
+    pub build: u64,
+}
+
+/// The lengths of `text` ahead of and behind the body of the member
+/// spanning `span`: through its opening brace, and from its closing one
+/// — the whole rest of the text when the body is not closed.
+fn outside_body(text: &str, span: Span) -> (usize, usize) {
+    use sysmlv2_parser::token::TokenKind;
+    let start = (span.start as usize).min(text.len());
+    let end = (span.end as usize).clamp(start, text.len());
+    let member = &text[start..end];
+    let tokens = sysmlv2_parser::lexer::tokenize(member).0;
+    let open = tokens
+        .iter()
+        .find(|t| t.kind == TokenKind::LBrace)
+        .map_or(end, |t| start + t.span.end as usize);
+    let close = tokens
+        .iter()
+        .rev()
+        .find(|t| t.kind != TokenKind::Eof && !t.kind.is_trivia())
+        .filter(|t| t.kind == TokenKind::RBrace && start + t.span.start as usize >= open)
+        .map_or(end, |t| start + t.span.start as usize);
+    (open, text.len() - close)
+}
+
+/// The key the inherited members of the innermost of `around` are kept
+/// under (see [`Nav::inherited_members`]): the declarations around it,
+/// the text of `uri` outside its body — `before` and `after` bytes —
+/// every other open document's text, and the text hashes of the seeded
+/// units no open document shadows, taken once per `seed`.
+fn member_key(
+    docs: &BTreeMap<Uri, Document>,
+    uri: &Uri,
+    text: &str,
+    (before, after): (usize, usize),
+    around: &[crate::kinds::Enclosing],
+    seed: &[(String, u64)],
+) -> u64 {
+    use std::hash::{Hash, Hasher};
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    for e in around {
+        e.name.hash(&mut hasher);
+        for t in &e.types {
+            t.is_global.hash(&mut hasher);
+            for segment in &t.segments {
+                segment.value.hash(&mut hasher);
+            }
+        }
+    }
+    let bytes = text.as_bytes();
+    uri.to_string().hash(&mut hasher);
+    bytes[..before].hash(&mut hasher);
+    bytes[bytes.len() - after..].hash(&mut hasher);
+    let mut open = std::collections::HashSet::new();
+    for (u, d) in docs {
+        let name = u.to_string();
+        if u != uri {
+            name.hash(&mut hasher);
+            d.text.hash(&mut hasher);
+        }
+        open.insert(name);
+    }
+    // The seeded units no open document shadows, as of the last seed.
+    for (name, text) in seed {
+        if !open.contains(name) {
+            name.hash(&mut hasher);
+            text.hash(&mut hasher);
+        }
+    }
+    hasher.finish()
+}
+
+/// Is the text a session was built from (`built`) the same as the text
+/// now (`now`) outside the body of an element of the unit `uri` — its
+/// first `before` and last `after` bytes there, every other unit whole?
+fn outside_unchanged(
+    built: &[(String, String)],
+    now: &[(String, String)],
+    uri: &str,
+    before: usize,
+    after: usize,
+) -> bool {
+    built.len() == now.len()
+        && built.iter().zip(now).all(|((bn, bt), (nn, nt))| {
+            if bn != nn {
+                return false;
+            }
+            if bn != uri {
+                return bt == nt;
+            }
+            let (b, n) = (bt.as_bytes(), nt.as_bytes());
+            b.len() >= before + after
+                && n.len() >= before + after
+                && b[..before] == n[..before]
+                && b[b.len() - after..] == n[n.len() - after..]
+        })
+}
+
+/// `features` as [`ScopeMember`]s, each name once — a feature's lookup
+/// name, so a redefinition declaring no name of its own counts under
+/// the name of the feature it redefines.
+fn scope_members_of(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    features: Vec<ElementRef>,
+) -> Vec<ScopeMember> {
+    #[cfg(test)]
+    MEMBER_READS.with(|n| n.set(n.get() + 1));
+    let mut seen = std::collections::HashSet::new();
+    let mut out = Vec::new();
+    for m in features {
+        let Some(name) = resolved.element_lookup_name(m) else {
+            continue;
+        };
+        if !seen.insert(name.clone()) {
+            continue;
+        }
+        let meta = resolved.element_type(m);
+        out.push(ScopeMember {
+            name,
+            qualified: resolved.element_qualified_name(m),
+            decl: crate::kinds::feature_decl(meta),
+            kind: member_kind(meta),
+            library: resolved.is_library_element(m),
+        });
+    }
+    out
+}
+
+/// A feature in scope at a statement, from the completion tier's session
+/// (see [`Nav::scope_members`]).
+#[derive(Clone)]
+struct ScopeMember {
+    name: String,
+    qualified: Option<String>,
+    decl: crate::kinds::Decl,
+    kind: lsp_types::CompletionItemKind,
+    /// Declared in the library, not the workspace.
+    library: bool,
+}
+
 /// What the cursor is completing: the partial word being typed, the
-/// `::`-chained qualifier before it, and whether the enclosing
-/// statement (back to the previous `;`/`{`/`}`) is an `import`.
+/// `::`-chained qualifier before it, and the statement it belongs to,
+/// read off the toolkit's tokens of the text ahead of the cursor (see
+/// [`crate::site`]).
 pub(crate) struct CompletionCx {
     pub qualifier: Vec<String>,
     /// The `.`-chained feature path before the partial word
@@ -3059,10 +5323,84 @@ pub(crate) struct CompletionCx {
     /// Byte range of the partial word: `partial_start..offset`.
     pub partial_start: u32,
     pub offset: u32,
+    /// The statement is an `import`.
     pub import: bool,
-    /// Statement start (after the previous `;`/`{`/`}`) — the autofix
-    /// tier's scan anchor.
+    /// Statement start: its first token after the last `;`, `{`, `}`,
+    /// or comment body token ahead of the cursor, the cursor when it has
+    /// none yet — never inside a comment, note, string, or quoted name.
+    /// The autofix tier's scan anchor.
     pub stmt_start: u32,
+    /// The quoted name the cursor is typing, if any (see
+    /// [`crate::accept`]): found by the token pass that reads the rest
+    /// of the context, once per request, since each completion tier's
+    /// accepts start from it.
+    pub quoted: Option<crate::accept::Quoted>,
+    /// The statement leaves a `[` open ahead of the partial word: the
+    /// cursor sits where a quantity's unit is written (`9.8 [m`), or in
+    /// a multiplicity (`[0..*]`), which the tokens cannot tell apart.
+    /// The completion's own opening quote (`['deg`) leaves the bracket
+    /// open. Read once per request, for the tiers that offer multi-word
+    /// unit names and for the accepts that take such a name typed word
+    /// by word.
+    pub in_bracket: bool,
+    /// What the partial word fills: nothing, a declared name, or a
+    /// position taking some keywords and kinds of element.
+    pub slot: crate::site::Slot,
+}
+
+/// Does the statement being typed at byte offset `at` import or expose
+/// — is an `import` or `expose` keyword among its tokens? Read on the
+/// toolkit's tokens of the text up to `at`, starting over at every `;`,
+/// `{`, and `}` token and at a `[`, which opens an import's filter
+/// condition, so the words in strings, quoted names, comments, notes,
+/// and filter expressions never count.
+pub(crate) fn in_import_path(text: &str, at: u32) -> bool {
+    use sysmlv2_parser::token::TokenKind;
+    let Some(prefix) = text.get(..at as usize) else {
+        return false;
+    };
+    let mut keyword = false;
+    for token in sysmlv2_parser::lexer::tokenize(prefix).0 {
+        match token.kind {
+            // A `[` opens an import's filter condition: an expression,
+            // no longer the path.
+            TokenKind::Semi | TokenKind::LBrace | TokenKind::RBrace | TokenKind::LBracket => {
+                keyword = false;
+            }
+            TokenKind::Ident => {
+                keyword |= matches!(token.span.slice(prefix), "import" | "expose");
+            }
+            _ => {}
+        }
+    }
+    keyword
+}
+
+/// Does the statement being typed at byte offset `at` import with `all`
+/// — is `import all` among its tokens, read as [`in_import_path`] reads
+/// them? Such an import names a namespace's members whatever their
+/// visibility.
+pub(crate) fn imports_all(text: &str, at: u32) -> bool {
+    use sysmlv2_parser::token::TokenKind;
+    let Some(prefix) = text.get(..at as usize) else {
+        return false;
+    };
+    let (mut after_import, mut all) = (false, false);
+    for token in sysmlv2_parser::lexer::tokenize(prefix).0 {
+        match token.kind {
+            TokenKind::Whitespace | TokenKind::LineNote | TokenKind::BlockNote => {}
+            TokenKind::Semi | TokenKind::LBrace | TokenKind::RBrace | TokenKind::LBracket => {
+                (after_import, all) = (false, false);
+            }
+            TokenKind::Ident => {
+                let word = token.span.slice(prefix);
+                all |= after_import && word == "all";
+                after_import = word == "import";
+            }
+            _ => after_import = false,
+        }
+    }
+    all
 }
 
 /// The declare-the-type context for unit completions: the cursor sits
@@ -3075,81 +5413,16 @@ pub(crate) struct UnitTypeCx {
     pub bracket_open: u32,
 }
 
-/// Detect [`UnitTypeCx`] textually on the live document — the
-/// statement being typed rarely parses, so the model cannot answer.
-/// Conservative: any `:` between the name and the `=` (typing,
-/// subsetting, redefinition) bails, as does a cursor not inside an
-/// open `[`.
+/// Detect [`UnitTypeCx`] on the live document's tokens — the statement
+/// being typed rarely parses, so the model cannot answer (see
+/// [`crate::units::untyped_attribute`]). Conservative: a typing or
+/// specialization between the name and the `=` bails, as does a cursor
+/// not inside an open `[` of the value.
 pub(crate) fn untyped_attribute_unit_context(text: &str, cx: &CompletionCx) -> Option<UnitTypeCx> {
-    let seg = text.get(cx.stmt_start as usize..cx.partial_start as usize)?;
-    let bytes = seg.as_bytes();
-    let is_word = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
-    // `attribute` as its own word.
-    let kw = "attribute";
-    let mut from = 0;
-    let kw_end = loop {
-        let at = from + seg[from..].find(kw)?;
-        let end = at + kw.len();
-        let before_ok = at == 0 || !is_word(bytes[at - 1]);
-        let after_ok = end >= seg.len() || !is_word(bytes[end]);
-        if before_ok && after_ok {
-            break end;
-        }
-        from = end;
-    };
-    let skip_ws = |mut p: usize| {
-        while p < bytes.len() && bytes[p].is_ascii_whitespace() {
-            p += 1;
-        }
-        p
-    };
-    let mut p = skip_ws(kw_end);
-    // Optional short-name group `<...>`.
-    if bytes.get(p) == Some(&b'<') {
-        p = p + seg[p..].find('>')? + 1;
-        p = skip_ws(p);
-    }
-    // The declared name: an identifier or a quoted name.
-    let name_start = p;
-    if bytes.get(p) == Some(&b'\'') {
-        p = p + 1 + seg[p + 1..].find('\'')? + 2;
-    } else {
-        while p < bytes.len() && is_word(bytes[p]) {
-            p += 1;
-        }
-    }
-    if p == name_start {
-        return None;
-    }
-    let name_end = p;
-    // Between the name and the `=`: whitespace and at most a
-    // multiplicity group — any `:` means the declaration is typed.
-    let eq = name_end + seg[name_end..].find('=')?;
-    if seg[name_end..eq].contains(':') {
-        return None;
-    }
-    // The cursor must sit inside an open quantity bracket of the value.
-    let mut open: Option<usize> = None;
-    let mut depth = 0i32;
-    for (j, b) in seg.bytes().enumerate().skip(eq) {
-        match b {
-            b'[' => {
-                depth += 1;
-                open = Some(j);
-            }
-            b']' => {
-                depth -= 1;
-                if depth <= 0 {
-                    open = None;
-                }
-            }
-            _ => {}
-        }
-    }
-    let bracket_open = open?;
+    let (name_end, bracket_open) = crate::units::untyped_attribute(text, cx)?;
     Some(UnitTypeCx {
-        name_end: cx.stmt_start + offset32(name_end),
-        bracket_open: cx.stmt_start + offset32(bracket_open),
+        name_end,
+        bracket_open,
     })
 }
 
@@ -3159,22 +5432,52 @@ pub(crate) fn doc_markdown(body: &str) -> String {
     sysmlv2_parser::json::doc_display_text(body)
 }
 
-/// A parameter's (or return's) type references: the written
-/// specialization clauses of its declaration (typing, subsetting,
-/// redefinition — the qualified name spans as the author spelled
-/// them), plus resolved simple names as the fallback for declarations
-/// with nothing spelled (interchange-lifted units).
-struct SigTypes {
-    refs: Vec<(usize, Span)>,
-    fallback: Vec<String>,
+/// A parameter's (or return's) types as a signature line spells them.
+enum SigTypes {
+    /// The written typings of a declaration in the workspace, failing
+    /// those its other specialization clauses (subsetting, redefinition)
+    /// — the qualified name spans as the author spelled them — sliced
+    /// out of its unit, and its declared multiplicity as
+    /// [`multiplicity_suffix`] spells it.
+    Written(Vec<(usize, Span)>, String),
+    /// Spelled from the model: a library declaration, whose text the
+    /// session does not carry, or one with nothing written
+    /// (interchange-lifted units) — see [`model_types`].
+    Spelled(String),
+}
+
+/// Where a signature is read, for the types spelled from the model: the
+/// document's dialect and the scope names resolve from there.
+struct SigAt {
+    dialect: sysmlv2_parser::ast::Dialect,
+    scope: sysmlv2_parser::json::ScopeRef,
+}
+
+impl SigAt {
+    /// The innermost of the user declarations in `unit` enclosing byte
+    /// `at` that has a scope, the root namespace as the fallback.
+    fn in_unit(
+        resolved: &sysmlv2_parser::json::ResolvedModel,
+        unit: usize,
+        at: u32,
+        dialect: sysmlv2_parser::ast::Dialect,
+    ) -> SigAt {
+        let scope = crate::receiver::enclosing_declarations(resolved, unit, at)
+            .into_iter()
+            .find_map(|e| resolved.element_scope(e))
+            .unwrap_or_else(|| resolved.root_scope());
+        SigAt { dialect, scope }
+    }
 }
 
 /// One rendered-signature parameter: direction prefix (`in` is implied
-/// and empty), name, types.
+/// and empty), name, types, and whether an argument binds it (see
+/// [`crate::receiver::binds_argument`]).
 struct SigParam {
     prefix: String,
     name: String,
     types: SigTypes,
+    input: bool,
 }
 
 /// A callable's signature before type-spelling extraction.
@@ -3187,57 +5490,168 @@ struct SigParts {
     ret_name: Option<String>,
 }
 
-/// The type references of a feature's declaration, spelled clauses
-/// first (see [`SigTypes`]).
-fn spelled_types(resolved: &mut sysmlv2_parser::json::ResolvedModel, e: ElementRef) -> SigTypes {
-    let refs = resolved.specialization_spans(e);
-    let fallback = if refs.is_empty() {
-        let mut targets = resolved.typings(e);
-        if targets.is_empty() {
-            targets = resolved.explicit_supertypes(e);
+/// The types of a feature's declaration (see [`SigTypes`]): as written
+/// where the workspace declares it, else spelled from the model — its
+/// typings either way, failing those what it subsets or redefines
+/// (`in a :> isp`), so `in :>> m : Heavy` reads `m: Heavy`. A feature
+/// that only redefines, writing no type, reads with the type of what it
+/// redefines: `in :>> m` is `m: Mass`, not `m: m`.
+fn spelled_types(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    e: ElementRef,
+    at: &SigAt,
+) -> SigTypes {
+    let mut e = e;
+    let multiplicity = multiplicity_suffix(resolved, e);
+    for _ in 0..8 {
+        let redefined = resolved.redefinition_targets(e);
+        let only_redefines = resolved.typing_spans(e).is_empty()
+            && !redefined.is_empty()
+            && resolved
+                .explicit_supertypes(e)
+                .iter()
+                .all(|t| redefined.contains(t));
+        match redefined.first() {
+            Some(&next) if only_redefines => e = next,
+            _ => break,
         }
-        targets
-            .into_iter()
-            .filter_map(|t| resolved.element_name(t).map(str::to_string))
-            .collect()
+    }
+    let mut refs = resolved.typing_spans(e);
+    if refs.is_empty() {
+        refs = resolved.specialization_spans(e);
+    }
+    // The multiplicity the parameter declares, else what it redefines.
+    let multiplicity = if multiplicity.is_empty() {
+        multiplicity_suffix(resolved, e)
     } else {
-        Vec::new()
+        multiplicity
     };
-    SigTypes { refs, fallback }
+    if refs.is_empty() || resolved.is_library_element(e) {
+        SigTypes::Spelled(model_types(resolved, e, at, &multiplicity))
+    } else {
+        SigTypes::Written(refs, multiplicity)
+    }
 }
 
-/// Assemble the signature line, slicing each type's written spelling
-/// out of its unit's source.
-fn render_signature(parts: SigParts, session: &Session) -> String {
-    let types = |t: &SigTypes| -> Vec<String> {
-        let spelled: Vec<String> = t
-            .refs
-            .iter()
-            .filter_map(|(unit, span)| {
-                let (_, _, src) = session.units().find(|(i, _, _)| i == unit)?;
-                src.get(span.start as usize..span.end as usize)
-                    .map(|s| s.trim().to_string())
-            })
-            .filter(|s| !s.is_empty())
-            .collect();
-        if spelled.is_empty() {
-            t.fallback.clone()
+/// A feature's declared multiplicity as a signature line appends it to
+/// the types (`[0..*]`, `[2]`), empty when it declares none or exactly
+/// one.
+fn multiplicity_suffix(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    e: ElementRef,
+) -> String {
+    let bound = |b: f64| {
+        if b.is_infinite() {
+            "*".to_string()
         } else {
-            spelled
+            format!("{b}")
         }
     };
-    let params: Vec<String> = parts
-        .params
-        .iter()
-        .map(|p| {
-            let ts = types(&p.types);
-            if ts.is_empty() {
-                format!("{}{}", p.prefix, p.name)
+    match resolved.declared_multiplicity(e) {
+        Some((lo, hi)) if (lo, hi) != (1.0, 1.0) => {
+            if lo == hi {
+                format!("[{}]", bound(hi))
             } else {
-                format!("{}{}: {}", p.prefix, p.name, ts.join(", "))
+                format!("[{}..{}]", bound(lo), bound(hi))
             }
+        }
+        _ => String::new(),
+    }
+}
+
+/// A feature's types spelled from the model where `at` reads them: its
+/// typings, or failing those its other written specializations, each
+/// spelled the shortest way that resolves there — the fully qualified
+/// name when nothing does — followed by `multiplicity` (see
+/// [`multiplicity_suffix`], `Real[0..*]`). Empty when the feature
+/// declares no type.
+fn model_types(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    e: ElementRef,
+    at: &SigAt,
+    multiplicity: &str,
+) -> String {
+    let mut targets = resolved.typings(e);
+    if targets.is_empty() {
+        targets = resolved.explicit_supertypes(e);
+    }
+    let dialect = Some(at.dialect);
+    let names: Vec<String> = targets
+        .into_iter()
+        .filter_map(|t| {
+            resolved
+                .type_spelling_at(dialect, at.scope, t)
+                .or_else(|| resolved.full_spelling(dialect, t))
         })
         .collect();
+    if names.is_empty() {
+        return String::new();
+    }
+    let mut spelled = names.join(", ");
+    spelled.push_str(multiplicity);
+    spelled
+}
+
+/// Assemble the signature line, slicing each type's written spelling
+/// out of its unit's source.
+fn render_signature(parts: SigParts, session: &Session) -> String {
+    signature_line(parts, session).label
+}
+
+/// A rendered signature line, with each parameter's name and the byte
+/// range its text takes in the line, and the parameters arguments bind,
+/// in order, by their index in `params`: the inputs, outputs passed over.
+pub(crate) struct SignatureLine {
+    pub label: String,
+    pub params: Vec<(String, std::ops::Range<usize>)>,
+    pub inputs: Vec<usize>,
+}
+
+/// [`render_signature`], keeping where each parameter's text lands.
+fn signature_line(parts: SigParts, session: &Session) -> SignatureLine {
+    let types = |t: &SigTypes| -> Vec<String> {
+        match t {
+            SigTypes::Written(refs, multiplicity) => {
+                let mut written: Vec<String> = refs
+                    .iter()
+                    .filter_map(|(unit, span)| {
+                        let (_, _, src) = session.units().find(|(i, _, _)| i == unit)?;
+                        src.get(span.start as usize..span.end as usize)
+                            .map(|s| s.trim().to_string())
+                    })
+                    .filter(|s| !s.is_empty())
+                    .collect();
+                // The multiplicity follows the last type, as a declaration
+                // writes it (`Mass[0..*]`).
+                if let Some(last) = written.last_mut() {
+                    last.push_str(multiplicity);
+                }
+                written
+            }
+            SigTypes::Spelled(spelled) if spelled.is_empty() => Vec::new(),
+            SigTypes::Spelled(spelled) => vec![spelled.clone()],
+        }
+    };
+    let mut label = format!("{}(", parts.name);
+    let mut params = Vec::new();
+    let mut inputs = Vec::new();
+    for (i, p) in parts.params.iter().enumerate() {
+        if i > 0 {
+            label.push_str(", ");
+        }
+        let start = label.len();
+        let ts = types(&p.types);
+        if ts.is_empty() {
+            label.push_str(&format!("{}{}", p.prefix, p.name));
+        } else {
+            label.push_str(&format!("{}{}: {}", p.prefix, p.name, ts.join(", ")));
+        }
+        if p.input {
+            inputs.push(params.len());
+        }
+        params.push((p.name.clone(), start..label.len()));
+    }
+    label.push(')');
     let ret = parts
         .ret
         .as_ref()
@@ -3245,24 +5659,34 @@ fn render_signature(parts: SigParts, session: &Session) -> String {
         .filter(|ts| !ts.is_empty())
         .map(|ts| ts.join(", "))
         .or(parts.ret_name);
-    let ret = ret.map(|r| format!(" → {r}")).unwrap_or_default();
-    format!("{}({}){ret}", parts.name, params.join(", "))
+    if let Some(r) = ret {
+        label.push_str(&format!(" → {r}"));
+    }
+    SignatureLine {
+        label,
+        params,
+        inputs,
+    }
 }
 
 /// A callable's function signature —
 /// `calculateDeltaV(isp: specificImpulse, g0: ISQ::acceleration) →
-/// ISQ::speed` — from its directed parameters and return parameter,
-/// for every metaclass an invocation expression can call: the SysML
-/// calc/constraint/action definitions AND usages (a package-level
-/// `calc <ln> naturalLogarithm { … }` is a CalculationUsage), and the
-/// KerML behavioral classifiers (`function`, `predicate`, `behavior`).
+/// ISQ::speed` — from the parameters it owns or inherits (see
+/// [`crate::receiver::parameters`]) and the closest return parameter
+/// (see [`crate::receiver::result_parameter`]), for every metaclass an
+/// invocation expression can call: the SysML calc/constraint/action
+/// definitions AND usages (a package-level `calc <ln> naturalLogarithm
+/// { … }` is a CalculationUsage), and the KerML behavioral classifiers
+/// (`function`, `predicate`, `behavior`).
 /// `in` is the implied direction and stays silent; `out`/`inout` are
-/// spelled. `None` for other metaclasses and for callables declaring
-/// no parameters (the bare card already says everything).
+/// spelled. Types read as `at` sees them (see [`SigTypes`]). `None` for
+/// other metaclasses and for callables with neither parameters nor a
+/// result, own or inherited (the bare card already says everything).
 fn def_signature(
     resolved: &mut sysmlv2_parser::json::ResolvedModel,
     target: ElementRef,
     metaclass: &str,
+    at: &SigAt,
 ) -> Option<SigParts> {
     if !matches!(
         metaclass,
@@ -3278,91 +5702,199 @@ fn def_signature(
     ) {
         return None;
     }
-    let ret = resolved.calc_return_param(target);
-    let params: Vec<ElementRef> = resolved
-        .owned_features(target)
-        .into_iter()
-        .filter(|p| Some(*p) != ret && resolved.declared_direction(*p).is_some())
-        .collect();
+    let ret = crate::receiver::result_parameter(resolved, target);
+    let params = crate::receiver::parameters(resolved, target);
     if params.is_empty() && ret.is_none() {
         return None;
     }
-    let name = resolved
-        .element_name(target)
-        .unwrap_or("<anonymous>")
-        .to_string();
+    // `calc :>> ke { … }` is called by what it redefines.
+    let name = crate::receiver::feature_name(resolved, target)
+        .unwrap_or_else(|| "<anonymous>".to_string());
     let params: Vec<SigParam> = params
         .into_iter()
-        .map(|p| SigParam {
+        .map(|(p, name)| SigParam {
             prefix: match resolved.declared_direction(p) {
                 Some("in") | None => String::new(),
                 Some(dir) => format!("{dir} "),
             },
-            name: resolved.element_name(p).unwrap_or("_").to_string(),
-            types: spelled_types(resolved, p),
+            name: name.unwrap_or_else(|| "_".to_string()),
+            types: spelled_types(resolved, p, at),
+            input: crate::receiver::binds_argument(resolved, p),
         })
         .collect();
     Some(SigParts {
         name,
-        ret: ret.map(|r| spelled_types(resolved, r)),
+        ret: ret.map(|r| spelled_types(resolved, r, at)),
         ret_name: ret.and_then(|r| resolved.element_name(r).map(str::to_string)),
         params,
     })
 }
 
-/// The edits accepting `name` should perform, beyond inserting the
-/// label: restricted names insert quoted (`'m/s²'` — the raw label
-/// would parse as an expression) over the typed spelling (see
-/// [`crate::autoimport::replace_range_for`]), and the autofix tier's
-/// statement repairs ride along — the suffix on the main edit, the
-/// rest as a separate insertion past the cursor. When a repair suffix
-/// rides the main edit and the client takes snippets, the edit
-/// carries a `$0` stop between name and suffix: the cursor belongs
-/// where typing continues, before the auto-inserted `];`, not after
-/// it. `(None, None, None)` for a basic name needing no repairs:
-/// plain label insertion is right and keeps the item light.
-fn item_edits(
-    text: &str,
-    mapper: &Mapper<'_>,
-    cx: &CompletionCx,
-    dialect: sysmlv2_parser::ast::Dialect,
-    name: &str,
-    snippets: bool,
-) -> (
-    Option<lsp_types::CompletionTextEdit>,
-    Option<TextEdit>,
-    Option<lsp_types::InsertTextFormat>,
-) {
-    // Insert text is source for this document: a name the dialect
-    // reserves (`'view'`) and a non-basic name are quoted, a word the
-    // dialect does not reserve stays bare — the label keeps the raw name.
-    let escaped = sysmlv2_parser::name::spell_name_in(Some(dialect), name);
-    let range = crate::autoimport::replace_range_for(text, cx.partial_start, cx.offset, name);
-    let repairs = crate::autofix::statement_repairs(text, cx.stmt_start, range.start, cx.offset);
-    let (suffix, insert) = match repairs {
-        Some(r) => (r.suffix, r.insert),
-        None => (String::new(), None),
+/// An item a list offers by simple name, as the declare-the-type edits
+/// read it: its index in the list, the symbol's name and path, and the
+/// document declaring it (`None`: the library).
+type Offered = (usize, String, String, Option<String>);
+
+/// What the item at `index` offering `s` was built from.
+fn offered(index: usize, s: &QualifiedSymbol) -> Offered {
+    let site = s.site.as_ref().map(|(uri, _)| uri.clone());
+    (index, s.name.clone(), s.qualified.clone(), site)
+}
+
+/// The element the symbol at `qualified`, declared in the document
+/// `site` (`None`: the library), stands for in a session whose units
+/// are `unit_of` by name: the one its path names from the root, unless
+/// another document declares the path's top-level package too and the
+/// path finds that one's — then the one it names inside the top-level
+/// package of the document declaring it. `tops` holds the top-level
+/// elements by unit and name, once a symbol needed them.
+fn declared_element(
+    resolved: &mut sysmlv2_parser::json::ResolvedModel,
+    qualified: &str,
+    site: Option<&str>,
+    unit_of: &HashMap<String, usize>,
+    tops: &mut Option<HashMap<(usize, String), ElementRef>>,
+) -> Option<ElementRef> {
+    let by_path = resolved.resolve_qualified(qualified);
+    let Some(unit) = site.and_then(|uri| unit_of.get(uri)).copied() else {
+        return by_path;
     };
-    let snippet = snippets && !suffix.is_empty();
-    let text_edit = (escaped != name || !suffix.is_empty()).then(|| {
-        lsp_types::CompletionTextEdit::Edit(TextEdit {
-            range: mapper.range(range),
-            new_text: if snippet {
-                format!("{}$0{suffix}", snippet_escape(&escaped))
-            } else {
-                format!("{escaped}{suffix}")
-            },
-        })
+    let declared_here = |resolved: &sysmlv2_parser::json::ResolvedModel, e: ElementRef| {
+        resolved.member_extent(e).is_some_and(|(u, _)| u == unit)
+    };
+    if by_path.is_some_and(|e| declared_here(resolved, e)) {
+        return by_path;
+    }
+    let mut segments = qualified.split("::");
+    let first = segments.next()?;
+    let tops = tops.get_or_insert_with(|| {
+        let elements: Vec<ElementRef> = resolved.user_elements().collect();
+        let mut out = HashMap::new();
+        for e in elements {
+            let top = resolved
+                .owner(e)
+                .is_some_and(|root| resolved.owner(root).is_none());
+            let site = resolved.member_extent(e).map(|(u, _)| u);
+            if let (true, Some(u), Some(name)) = (top, site, resolved.element_name(e)) {
+                out.entry((u, name.to_string())).or_insert(e);
+            }
+        }
+        out
     });
-    let extra = insert.map(|(at, fix)| TextEdit {
-        range: mapper.range(Span::new(at, at)),
-        new_text: fix,
+    let top = *tops.get(&(unit, first.to_string()))?;
+    let rest: Vec<sysmlv2_parser::ast::Name> = segments
+        .map(|value| sysmlv2_parser::ast::Name {
+            value: value.to_string(),
+            span: Span::default(),
+        })
+        .collect();
+    if rest.is_empty() {
+        return Some(top);
+    }
+    let path = sysmlv2_parser::ast::QualifiedName {
+        is_global: false,
+        segments: rest,
+        span: Span::default(),
+    };
+    resolved.member_of(top, &path).map(|(e, _)| e)
+}
+
+/// What accepting `s` by simple name takes to resolve at the cursor
+/// `auto` describes: `Some(None)` nothing, `Some(Some(edit))` the import
+/// `edit`, `None` when no import gives it — a member of a type, or a
+/// usage without a name of its own, outside its owner, a name that finds
+/// something else at the cursor (see
+/// [`crate::autoimport::AutoImport::needs`]), or a symbol its own or an
+/// ancestor's visibility keeps from being named here by its path, which
+/// only an existing import the symbol tables follow, or one through a
+/// package re-exporting it, brings in.
+fn reach(
+    auto: &crate::autoimport::AutoImport<'_>,
+    s: &QualifiedSymbol,
+) -> Option<Option<crate::autoimport::ImportEdit>> {
+    use crate::autoimport::Needs;
+    if s.depth == 0 {
+        return Some(None);
+    }
+    // A member of a type, or of something a type holds, has no path an
+    // import could name: it is offered by its simple name where that
+    // name finds it — inside its owner, inside what inherits it, and
+    // where an import in scope brings it in. So is a usage without a
+    // name of its own, by the name it is found by: elsewhere that name
+    // is the feature's own, or another member's.
+    if !s.importable || s.effective {
+        let found = s
+            .parent()
+            .is_some_and(|owner| auto.may_find(&s.name, &s.qualified, owner))
+            && matches!(auto.needs(&s.name, &s.qualified), Needs::Nothing);
+        return found.then_some(None);
+    }
+    let seen = if !s.public {
+        auto.sees_hidden(&s.name, &s.qualified)
+    } else if s.enclosed().is_some_and(|ns| !auto.inside(ns)) {
+        auto.sees_enclosed(&s.name, &s.qualified)
+    } else {
+        return match auto.needs(&s.name, &s.qualified) {
+            Needs::Nothing => Some(None),
+            Needs::Import(edit) => Some(Some(edit)),
+            Needs::Qualifier => None,
+        };
+    };
+    if seen {
+        return Some(None);
+    }
+    match auto.needs(&s.name, &s.qualified) {
+        Needs::Import(edit) if edit.route.is_some() => Some(Some(edit)),
+        Needs::Nothing | Needs::Import(_) | Needs::Qualifier => None,
+    }
+}
+
+/// The text edit and source annotation of the import `edit` accepting
+/// `s` by simple name needs: the annotation names the package the import
+/// runs through, spelled as the statement spells it in `dialect`.
+fn import_for(
+    mapper: &Mapper<'_>,
+    dialect: sysmlv2_parser::ast::Dialect,
+    s: &QualifiedSymbol,
+    edit: crate::autoimport::ImportEdit,
+) -> Option<(Vec<TextEdit>, lsp_types::CompletionItemLabelDetails)> {
+    let parent = edit
+        .route
+        .as_deref()
+        .unwrap_or(&s.qualified)
+        .strip_suffix(s.name.as_str())?
+        .strip_suffix("::")?;
+    // Most paths need no quote: those are taken as they are.
+    let plain = parent.split("::").all(|segment| {
+        segment
+            .chars()
+            .next()
+            .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+            && segment
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '_')
+            && !sysmlv2_parser::parser::is_reserved(dialect, segment)
     });
-    (
-        text_edit,
-        extra,
-        snippet.then_some(lsp_types::InsertTextFormat::SNIPPET),
-    )
+    let parent: std::borrow::Cow<'_, str> = if plain {
+        parent.into()
+    } else {
+        crate::autoimport::escape_qualified(dialect, parent).into()
+    };
+    let description = if edit.global {
+        format!("import $::{parent}")
+    } else {
+        format!("import {parent}")
+    };
+    Some((
+        vec![TextEdit {
+            range: mapper.range(Span::new(edit.at, edit.at)),
+            new_text: edit.text,
+        }],
+        lsp_types::CompletionItemLabelDetails {
+            detail: None,
+            description: Some(description),
+        },
+    ))
 }
 
 /// A member's completion-item kind from its abstract-syntax metaclass
@@ -3382,20 +5914,11 @@ fn member_kind(meta: &str) -> lsp_types::CompletionItemKind {
     }
 }
 
-/// A completion's literal text made safe for snippet-format delivery:
-/// `$`, `}`, and `\` are snippet syntax and must arrive escaped.
-fn snippet_escape(text: &str) -> String {
-    let mut out = String::with_capacity(text.len());
-    for c in text.chars() {
-        if matches!(c, '$' | '}' | '\\') {
-            out.push('\\');
-        }
-        out.push(c);
-    }
-    out
-}
-
-pub(crate) fn completion_context(text: &str, offset: u32) -> CompletionCx {
+pub(crate) fn completion_context(
+    text: &str,
+    offset: u32,
+    dialect: sysmlv2_parser::ast::Dialect,
+) -> CompletionCx {
     let bytes = text.as_bytes();
     let is_ident = |b: u8| b.is_ascii_alphanumeric() || b == b'_';
     let offset = (offset as usize).min(bytes.len());
@@ -3439,49 +5962,121 @@ pub(crate) fn completion_context(text: &str, offset: u32) -> CompletionCx {
         }
         dot_chain.reverse();
     }
-    let stmt_start = text[..j].rfind([';', '{', '}']).map(|k| k + 1).unwrap_or(0);
-    let import = text[stmt_start..j]
-        .split(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
-        .any(|w| w == "import");
+    // A qualified name stands where its first segment does: the position
+    // is read off the text ahead of it (`attribute x : ISQ::Mas` takes
+    // what a typing takes), a global `$::` included.
+    let word_start = if qualifier.is_empty() {
+        partial_start
+    } else if text[..j].ends_with("$::") {
+        j - 3
+    } else {
+        j
+    };
+    let scan = crate::site::scan(text, offset32(word_start), offset32(offset), dialect);
     CompletionCx {
         qualifier,
         dot_chain,
         partial_start: offset32(partial_start),
         offset: offset32(offset),
-        import,
-        stmt_start: offset32(stmt_start),
+        import: scan.import,
+        stmt_start: scan.stmt_start,
+        quoted: scan
+            .quote
+            .and_then(|open| crate::accept::quoted_from(text, open, offset32(offset))),
+        in_bracket: scan.in_bracket,
+        slot: scan.slot,
     }
 }
 
+#[cfg(test)]
+thread_local! {
+    /// Answers read off a session built from other texts on this thread
+    /// (see [`Nav::cut_answer`]), so a test can pin where one was.
+    pub(crate) static REUSED_ANSWERS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+#[cfg(test)]
+thread_local! {
+    /// Session builds on this thread, so a test can pin what a request
+    /// costs.
+    pub(crate) static SESSION_BUILDS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    /// Enclosing elements' member lists read off a model on this thread.
+    pub(crate) static MEMBER_READS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
 #[cfg(test)]
 mod context_tests {
-    use super::completion_context;
+    use super::{completion_context, offset32};
+    use sysmlv2_parser::ast::Dialect;
+
+    #[test]
+    fn open_bracket_detection() {
+        for (stmt, open) in [
+            ("attribute g = 9.8 [", true),
+            ("attribute g = 9.8 [m/", true),
+            // the completion's own opening quote keeps it open
+            ("attribute g = 9.8 ['", true),
+            // closed again: an expression continues
+            ("attribute g = 9.8 [m] + ", false),
+            ("attribute g : ", false),
+            // a multiplicity counts, nested brackets count once open
+            ("part w : Wheel [0..", true),
+            ("attribute a = b[c[d]", true),
+            // brackets in strings, quoted names, and comments do not
+            ("attribute s = \"[\" + ", false),
+            ("attribute s = 'a[' + ", false),
+            ("attribute s /* [ */ = ", false),
+            ("attribute s // [\n = ", false),
+            // an unterminated string or comment is not a bracket
+            ("attribute s = \"a [", false),
+            ("attribute s /* [", false),
+            // a note runs to its `*/`, across lines
+            ("attribute g = 9.8 //* see\n [ */ + ", false),
+            ("attribute g = 9.8 [ //* see\n ] */ + ", true),
+            // statement boundaries count only as tokens: a `;` inside a
+            // comment neither ends the statement nor exposes the text
+            // after it
+            (
+                "part def V {\n doc /* mass; it's wet */\n attribute a = 9.8 [",
+                true,
+            ),
+            ("part def V {\n /* note; [draft */\n attribute x : ", false),
+            // a statement boundary closes what the statement left open
+            ("attribute a = 9.8 [m;\n attribute b : ", false),
+        ] {
+            assert_eq!(
+                completion_context(stmt, offset32(stmt.len()), Dialect::Sysml).in_bracket,
+                open,
+                "{stmt:?}"
+            );
+        }
+    }
 
     #[test]
     fn qualifier_and_import_detection() {
         let text = "package P { private import ScalarFunctions:: }";
-        let cx = completion_context(text, 44);
+        let cx = completion_context(text, 44, Dialect::Sysml);
         assert_eq!(cx.qualifier, vec!["ScalarFunctions"]);
         assert!(cx.import);
 
         let text = "package P { private import Real }";
-        let cx = completion_context(text, 31);
+        let cx = completion_context(text, 31, Dialect::Sysml);
         assert!(cx.qualifier.is_empty());
         assert!(cx.import);
         assert_eq!(&text[cx.partial_start as usize..cx.offset as usize], "Real");
 
         let text = "package P { part x : ISQ::Torque }";
-        let cx = completion_context(text, 32);
+        let cx = completion_context(text, 32, Dialect::Sysml);
         assert_eq!(cx.qualifier, vec!["ISQ"]);
         assert!(!cx.import);
 
         let text = "package P { import A::B:: }";
-        let cx = completion_context(text, 25);
+        let cx = completion_context(text, 25, Dialect::Sysml);
         assert_eq!(cx.qualifier, vec!["A", "B"]);
         assert!(cx.import);
 
         let text = "part w : ";
-        let cx = completion_context(text, 9);
+        let cx = completion_context(text, 9, Dialect::Sysml);
         assert!(cx.qualifier.is_empty());
         assert!(!cx.import);
     }
@@ -3490,26 +6085,26 @@ mod context_tests {
     fn dot_chain_detection() {
         // Bare dot, and a partial after it.
         let text = "package P { attribute t = fuelTank. }";
-        let cx = completion_context(text, 35);
+        let cx = completion_context(text, 35, Dialect::Sysml);
         assert_eq!(cx.dot_chain, vec!["fuelTank"]);
         let text = "package P { attribute t = fuelTank.vol }";
-        let cx = completion_context(text, 38);
+        let cx = completion_context(text, 38, Dialect::Sysml);
         assert_eq!(cx.dot_chain, vec!["fuelTank"]);
         assert_eq!(&text[cx.partial_start as usize..cx.offset as usize], "vol");
 
         // Multi-hop chains keep every segment, in order.
         let text = "package P { attribute t = sys.tank.liq }";
-        let cx = completion_context(text, 38);
+        let cx = completion_context(text, 38, Dialect::Sysml);
         assert_eq!(cx.dot_chain, vec!["sys", "tank"]);
 
         // A literal's decimal point is no chain step.
         let text = "package P { attribute t = 9.8 }";
-        let cx = completion_context(text, 29);
+        let cx = completion_context(text, 29, Dialect::Sysml);
         assert!(cx.dot_chain.is_empty());
 
         // `::` qualifiers keep their own context.
         let text = "package P { part x : ISQ::Torque }";
-        let cx = completion_context(text, 32);
+        let cx = completion_context(text, 32, Dialect::Sysml);
         assert!(cx.dot_chain.is_empty());
     }
 }
diff --git a/crates/sysmlv2-lsp/src/nav/namespaces.rs b/crates/sysmlv2-lsp/src/nav/namespaces.rs
new file mode 100644
index 0000000..b51116e
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/nav/namespaces.rs
@@ -0,0 +1,1381 @@
+//! The completion tier's symbol tables and what their namespaces make
+//! visible. A table holds the qualified symbols of a set of units,
+//! flattened from their outlines, and the `import` statements their
+//! namespaces declare; it answers which members a namespace makes
+//! visible beyond the ones it owns — what its public imports bring in,
+//! directly or through the imported namespaces' own public imports —
+//! without a model build.
+//!
+//! Targets resolve the way the notation reads them, as far as a syntax
+//! tier can: the first segment among the owned members of the
+//! namespace the import sits in, then of each enclosing namespace out
+//! to the root; each later segment among the visible members of the
+//! namespace before it. Tables layer: the document being completed
+//! over the rest of the workspace over the library, lookups falling
+//! through, each layer's imports naming namespaces of its own or of the
+//! layers below. A layer keeps what it works out for as long as it
+//! lives, so the library's answers last the session and the rest of
+//! the workspace's last while no other document changes.
+//!
+//! What a namespace makes visible is decided once per namespace — for
+//! its clients, and for a name written inside it
+//! ([`SymbolTable::names`]) — and serves every question asked of it —
+//! what a qualifier lists, whether an existing import provides a name,
+//! which package an inserted import may run through — so the answers
+//! cannot disagree: an owned member hides an imported one of the same
+//! name from whoever sees it at every step of a re-export chain, and a
+//! name two imports bring in for different elements denotes neither.
+
+use super::QualifiedSymbol;
+use crate::autoimport::Brought;
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, Mutex};
+
+#[cfg(test)]
+thread_local! {
+    /// The tables' work on this thread, so a test can pin what a
+    /// completion request costs: symbols indexed into a table,
+    /// namespaces whose visible names were worked out, and namespaces
+    /// whose routes were walked.
+    pub(crate) static WORK: std::cell::Cell<[usize; 3]> = const { std::cell::Cell::new([0; 3]) };
+}
+
+thread_local! {
+    /// The views being worked out on this thread (see
+    /// [`SymbolTable::guarded`]).
+    static WORKING: std::cell::RefCell<Working> = std::cell::RefCell::default();
+}
+
+/// The views being worked out on a thread: a view asked for again while
+/// it is worked out — through a name looked up on the way, say — is a
+/// cycle, cut there, and every view begun since works with an answer
+/// short of what that one comes to: those are not kept.
+#[derive(Default)]
+struct Working {
+    /// Each view being worked out, by table and view, at its depth.
+    open: HashMap<(usize, String), usize>,
+    /// The shallowest depth a cut leaves short, if any.
+    short: Option<usize>,
+}
+
+/// A view being worked out (see [`SymbolTable::guarded`]), left once
+/// done — or when the work unwinds, so a view a request gave up on is
+/// not taken for one under way by the next.
+struct Open {
+    id: (usize, String),
+    depth: usize,
+    left: bool,
+}
+
+impl Open {
+    /// Leave the view, done: whether its answer is whole, no cut on the
+    /// way having left it short.
+    fn leave(mut self) -> bool {
+        self.left = true;
+        WORKING.with(|w| {
+            let mut w = w.borrow_mut();
+            w.open.remove(&self.id);
+            let short = w.short.is_some_and(|d| d <= self.depth);
+            if w.short.is_some_and(|d| d >= self.depth) {
+                w.short = None;
+            }
+            !short
+        })
+    }
+}
+
+impl Drop for Open {
+    fn drop(&mut self) {
+        if !self.left {
+            WORKING.with(|w| {
+                let mut w = w.borrow_mut();
+                w.open.remove(&self.id);
+                if w.short.is_some_and(|d| d >= self.depth) {
+                    w.short = None;
+                }
+            });
+        }
+    }
+}
+
+/// Count `n` units of the work at `slot` of [`WORK`].
+#[cfg(test)]
+fn work(slot: usize, n: usize) {
+    WORK.with(|w| {
+        let mut counts = w.get();
+        counts[slot] += n;
+        w.set(counts);
+    });
+}
+
+/// What an import brings into its namespace.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Reach {
+    /// `import T;` — the one member `T` names.
+    Member,
+    /// `import T::*;` — the members of `T`.
+    Members,
+    /// `import T::*::**;` — the members of `T` and, recursively, of the
+    /// namespaces among them. `import T::**;` is recorded as a `Member`
+    /// and a `Recursive`.
+    Recursive,
+}
+
+/// Whose view of a namespace's names is asked for.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) enum Access {
+    /// A client outside the namespace: its public members, and what its
+    /// public imports bring in.
+    Clients,
+    /// A name written inside the namespace, or an `import all` of it:
+    /// every member, and what every import brings in.
+    Inside,
+}
+
+/// One import statement, as a table records it.
+#[derive(Clone, Debug)]
+pub(super) struct ImportRecord {
+    /// The importing namespace's qualified path (`""`: the root).
+    pub owner: String,
+    /// The target as written: one raw name per segment.
+    pub target: Vec<String>,
+    /// `$::`-rooted: resolved from the root, not from the owner.
+    pub global: bool,
+    pub reach: Reach,
+    /// Re-exported to the namespace's clients: `public`, or no
+    /// visibility keyword at all.
+    pub public: bool,
+    /// `import all`: brings in what a name written inside the target
+    /// finds there, whatever its visibility.
+    pub all: bool,
+    /// Conditioned by a filter: brings in only the members the
+    /// condition admits, which the syntax tier cannot tell.
+    pub filtered: bool,
+    /// The declaring unit of a workspace import (the key of
+    /// [`QualifiedSymbol`]'s site), so a seeded unit's imports are
+    /// shadowed with its symbols while the unit is open.
+    pub unit: Option<String>,
+    /// The target's qualified path, once the table resolved it.
+    resolved: Option<String>,
+}
+
+impl ImportRecord {
+    /// Does the import make what it brings in visible to the
+    /// namespace's clients, as far as the syntax tier can tell? A
+    /// filtered one counts as bringing in nothing.
+    fn reexports(&self) -> bool {
+        self.public && !self.filtered
+    }
+
+    pub(super) fn new(
+        owner: &str,
+        form: &crate::outline::ImportForm,
+        reach: Reach,
+        unit: Option<&str>,
+    ) -> ImportRecord {
+        ImportRecord {
+            owner: owner.to_string(),
+            target: form.target.clone(),
+            global: form.global,
+            reach,
+            public: form.public,
+            all: form.all,
+            filtered: form.filtered,
+            unit: unit.map(str::to_string),
+            resolved: None,
+        }
+    }
+}
+
+/// What a walk over the units records besides their symbols.
+#[derive(Clone, Default)]
+pub(super) struct Links {
+    pub imports: Vec<ImportRecord>,
+    /// What each declaration specializes, as written (see
+    /// [`crate::outline::Base`]), by its qualified path.
+    pub bases: Vec<(String, Vec<crate::outline::Base>)>,
+}
+
+impl Links {
+    /// Record the import at an outline node inside `owner`: one record,
+    /// or two for `import T::**;`.
+    pub(super) fn import(
+        &mut self,
+        owner: &str,
+        form: &crate::outline::ImportForm,
+        unit: Option<&str>,
+    ) {
+        let reaches: &[Reach] = match (form.namespace, form.recursive) {
+            (false, false) => &[Reach::Member],
+            (true, false) => &[Reach::Members],
+            (true, true) => &[Reach::Recursive],
+            (false, true) => &[Reach::Member, Reach::Recursive],
+        };
+        for &reach in reaches {
+            self.imports
+                .push(ImportRecord::new(owner, form, reach, unit));
+        }
+    }
+}
+
+/// What a namespace makes visible, by name, in the order the names come
+/// in: the qualified path of the one element each denotes there, or
+/// none when two of the namespace's imports bring in different elements
+/// under it — an ambiguous reference. A name comes in at a tier — the
+/// namespace's own members, what its imports of one member bring in,
+/// what its imports of a namespace's members do — and one that came in
+/// at an earlier tier hides it at a later one.
+#[derive(Default)]
+pub(super) struct Names {
+    entries: Vec<(String, Option<String>, u8)>,
+    index: HashMap<String, usize>,
+}
+
+impl Names {
+    /// What `name` denotes: `None` when nothing is visible under it,
+    /// `Some(None)` when it is ambiguous.
+    fn get(&self, name: &str) -> Option<Option<&str>> {
+        self.index.get(name).map(|&i| self.entries[i].1.as_deref())
+    }
+
+    /// Record that `name` denotes the element at `path` (`None`: an
+    /// ambiguous name brought in whole), coming in at `tier`: a
+    /// different element at the same tier makes it ambiguous, one at an
+    /// earlier tier replaces it, one at a later tier is hidden.
+    fn add(&mut self, tier: u8, name: &str, path: Option<&str>) {
+        match self.index.get(name) {
+            None => {
+                self.index.insert(name.to_string(), self.entries.len());
+                self.entries
+                    .push((name.to_string(), path.map(str::to_string), tier));
+            }
+            Some(&i) => {
+                let (_, known, at) = &mut self.entries[i];
+                if tier < *at {
+                    *known = path.map(str::to_string);
+                    *at = tier;
+                } else if tier == *at && known.as_deref() != path {
+                    *known = None;
+                }
+            }
+        }
+    }
+
+    /// Every name with what it denotes, in order.
+    fn iter(&self) -> impl Iterator<Item = (&str, Option<&str>)> {
+        self.entries
+            .iter()
+            .map(|(name, path, _)| (name.as_str(), path.as_deref()))
+    }
+}
+
+/// The tiers names come in at (see [`Names`]).
+const OWNED: u8 = 0;
+const IMPORTED_MEMBER: u8 = 1;
+const IMPORTED_MEMBERS: u8 = 2;
+
+/// The qualified symbols and imports of a set of units, indexed.
+#[derive(Default)]
+pub(crate) struct SymbolTable {
+    symbols: Vec<QualifiedSymbol>,
+    imports: Vec<ImportRecord>,
+    /// Qualified path → the first symbol declaring it.
+    by_path: HashMap<String, usize>,
+    /// Namespace path (`""`: the root) → its members, in order.
+    by_parent: HashMap<String, Vec<usize>>,
+    /// Namespace path → the imports it declares, in order.
+    by_owner: HashMap<String, Vec<usize>>,
+    /// Resolved target path → the re-exporting imports naming it.
+    by_target: HashMap<String, Vec<usize>>,
+    /// The namespace owning a re-exporting single-member import's target
+    /// → those imports.
+    singles: HashMap<String, Vec<usize>>,
+    /// The table lookups fall through to (the library's, for a
+    /// workspace table).
+    base: Option<Arc<SymbolTable>>,
+    /// [`Self::names`], by view and namespace, as they are asked for.
+    visible: Mutex<[HashMap<String, Arc<Names>>; 2]>,
+    /// [`Self::recursive_in`], by view and namespace, as they are asked
+    /// for.
+    recursive: Mutex<[HashMap<String, Arc<Names>>; 2]>,
+    /// What each declaration this table holds specializes, as written,
+    /// by its qualified path (see [`Links::bases`]).
+    written: HashMap<String, Vec<crate::outline::Base>>,
+    /// [`Self::bases_of`], by element, as they are asked for.
+    bases: Mutex<HashMap<String, Arc<[String]>>>,
+    /// [`Self::inherited`], by element, as they are asked for.
+    inheritance: Mutex<HashMap<String, Arc<Names>>>,
+    /// [`Self::heritage`], by element, as they are asked for.
+    heritage: Mutex<HashMap<String, Arc<Names>>>,
+    /// [`Self::routes_of`], by namespace, as they are asked for.
+    routes: Mutex<HashMap<String, Arc<Routes>>>,
+}
+
+/// The routes to a namespace's members: those that see all of them,
+/// and, for a member a single-member import names, those that see it
+/// alone too — each list best first.
+#[derive(Default)]
+struct Routes {
+    /// The segments of the namespace's own path.
+    segments: usize,
+    members: Vec<Route>,
+    singles: Vec<(String, Vec<Route>)>,
+}
+
+impl Routes {
+    /// The routes to the member named `name`.
+    fn to(&self, name: &str) -> &[Route] {
+        self.singles
+            .iter()
+            .find(|(n, _)| n == name)
+            .map_or(&self.members, |(_, routes)| routes)
+    }
+}
+
+/// A top-level package that sees a namespace's members under their
+/// own names: how well it names them (see [`SymbolTable::import_path`])
+/// and the number of imports on the way. What the package makes
+/// visible is asked of the table choosing the path, never kept here:
+/// the layers above the one that worked the routes out share them, and
+/// a layer above can declare in the package itself.
+#[derive(Clone)]
+struct Route {
+    rank: u8,
+    hops: usize,
+    package: String,
+}
+
+impl Route {
+    fn key(&self) -> (u8, usize, &str) {
+        (self.rank, self.hops, &self.package)
+    }
+}
+
+impl SymbolTable {
+    /// The table's symbols: its own, then those of the workspace layers
+    /// below it — never the library's, which a library table alone
+    /// yields.
+    pub(super) fn iter(&self) -> impl Iterator<Item = &QualifiedSymbol> {
+        std::iter::successors(Some(self), |t| {
+            t.base.as_deref().filter(|b| b.base.is_some())
+        })
+        .flat_map(|t| t.symbols.iter())
+    }
+
+    /// The table's own symbols, not those of the layers below.
+    pub(super) fn symbols(&self) -> &[QualifiedSymbol] {
+        &self.symbols
+    }
+
+    /// This table and the ones below it, topmost first.
+    fn layers(&self) -> impl Iterator<Item = &SymbolTable> {
+        std::iter::successors(Some(self), |t| t.base.as_deref())
+    }
+
+    /// Would a re-exporting import the table could not resolve on its
+    /// own resolve over `top`, a layer above it? Only those change what
+    /// a namespace makes visible: a private import's target decides
+    /// nothing a client sees.
+    pub(super) fn resolves_above(&self, top: &SymbolTable) -> bool {
+        self.imports
+            .iter()
+            .filter(|imp| imp.resolved.is_none() && imp.reexports())
+            .any(|imp| top.resolve(&imp.owner, &imp.target, imp.global).is_some())
+    }
+
+    /// The table's own symbols and imports, for a table built anew.
+    pub(super) fn parts(&self) -> (Vec<QualifiedSymbol>, Links) {
+        let mut imports = self.imports.clone();
+        for imp in &mut imports {
+            imp.resolved = None;
+        }
+        let bases = self
+            .written
+            .iter()
+            .map(|(path, bases)| (path.clone(), bases.clone()))
+            .collect();
+        (self.symbols.clone(), Links { imports, bases })
+    }
+
+    /// Index `symbols` and `links` over `base` and resolve the import
+    /// targets.
+    pub(super) fn new(
+        symbols: Vec<QualifiedSymbol>,
+        links: Links,
+        base: Option<Arc<SymbolTable>>,
+    ) -> SymbolTable {
+        #[cfg(test)]
+        work(0, symbols.len());
+        let mut table = SymbolTable {
+            symbols,
+            imports: links.imports,
+            base,
+            ..SymbolTable::default()
+        };
+        for (path, bases) in links.bases {
+            table.written.entry(path).or_insert(bases);
+        }
+        for (i, s) in table.symbols.iter().enumerate() {
+            table.by_path.entry(s.qualified.clone()).or_insert(i);
+            if let Some(parent) = parent_of(s) {
+                table
+                    .by_parent
+                    .entry(parent.to_string())
+                    .or_default()
+                    .push(i);
+            }
+        }
+        for (i, imp) in table.imports.iter().enumerate() {
+            table.by_owner.entry(imp.owner.clone()).or_default().push(i);
+        }
+        // A target reached through another namespace's public import
+        // needs that import resolved first: each round picks up what the
+        // previous one made reachable, until one resolves nothing new.
+        loop {
+            let resolved: Vec<(usize, String)> = table
+                .imports
+                .iter()
+                .enumerate()
+                .filter(|(_, imp)| imp.resolved.is_none())
+                .filter_map(|(i, imp)| {
+                    table
+                        .resolve(&imp.owner, &imp.target, imp.global)
+                        .map(|path| (i, path))
+                })
+                .collect();
+            if resolved.is_empty() {
+                break;
+            }
+            for (i, path) in resolved {
+                table.imports[i].resolved = Some(path);
+            }
+        }
+        for (i, imp) in table.imports.iter().enumerate() {
+            if let Some(target) = imp.resolved.as_ref().filter(|_| imp.reexports()) {
+                table.by_target.entry(target.clone()).or_default().push(i);
+                if imp.reach == Reach::Member {
+                    let parent = enclosing(target).unwrap_or_default();
+                    table.singles.entry(parent.to_string()).or_default().push(i);
+                }
+            }
+        }
+        table.resolve_aliases();
+        table
+    }
+
+    /// Take each alias as what it names (see [`Self::alias_target`]):
+    /// its target's kind, declaration, and types — completion shows,
+    /// admits, and ranks it so — and whether an operator names a
+    /// function by it. One whose target does not resolve keeps what it
+    /// was collected with.
+    fn resolve_aliases(&mut self) {
+        let named: Vec<_> = (0..self.symbols.len())
+            .filter(|&i| self.symbols[i].alias.is_some())
+            .filter_map(|i| {
+                let t = self.alias_target(i)?;
+                Some((i, t.kind, t.decl, t.types.clone()))
+            })
+            .collect();
+        for (i, kind, decl, types) in named {
+            let s = &mut self.symbols[i];
+            s.operator = super::is_operator_spelling(&s.name)
+                && matches!(
+                    kind,
+                    lsp_types::CompletionItemKind::FUNCTION
+                        | lsp_types::CompletionItemKind::OPERATOR
+                );
+            (s.kind, s.decl, s.types) = (kind, decl, types);
+        }
+    }
+
+    /// The symbol the alias at `i` names: its target read as a name
+    /// written where the alias is ([`Self::resolve_written`]), through
+    /// further aliases of this table — one of a table below is already
+    /// what it names. `None` when a target does not resolve, or the
+    /// aliases lead back to one on the way.
+    fn alias_target(&self, i: usize) -> Option<&QualifiedSymbol> {
+        let mut s = &self.symbols[i];
+        let mut seen = HashSet::new();
+        while let Some(alias) = &s.alias {
+            if !seen.insert(s.qualified.as_str()) {
+                return None;
+            }
+            let path = self.resolve_written(parent_of(s)?, &alias.target, alias.global)?;
+            s = match self.by_path.get(&path) {
+                Some(&j) => &self.symbols[j],
+                None => return self.symbol_at(&path),
+            };
+        }
+        Some(s)
+    }
+
+    /// Resolve a qualified name written inside the namespace at `owner`
+    /// as the notation reads it: the first segment among what each
+    /// namespace from `owner` out to the root finds under it — its
+    /// members, and what its imports bring in, private ones included —
+    /// or from the root alone when `global`; each later segment among
+    /// what the namespace before makes visible to `owner`: every member
+    /// when `owner` is inside it, the public ones otherwise. `None` when
+    /// a segment does not resolve, or names two elements.
+    fn resolve_written(&self, owner: &str, target: &[String], global: bool) -> Option<String> {
+        let (first, rest) = target.split_first()?;
+        let mut scope = Some(if global { "" } else { owner });
+        let mut path = None;
+        while let Some(s) = scope {
+            if let Some(found) = self.name_in(s, Access::Inside, first, &mut HashSet::new()) {
+                path = Some(found?);
+                break;
+            }
+            scope = enclosing(s);
+        }
+        let mut path = path?;
+        for segment in rest {
+            let access = if within(owner, &path) {
+                Access::Inside
+            } else {
+                Access::Clients
+            };
+            path = self.name_in(&path, access, segment, &mut HashSet::new())??;
+        }
+        Some(path)
+    }
+
+    /// What [`Self::names`] holds under `name` for the namespace at
+    /// `ns`, worked out for that one name unless the whole answer is
+    /// known already: a namespace this table declares in is answered
+    /// anew for every table built, and one name rarely needs all it
+    /// makes visible.
+    fn name_in(
+        &self,
+        ns: &str,
+        access: Access,
+        name: &str,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Option<Option<String>> {
+        if let Some(base) = &self.base {
+            if !self.by_parent.contains_key(ns) && !self.by_owner.contains_key(ns) {
+                return base.name_in(ns, access, name, active);
+            }
+        }
+        if let Some(known) = self.visible.lock().expect("visible names")[access as usize].get(ns) {
+            return known.get(name).map(|path| path.map(str::to_string));
+        }
+        let key = (ns.to_string(), access);
+        if !active.insert(key.clone()) {
+            return None;
+        }
+        let found = self.compute_name(ns, access, name, active);
+        active.remove(&key);
+        found
+    }
+
+    /// [`Self::compute_names`] for the one name `name`.
+    fn compute_name(
+        &self,
+        ns: &str,
+        access: Access,
+        name: &str,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Option<Option<String>> {
+        let own = join(ns, name);
+        if self
+            .symbol_at(&own)
+            .is_some_and(|s| access == Access::Inside || s.public)
+        {
+            return Some(Some(own));
+        }
+        // The imports' answers, the earliest tier deciding.
+        let mut found: Option<(u8, Option<String>)> = None;
+        for imp in self.imports_of(ns) {
+            let admitted = match access {
+                Access::Clients => imp.reexports(),
+                Access::Inside => !imp.filtered,
+            };
+            let Some(target) = imp.resolved.as_deref().filter(|_| admitted) else {
+                continue;
+            };
+            let inner = if imp.all {
+                Access::Inside
+            } else {
+                Access::Clients
+            };
+            let (tier, brought) = match imp.reach {
+                Reach::Member => (
+                    IMPORTED_MEMBER,
+                    (imp.target.last().map(String::as_str) == Some(name)
+                        && self.symbol_at(target).is_some_and(|s| imp.all || s.public))
+                    .then(|| Some(target.to_string())),
+                ),
+                Reach::Members => (IMPORTED_MEMBERS, self.name_in(target, inner, name, active)),
+                Reach::Recursive => (
+                    IMPORTED_MEMBERS,
+                    self.recursive_in(target, inner, active)
+                        .get(name)
+                        .map(|path| path.map(str::to_string)),
+                ),
+            };
+            let Some(brought) = brought else {
+                continue;
+            };
+            found = match found {
+                None => Some((tier, brought)),
+                Some((at, _)) if tier < at => Some((tier, brought)),
+                Some((at, known)) if tier == at && known != brought => Some((at, None)),
+                kept => kept,
+            };
+        }
+        found.map(|(_, path)| path)
+    }
+
+    /// The symbol declaring `path`, here or in the base table.
+    pub(super) fn symbol_at(&self, path: &str) -> Option<&QualifiedSymbol> {
+        match self.by_path.get(path) {
+            Some(&i) => Some(&self.symbols[i]),
+            None => self.base.as_ref().and_then(|b| b.symbol_at(path)),
+        }
+    }
+
+    /// The owned members of the namespace at `path`, here and in the
+    /// base table.
+    fn members_of<'s>(&'s self, path: &str, out: &mut Vec<&'s QualifiedSymbol>) {
+        if let Some(members) = self.by_parent.get(path) {
+            out.extend(members.iter().map(|&i| &self.symbols[i]));
+        }
+        if let Some(base) = &self.base {
+            base.members_of(path, out);
+        }
+    }
+
+    /// The imports the namespace at `path` declares, here and in the
+    /// base table.
+    fn imports_of(&self, path: &str) -> Vec<&ImportRecord> {
+        let mut out: Vec<&ImportRecord> = self
+            .by_owner
+            .get(path)
+            .into_iter()
+            .flatten()
+            .map(|&i| &self.imports[i])
+            .collect();
+        if let Some(base) = &self.base {
+            out.extend(base.imports_of(path));
+        }
+        out
+    }
+
+    /// The re-exporting imports whose target resolved to `path`, here
+    /// and in the layers below.
+    fn importers_of<'s>(&'s self, path: &'s str) -> impl Iterator<Item = &'s ImportRecord> {
+        self.layers().flat_map(move |t| {
+            t.by_target
+                .get(path)
+                .into_iter()
+                .flatten()
+                .map(move |&i| &t.imports[i])
+        })
+    }
+
+    /// Every import, here then in the base table.
+    fn all_imports(&self) -> impl Iterator<Item = &ImportRecord> {
+        let base = self
+            .base
+            .iter()
+            .flat_map(|b| b.all_imports().collect::<Vec<_>>());
+        self.imports.iter().chain(base)
+    }
+
+    /// Resolve a qualified name written inside the namespace at
+    /// `owner`: the first segment among the owned members of `owner`,
+    /// then of each enclosing namespace out to the root (from the root
+    /// alone when `global`), each later segment among what the namespace
+    /// before shows `owner` — every member when `owner` is inside it,
+    /// the public ones otherwise.
+    fn resolve(&self, owner: &str, target: &[String], global: bool) -> Option<String> {
+        let (first, rest) = target.split_first()?;
+        let mut scope = Some(if global { "" } else { owner });
+        let mut path = None;
+        while let Some(s) = scope {
+            let candidate = join(s, first);
+            if self.symbol_at(&candidate).is_some() {
+                path = Some(candidate);
+                break;
+            }
+            scope = enclosing(s);
+        }
+        let mut path = path?;
+        for segment in rest {
+            let inside = within(owner, &path);
+            path = self.member_path(&path, segment, inside, &mut HashSet::new())?;
+        }
+        Some(path)
+    }
+
+    /// The qualified path of the member the namespace at `ns` shows
+    /// under `name` — to a name written inside it (`inside`) every
+    /// member, to a client the public ones: its own, else the first its
+    /// imports bring in — every one of them inside it, the public ones
+    /// to a client.
+    fn member_path(
+        &self,
+        ns: &str,
+        name: &str,
+        inside: bool,
+        seen: &mut HashSet<String>,
+    ) -> Option<String> {
+        let own = join(ns, name);
+        if self.symbol_at(&own).is_some_and(|s| inside || s.public) {
+            return Some(own);
+        }
+        if !seen.insert(ns.to_string()) {
+            return None;
+        }
+        for imp in self.imports_of(ns) {
+            let admitted = if inside {
+                !imp.filtered
+            } else {
+                imp.reexports()
+            };
+            let Some(target) = imp.resolved.as_deref().filter(|_| admitted) else {
+                continue;
+            };
+            let found = match imp.reach {
+                Reach::Member => (imp.target.last().map(String::as_str) == Some(name)
+                    && self.symbol_at(target).is_some_and(|s| imp.all || s.public))
+                .then(|| target.to_string()),
+                Reach::Members | Reach::Recursive => self.member_path(target, name, imp.all, seen),
+            };
+            if found.is_some() {
+                return found;
+            }
+        }
+        None
+    }
+
+    /// The members the namespaces a qualifier names make visible
+    /// through their imports — the public ones to a client, every one
+    /// to a name written inside them (`access`) — directly or through
+    /// the imported namespaces' own, in import order, not counting the
+    /// members they own, nor a name that denotes no one element. The
+    /// qualifier matches as [`QualifiedSymbol`] parents do: the path
+    /// itself or any path ending in it.
+    pub(super) fn reexported_members(
+        &self,
+        qualifier: &str,
+        access: Access,
+    ) -> Vec<&QualifiedSymbol> {
+        let suffix = format!("::{qualifier}");
+        let mut owners: Vec<&str> = Vec::new();
+        for imp in self.all_imports() {
+            let owner = imp.owner.as_str();
+            if (owner == qualifier || owner.ends_with(&suffix)) && !owners.contains(&owner) {
+                owners.push(owner);
+            }
+        }
+        let mut out = Vec::new();
+        for owner in owners {
+            let names = self.names(owner, access);
+            for (_, path) in names.iter() {
+                let Some(path) = path.filter(|p| enclosing(p) != Some(owner)) else {
+                    continue;
+                };
+                out.extend(self.symbol_at(path));
+            }
+        }
+        out
+    }
+
+    /// What the namespace at `ns` makes visible, by name, to `access`:
+    /// its own members — the public ones to a client — then what its
+    /// imports bring in — the public ones' to a client — one member,
+    /// the members of a namespace (with what that namespace makes
+    /// visible in turn), or a namespace's contents recursively; an
+    /// `import all` brings in what a name written inside its target
+    /// finds there. An owned member hides an imported one of the same
+    /// name from whoever sees it; a name two imports bring in for
+    /// different elements denotes neither. Decided once per namespace
+    /// and view: a namespace the table declares nothing in is answered
+    /// by the base table, which keeps its answers.
+    pub(super) fn names(&self, ns: &str, access: Access) -> Arc<Names> {
+        self.names_in(ns, access, &mut HashSet::new())
+    }
+
+    /// [`Self::names`], with the namespaces whose answer is being worked
+    /// out further up: an import cycle adds nothing more.
+    fn names_in(
+        &self,
+        ns: &str,
+        access: Access,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Arc<Names> {
+        if let Some(base) = &self.base {
+            if !self.by_parent.contains_key(ns) && !self.by_owner.contains_key(ns) {
+                return base.names_in(ns, access, active);
+            }
+        }
+        if let Some(known) = self.visible.lock().expect("visible names")[access as usize].get(ns) {
+            return Arc::clone(known);
+        }
+        let key = (ns.to_string(), access);
+        if !active.insert(key.clone()) {
+            return Arc::default();
+        }
+        let view = format!("n{} {ns}", access as usize);
+        let worked = self.guarded(view, || self.compute_names(ns, access, active));
+        active.remove(&key);
+        let Some((names, keep)) = worked else {
+            return Arc::default();
+        };
+        let names = Arc::new(names);
+        if keep {
+            self.visible.lock().expect("visible names")[access as usize]
+                .insert(key.0, Arc::clone(&names));
+        }
+        names
+    }
+
+    fn compute_names(
+        &self,
+        ns: &str,
+        access: Access,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Names {
+        #[cfg(test)]
+        work(1, 1);
+        let mut names = Names::default();
+        let mut own = Vec::new();
+        self.members_of(ns, &mut own);
+        // An owned member hides an imported one of the same name from
+        // whoever sees it: a private or protected one is visible to no
+        // client, so it hides nothing from one.
+        for s in own
+            .into_iter()
+            .filter(|s| access == Access::Inside || s.public)
+        {
+            names.add(OWNED, &s.name, Some(&s.qualified));
+        }
+        // What the imports bring in, as whoever they name them for finds
+        // them — a client of the target, or with `all` a name written
+        // inside it: an import of one member ahead of an import of a
+        // namespace's members.
+        for imp in self.imports_of(ns) {
+            let admitted = match access {
+                Access::Clients => imp.reexports(),
+                Access::Inside => !imp.filtered,
+            };
+            let Some(target) = imp.resolved.as_deref().filter(|_| admitted) else {
+                continue;
+            };
+            let inner = if imp.all {
+                Access::Inside
+            } else {
+                Access::Clients
+            };
+            match imp.reach {
+                Reach::Member => {
+                    if let Some(s) = self.symbol_at(target).filter(|s| imp.all || s.public) {
+                        names.add(IMPORTED_MEMBER, &s.name, Some(&s.qualified));
+                    }
+                }
+                Reach::Members => {
+                    for (name, path) in self.names_in(target, inner, active).iter() {
+                        names.add(IMPORTED_MEMBERS, name, path);
+                    }
+                }
+                Reach::Recursive => {
+                    for (name, path) in self.recursive_in(target, inner, active).iter() {
+                        names.add(IMPORTED_MEMBERS, name, path);
+                    }
+                }
+            }
+        }
+        names
+    }
+
+    /// What an import of the contents of the namespace at `ns`,
+    /// recursively, brings in, as `access` finds them: the members of
+    /// the namespaces it owns, at any depth — a client sees none inside
+    /// a private or protected one, and nobody inside a usage found by
+    /// the name of what it redefines or references — what it makes
+    /// visible itself, and what the elements it reaches inherit (see
+    /// [`Self::compute_recursive`]). Decided once per namespace and
+    /// view, like [`Self::names`].
+    fn recursive_in(
+        &self,
+        ns: &str,
+        access: Access,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Arc<Names> {
+        if let Some(base) = &self.base {
+            if !self.by_parent.contains_key(ns) && !self.by_owner.contains_key(ns) {
+                return base.recursive_in(ns, access, active);
+            }
+        }
+        if let Some(known) =
+            self.recursive.lock().expect("recursive names")[access as usize].get(ns)
+        {
+            return Arc::clone(known);
+        }
+        let key = format!("r{} {ns}", access as usize);
+        let Some((names, keep)) = self.guarded(key, || self.compute_recursive(ns, access, active))
+        else {
+            return Arc::default();
+        };
+        let names = Arc::new(names);
+        if keep {
+            self.recursive.lock().expect("recursive names")[access as usize]
+                .insert(ns.to_string(), Arc::clone(&names));
+        }
+        names
+    }
+
+    /// [`Self::recursive_in`], worked out.
+    fn compute_recursive(
+        &self,
+        ns: &str,
+        access: Access,
+        active: &mut HashSet<(String, Access)>,
+    ) -> Names {
+        let mut below: Vec<&QualifiedSymbol> = Vec::new();
+        let mut stack = vec![ns.to_string()];
+        let mut walked = HashSet::new();
+        while let Some(path) = stack.pop() {
+            if !walked.insert(path.clone()) {
+                continue;
+            }
+            let mut members = Vec::new();
+            self.members_of(&path, &mut members);
+            members.retain(|s| access == Access::Inside || s.public);
+            stack.extend(
+                members
+                    .iter()
+                    .filter(|s| !s.effective)
+                    .map(|s| s.qualified.clone()),
+            );
+            below.extend(members);
+        }
+        let mut names = Names::default();
+        for s in below {
+            names.add(OWNED, &s.name, Some(&s.qualified));
+        }
+        for (name, path) in self.names_in(ns, access, active).iter() {
+            names.add(OWNED, name, path);
+        }
+        // What each element the walk reaches inherits is found in it
+        // too, unless the element declares that name itself. What a
+        // library type passes on also comes to elements no written
+        // specialization shows, through the library base every element
+        // of a kind specializes: a name it passes on denotes no one
+        // element here.
+        for path in &walked {
+            for (name, found) in self.inherited(path).iter() {
+                if self.symbol_at(&join(path, name)).is_some() {
+                    continue;
+                }
+                let library = found
+                    .and_then(|f| self.symbol_at(f))
+                    .is_some_and(|s| s.site.is_none());
+                names.add(OWNED, name, found.filter(|_| !library));
+            }
+        }
+        names
+    }
+
+    /// Does this table declare the element at `path`, or anything in it?
+    /// Else a table below answers for it.
+    fn holds(&self, path: &str) -> bool {
+        self.by_path.contains_key(path) || self.by_parent.contains_key(path)
+    }
+
+    /// Work out the view `key` of this table with `work`, unless it is
+    /// being worked out already further up: `None` then (see
+    /// [`Working`]). With the answer, whether to keep it: not when a
+    /// cut on the way left it short.
+    fn guarded<T>(&self, key: String, work: impl FnOnce() -> T) -> Option<(T, bool)> {
+        let id = (std::ptr::from_ref(self) as usize, key);
+        let depth = WORKING.with(|w| {
+            let mut w = w.borrow_mut();
+            if let Some(&at) = w.open.get(&id) {
+                w.short = Some(w.short.map_or(at + 1, |d| d.min(at + 1)));
+                return None;
+            }
+            let depth = w.open.len();
+            w.open.insert(id.clone(), depth);
+            Some(depth)
+        })?;
+        let open = Open {
+            id,
+            depth,
+            left: false,
+        };
+        let out = work();
+        Some((out, open.leave()))
+    }
+
+    /// What the element at `path` specializes, resolved: the types it is
+    /// typed by, the features it subsets, redefines, or references, the
+    /// definitions it specializes — each reference read from where the
+    /// declaration is written, a redefined feature among what that
+    /// owner inherits, the element itself never. Worked out once per
+    /// element.
+    fn bases_of(&self, path: &str) -> Arc<[String]> {
+        if let Some(base) = &self.base {
+            if !self.holds(path) {
+                return base.bases_of(path);
+            }
+        }
+        if let Some(known) = self.bases.lock().expect("bases").get(path) {
+            return Arc::clone(known);
+        }
+        let Some((declared, owner)) = self
+            .layers()
+            .find_map(|t| t.written.get(path))
+            .zip(self.symbol_at(path).and_then(parent_of))
+        else {
+            return Arc::default();
+        };
+        let work = || {
+            let mut out: Vec<String> = Vec::new();
+            for b in declared {
+                let written = &b.written;
+                let inherited = match written.target.as_slice() {
+                    [name] if b.redefines && !written.global => self
+                        .inherited(owner)
+                        .get(name)
+                        .flatten()
+                        .map(str::to_string),
+                    _ => None,
+                };
+                let found = inherited
+                    .or_else(|| self.resolve_written(owner, &written.target, written.global));
+                if let Some(found) = found.filter(|f| f != path && !out.contains(f)) {
+                    out.push(found);
+                }
+            }
+            out
+        };
+        let Some((bases, keep)) = self.guarded(format!("b {path}"), work) else {
+            return Arc::default();
+        };
+        let bases: Arc<[String]> = bases.into();
+        if keep {
+            self.bases
+                .lock()
+                .expect("bases")
+                .insert(path.to_string(), Arc::clone(&bases));
+        }
+        bases
+    }
+
+    /// What the element at `path` inherits, by name: what each element
+    /// it specializes passes on ([`Self::heritage`]), a name two of them
+    /// pass on for different elements denoting neither. Worked out once
+    /// per element.
+    fn inherited(&self, path: &str) -> Arc<Names> {
+        if let Some(base) = &self.base {
+            if !self.holds(path) {
+                return base.inherited(path);
+            }
+        }
+        if let Some(known) = self.inheritance.lock().expect("inheritance").get(path) {
+            return Arc::clone(known);
+        }
+        let work = || {
+            let mut names = Names::default();
+            for b in self.bases_of(path).iter() {
+                for (name, found) in self.heritage(b).iter() {
+                    names.add(OWNED, name, found);
+                }
+            }
+            names
+        };
+        let Some((names, keep)) = self.guarded(format!("i {path}"), work) else {
+            return Arc::default();
+        };
+        let names = Arc::new(names);
+        if keep {
+            self.inheritance
+                .lock()
+                .expect("inheritance")
+                .insert(path.to_string(), Arc::clone(&names));
+        }
+        names
+    }
+
+    /// What the element at `path` passes on to what specializes it, by
+    /// name: its public members, then what it inherits, a member hiding
+    /// an inherited one of its name. Worked out once per element.
+    fn heritage(&self, path: &str) -> Arc<Names> {
+        if let Some(base) = &self.base {
+            if !self.holds(path) {
+                return base.heritage(path);
+            }
+        }
+        if let Some(known) = self.heritage.lock().expect("heritage").get(path) {
+            return Arc::clone(known);
+        }
+        let work = || {
+            let mut names = Names::default();
+            let mut own = Vec::new();
+            self.members_of(path, &mut own);
+            for s in own.into_iter().filter(|s| s.public) {
+                names.add(OWNED, &s.name, Some(&s.qualified));
+            }
+            for (name, found) in self.inherited(path).iter() {
+                names.add(IMPORTED_MEMBER, name, found);
+            }
+            names
+        };
+        let Some((names, keep)) = self.guarded(format!("h {path}"), work) else {
+            return Arc::default();
+        };
+        let names = Arc::new(names);
+        if keep {
+            self.heritage
+                .lock()
+                .expect("heritage")
+                .insert(path.to_string(), Arc::clone(&names));
+        }
+        names
+    }
+
+    /// Does `name` denote exactly the element at `qualified` for the
+    /// clients of the namespace at `ns`?
+    fn denotes(&self, ns: &str, name: &str, qualified: &str) -> bool {
+        self.names(ns, Access::Clients).get(name) == Some(Some(qualified))
+    }
+}
+
+impl SymbolTable {
+    /// The path an import of the symbol at `qualified` (named `name`)
+    /// should name. Besides its own path, every top-level package that
+    /// makes the symbol visible — through its public imports, and
+    /// theirs in turn — offers one of two segments. The shortest wins;
+    /// between equally short ones the package of the symbol's family
+    /// comes first (a package whose name its defining package's name
+    /// extends: `ISQ` for `ISQBase::MassValue`), then the symbol's own
+    /// path or its own top-level package, then the fewest imports on
+    /// the way, then the spelling. A package where the name denotes
+    /// anything else — a member of its own, or two imports' elements —
+    /// offers nothing.
+    pub(super) fn import_path(&self, name: &str, qualified: &str) -> String {
+        self.import_route(name, qualified)
+            .unwrap_or_else(|| qualified.to_string())
+    }
+
+    /// [`Self::import_path`] when it runs through a re-exporting package,
+    /// `None` when it is the symbol's own path.
+    fn import_route(&self, name: &str, qualified: &str) -> Option<String> {
+        let parent = qualified
+            .strip_suffix(name)
+            .and_then(|p| p.strip_suffix("::"))?;
+        let routes = self.routes_of(parent);
+        let own = (routes.segments + 1, 1, 0);
+        routes
+            .to(name)
+            .iter()
+            .take_while(|r| (2, r.rank, r.hops) < own)
+            .find(|r| self.denotes(&r.package, name, qualified))
+            .map(|r| join(&r.package, name))
+    }
+
+    /// The top-level packages other than `ns` itself that see the
+    /// members of the namespace at `ns` under their own names, and those
+    /// that see a member alone through an import of it, best first.
+    /// Worked out once per namespace; a table whose units re-export
+    /// nothing answers from the layer below, which keeps its answers.
+    fn routes_of(&self, ns: &str) -> Arc<Routes> {
+        if self.by_target.is_empty() {
+            if let Some(base) = &self.base {
+                return base.routes_of(ns);
+            }
+        }
+        if let Some(known) = self.routes.lock().expect("routes").get(ns) {
+            return Arc::clone(known);
+        }
+        #[cfg(test)]
+        work(2, 1);
+        let top = ns.split("::").next().unwrap_or(ns);
+        let mut members = self.walk_routes(std::iter::once((ns.to_string(), 0)), ns, top);
+        members.sort_by(|a, b| a.key().cmp(&b.key()));
+        // An import of one member sees it too, and so does whoever
+        // imports that importer's members.
+        let mut singles: Vec<(String, Vec<Route>)> = Vec::new();
+        for t in self.layers() {
+            for imp in t
+                .singles
+                .get(ns)
+                .into_iter()
+                .flatten()
+                .map(|&i| &t.imports[i])
+            {
+                let Some(name) = imp.resolved.as_deref().and_then(|p| p.rsplit("::").next()) else {
+                    continue;
+                };
+                let start = std::iter::once((imp.owner.clone(), 1));
+                let found = self.walk_routes(start, ns, top);
+                match singles.iter_mut().find(|(n, _)| n == name) {
+                    Some((_, routes)) => routes.extend(found),
+                    None => singles.push((name.to_string(), found)),
+                }
+            }
+        }
+        for (_, routes) in &mut singles {
+            routes.extend(members.iter().cloned());
+            routes.sort_by(|a, b| a.key().cmp(&b.key()));
+        }
+        let segments = ns.matches("::").count() + 1;
+        let routes = Arc::new(Routes {
+            segments,
+            members,
+            singles,
+        });
+        self.routes
+            .lock()
+            .expect("routes")
+            .insert(ns.to_string(), Arc::clone(&routes));
+        routes
+    }
+
+    /// Walk the public imports outward from `starts` (namespace, imports
+    /// on the way): whoever imports a namespace's members, or those of a
+    /// namespace around it recursively, sees them too. Every top-level
+    /// package reached other than `parent` is a route, ranked against
+    /// `top`, the members' own top-level package.
+    fn walk_routes(
+        &self,
+        starts: impl Iterator<Item = (String, usize)>,
+        parent: &str,
+        top: &str,
+    ) -> Vec<Route> {
+        let mut routes = Vec::new();
+        let mut queue: std::collections::VecDeque<(String, usize)> = starts.collect();
+        let mut seen = HashSet::new();
+        while let Some((ns, hops)) = queue.pop_front() {
+            if !seen.insert(ns.clone()) {
+                continue;
+            }
+            if !ns.is_empty() && !ns.contains("::") && ns != parent {
+                let rank = if family(&ns, top) {
+                    0
+                } else if ns == top {
+                    1
+                } else {
+                    2
+                };
+                routes.push(Route {
+                    rank,
+                    hops,
+                    package: ns.clone(),
+                });
+            }
+            let mut around = Some(ns.as_str());
+            while let Some(a) = around.filter(|a| !a.is_empty()) {
+                for imp in self.importers_of(a) {
+                    let reaches = match imp.reach {
+                        Reach::Members => a == ns,
+                        Reach::Recursive => true,
+                        Reach::Member => false,
+                    };
+                    if reaches {
+                        queue.push_back((imp.owner.clone(), hops + 1));
+                    }
+                }
+                around = enclosing(a);
+            }
+        }
+        routes
+    }
+}
+
+impl crate::autoimport::Reexports for SymbolTable {
+    fn namespace(&self, owner: &str, target: &[String], global: bool) -> Option<String> {
+        self.resolve(owner, target, global)
+    }
+
+    fn inherits(&self, ns: &str, name: &str, qualified: &str) -> Brought {
+        match self.inherited(ns).get(name) {
+            None => Brought::Nothing,
+            Some(Some(path)) if path == qualified => Brought::It,
+            Some(Some(path)) => Brought::other(path),
+            Some(None) => Brought::Several,
+        }
+    }
+
+    fn inherited_paths(&self, ns: &str) -> Vec<String> {
+        self.inherited(ns)
+            .iter()
+            .filter_map(|(_, path)| path.map(str::to_string))
+            .collect()
+    }
+
+    fn brought(
+        &self,
+        ns: &str,
+        name: &str,
+        qualified: &str,
+        recursive: bool,
+        all: bool,
+    ) -> Brought {
+        let access = if all { Access::Inside } else { Access::Clients };
+        let names = if recursive {
+            self.recursive_in(ns, access, &mut HashSet::new())
+        } else {
+            self.names(ns, access)
+        };
+        match names.get(name) {
+            None => Brought::Nothing,
+            Some(Some(path)) if path == qualified => Brought::It,
+            Some(Some(path)) => Brought::other(path),
+            Some(None) => Brought::Several,
+        }
+    }
+
+    fn import_route(&self, name: &str, qualified: &str) -> Option<String> {
+        SymbolTable::import_route(self, name, qualified)
+    }
+}
+
+/// Is the top-level package `ns` the facade of the family `top`
+/// belongs to — does `top`'s name extend `ns`'s (`ISQ` for `ISQBase`,
+/// `SI` for `SIPrefixes`) at a word boundary?
+fn family(ns: &str, top: &str) -> bool {
+    top.len() > ns.len()
+        && top.starts_with(ns)
+        && !top[ns.len()..].starts_with(|c: char| c.is_lowercase())
+}
+
+/// The qualified path of the namespace owning `s` (`""`: the root).
+fn parent_of(s: &QualifiedSymbol) -> Option<&str> {
+    if s.qualified == s.name {
+        return Some("");
+    }
+    s.qualified
+        .strip_suffix(s.name.as_str())
+        .and_then(|p| p.strip_suffix("::"))
+}
+
+/// Is the namespace at `path` the one at `ns`, or nested in it?
+fn within(path: &str, ns: &str) -> bool {
+    path.strip_prefix(ns)
+        .is_some_and(|rest| rest.is_empty() || rest.starts_with("::"))
+}
+
+/// `name` as a member of the namespace at `ns` (`""`: the root).
+fn join(ns: &str, name: &str) -> String {
+    if ns.is_empty() {
+        return name.to_string();
+    }
+    let mut path = String::with_capacity(ns.len() + 2 + name.len());
+    path.push_str(ns);
+    path.push_str("::");
+    path.push_str(name);
+    path
+}
+
+/// The namespace enclosing the one at `ns`: `None` past the root.
+fn enclosing(ns: &str) -> Option<&str> {
+    if ns.is_empty() {
+        None
+    } else {
+        Some(ns.rfind("::").map_or("", |i| &ns[..i]))
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/outline.rs b/crates/sysmlv2-lsp/src/outline.rs
index 225c242..3d65086 100644
--- a/crates/sysmlv2-lsp/src/outline.rs
+++ b/crates/sysmlv2-lsp/src/outline.rs
@@ -23,9 +23,10 @@ use crate::position::Mapper;
 use lsp_types::{DocumentSymbol, SymbolKind};
 use sysmlv2_parser::ast::{
     DefKind, Definition, FeatureSpecialization, Identification, Member, MemberKind, SourceUnit,
-    TargetRef, Usage, UsageKind,
+    TargetRef, Usage, UsageKind, Visibility,
 };
 use sysmlv2_parser::span::Span;
+use sysmlv2_parser::visit::{self, Visit};
 
 /// Build the outline for one parsed unit over its source text.
 ///
@@ -93,6 +94,244 @@ pub(crate) fn short_names(
     out
 }
 
+/// A unit's namespace plumbing that the completion tier's symbol
+/// tables read differently from the outline, at any depth, keyed by
+/// member start (the outline node's `range.start`).
+#[derive(Default)]
+pub(crate) struct Plumbing {
+    /// The `import` and `expose` members. The outline lists each under
+    /// its target's spelling, but they declare nothing.
+    pub imports: std::collections::HashSet<lsp_types::Position>,
+    /// What each `import` member names and how (an `expose` shows
+    /// elements in a view and makes nothing visible).
+    pub import_forms: std::collections::HashMap<lsp_types::Position, ImportForm>,
+    /// The `alias` members' targets, as written. An alias names what its
+    /// target does.
+    pub aliases: std::collections::HashMap<lsp_types::Position, Written>,
+    /// The members declared `private` or `protected`: no member of
+    /// their namespace for anyone outside it.
+    pub hidden: std::collections::HashSet<lsp_types::Position>,
+    /// What each declaration specializes (see [`Base`]), when anything.
+    pub bases: std::collections::HashMap<lsp_types::Position, Vec<Base>>,
+    /// The name each unnamed usage is found by (see [`effective_name`]),
+    /// and where the text spells it.
+    pub effective: std::collections::HashMap<lsp_types::Position, (String, lsp_types::Range)>,
+}
+
+/// A reference as written: an alias's target, or what a declaration
+/// specializes.
+#[derive(Clone, Debug)]
+pub(crate) struct Written {
+    /// One raw name per segment.
+    pub target: Vec<String>,
+    /// `$::`-rooted.
+    pub global: bool,
+}
+
+/// What a declaration specializes, as written: a type a usage is typed
+/// by, a feature it subsets, redefines, or references, a definition a
+/// definition specializes. Its members are the declaration's too.
+#[derive(Clone, Debug)]
+pub(crate) struct Base {
+    pub written: Written,
+    /// A feature the declaration redefines: found among what the
+    /// declaration's owner inherits, never the declaration itself.
+    pub redefines: bool,
+}
+
+/// An `import` statement's target, as written, and its form.
+pub(crate) struct ImportForm {
+    /// One raw name per segment.
+    pub target: Vec<String>,
+    /// `$::`-rooted.
+    pub global: bool,
+    /// `::*`: the target's members rather than the target itself.
+    pub namespace: bool,
+    /// `::**`: recursively.
+    pub recursive: bool,
+    /// Re-exported to the owning namespace's clients: `public`, or no
+    /// visibility keyword at all.
+    pub public: bool,
+    /// `import all`: the target's members whatever their visibility, as
+    /// a name written inside the target finds them.
+    pub all: bool,
+    /// Conditioned — by a `[…]` filter of its own, or by a `filter`
+    /// member of the namespace it sits in — so it brings in only the
+    /// members the condition admits, which the syntax tier cannot tell.
+    pub filtered: bool,
+}
+
+/// Collect a unit's [`Plumbing`] in one walk.
+pub(crate) fn plumbing(unit: &SourceUnit, mapper: &Mapper<'_>) -> Plumbing {
+    struct Walk<'m> {
+        mapper: &'m Mapper<'m>,
+        out: Plumbing,
+        /// The imports of namespace bodies that hold a `filter` member,
+        /// by member start.
+        conditioned: std::collections::HashSet<u32>,
+    }
+    impl Walk<'_> {
+        /// A `filter` member conditions every import of its namespace.
+        fn note_filters(&mut self, body: &[Member]) {
+            if body.iter().any(|b| matches!(b.kind, MemberKind::Filter(_))) {
+                let imports = body
+                    .iter()
+                    .filter(|b| matches!(b.kind, MemberKind::Import(_)));
+                self.conditioned.extend(imports.map(|b| b.span.start));
+            }
+        }
+    }
+    impl<'a> Visit<'a> for Walk<'_> {
+        fn visit_member(&mut self, m: &'a Member) {
+            if let MemberKind::Package(p) = &m.kind {
+                self.note_filters(p.body.as_deref().unwrap_or_default());
+            }
+            let at = || self.mapper.position(m.span.start);
+            if matches!(
+                m.visibility,
+                Some(Visibility::Private | Visibility::Protected)
+            ) {
+                self.out.hidden.insert(at());
+            }
+            match &m.kind {
+                MemberKind::Import(i) => {
+                    self.out.imports.insert(at());
+                    let form = ImportForm {
+                        target: i.target.segments.iter().map(|s| s.value.clone()).collect(),
+                        global: i.target.is_global,
+                        namespace: i.is_namespace,
+                        recursive: i.is_recursive,
+                        public: matches!(m.visibility, None | Some(Visibility::Public)),
+                        all: i.is_import_all,
+                        filtered: !i.filters.is_empty() || self.conditioned.contains(&m.span.start),
+                    };
+                    self.out.import_forms.insert(at(), form);
+                }
+                MemberKind::Expose(_) => {
+                    self.out.imports.insert(at());
+                }
+                MemberKind::Definition(d) => {
+                    let bases: Vec<Base> = d
+                        .specializes
+                        .iter()
+                        .filter_map(|t| base(t, false))
+                        .collect();
+                    if !bases.is_empty() {
+                        self.out.bases.insert(at(), bases);
+                    }
+                }
+                _ if crate::kinds::usage(m).is_some() => {
+                    if let Some(name) = effective_name_of(m) {
+                        let range = self.mapper.range(name.span);
+                        self.out.effective.insert(at(), (name.value.clone(), range));
+                    }
+                    let u = crate::kinds::usage(m).expect("a usage");
+                    let mut bases = Vec::new();
+                    for spec in &u.declaration.specializations {
+                        match spec {
+                            FeatureSpecialization::TypedBy(types) => {
+                                bases.extend(types.iter().filter_map(|t| base(&t.target, false)));
+                            }
+                            FeatureSpecialization::Subsets(ts) => {
+                                bases.extend(ts.iter().filter_map(|t| base(t, false)));
+                            }
+                            FeatureSpecialization::Redefines(ts) => {
+                                bases.extend(ts.iter().filter_map(|t| base(t, true)));
+                            }
+                            FeatureSpecialization::References(t) => bases.extend(base(t, false)),
+                            FeatureSpecialization::Crosses(_) => {}
+                        }
+                    }
+                    if !bases.is_empty() {
+                        self.out.bases.insert(at(), bases);
+                    }
+                }
+                MemberKind::Alias(a) => {
+                    let target = Written {
+                        target: a.target.segments.iter().map(|s| s.value.clone()).collect(),
+                        global: a.target.is_global,
+                    };
+                    self.out.aliases.insert(at(), target);
+                }
+                _ => {}
+            }
+            visit::walk_member(self, m);
+        }
+    }
+    let mut walk = Walk {
+        mapper,
+        out: Plumbing::default(),
+        conditioned: std::collections::HashSet::new(),
+    };
+    walk.note_filters(&unit.members);
+    walk.visit_unit(unit);
+    walk.out
+}
+
+/// A specialization's target as a [`Base`]; `None` for a feature chain,
+/// which names no one declaration by its path.
+fn base(target: &TargetRef, redefines: bool) -> Option<Base> {
+    let TargetRef::Name(qn) = target else {
+        return None;
+    };
+    Some(Base {
+        written: Written {
+            target: qn.segments.iter().map(|s| s.value.clone()).collect(),
+            global: qn.is_global,
+        },
+        redefines,
+    })
+}
+
+/// The name the member `m`, a usage without a name of its own, is found
+/// by (see [`effective_name`]).
+pub(crate) fn effective_name_of(m: &Member) -> Option<&sysmlv2_parser::ast::Name> {
+    let u = crate::kinds::usage(m)?;
+    let references = matches!(
+        u.kind,
+        UsageKind::Perform | UsageKind::Exhibit | UsageKind::Include
+    ) || matches!(m.kind, MemberKind::RequirementConstraint { .. });
+    effective_name(u, references)
+}
+
+/// The name an unnamed usage is found by, as the resolver names it: the
+/// last segment of the first feature it redefines (`:>> engine`,
+/// `attribute redefines fuelMassMax = 60 [kg];`), or of the one it
+/// references (`satisfy Requirements::vehicleSpecification by
+/// vehicle_b`); where the usage is `references`-named — a `perform`,
+/// `exhibit`, or `include`, or an `assume` or `require` constraint —
+/// or a variant, the one it references alone, the last step of a
+/// feature chain too for the former (`perform providePower.distributeTorque;`
+/// is found as `distributeTorque`). `None` for a usage with a name or a
+/// short name, and for one naming nothing so.
+fn effective_name(u: &Usage, references: bool) -> Option<&sysmlv2_parser::ast::Name> {
+    let specs = &u.declaration.specializations;
+    if !u.declaration.id.is_empty() {
+        return None;
+    }
+    let by_reference = (references || u.prefix.is_variant)
+        && specs
+            .iter()
+            .any(|s| matches!(s, FeatureSpecialization::References(_)));
+    for s in specs {
+        let (target, chained) = match s {
+            FeatureSpecialization::References(t) => (t, references),
+            FeatureSpecialization::Redefines(ts) if !by_reference => match ts.first() {
+                Some(t) => (t, false),
+                None => continue,
+            },
+            _ => continue,
+        };
+        let qn = match target {
+            TargetRef::Name(qn) => qn,
+            TargetRef::Chain(links) if chained => links.last()?,
+            TargetRef::Chain(_) => return None,
+        };
+        return qn.segments.last();
+    }
+    None
+}
+
 fn collect_short_names(
     members: &[Member],
     mapper: &Mapper<'_>,
diff --git a/crates/sysmlv2-lsp/src/push.rs b/crates/sysmlv2-lsp/src/push.rs
index f297ef7..f2ef1da 100644
--- a/crates/sysmlv2-lsp/src/push.rs
+++ b/crates/sysmlv2-lsp/src/push.rs
@@ -1,5 +1,6 @@
 //! Push-driven frontend: drive the server one
-//! message at a time — no threads, no blocking reads, no filesystem.
+//! message at a time — no threads, no blocking reads, no filesystem of
+//! its own.
 //! This is the WASM host shape: a web worker feeds client→server
 //! JSON-RPC strings in and relays the returned server→client strings.
 //!
@@ -10,12 +11,13 @@
 //! - the workspace model tier is disabled ([`worker::Worker::disabled`])
 //!   — in the browser, semantic/library-aware diagnostics are the
 //!   kernel worker's job, and this server serves the syntax tier;
-//! - no root-directory walk (there is no disk); the standard library,
-//!   when wanted, arrives as in-memory sources
-//!   ([`PushServer::with_library_sources`]) and feeds navigation and
-//!   completions, and the workspace's units arrive the same way
-//!   ([`PushServer::set_workspace_sources`]) so navigation crosses
-//!   into units the client has not opened.
+//! - no root-directory walk (the browser host has no disk); the standard
+//!   library, when wanted, is handed over as sources
+//!   ([`PushServer::with_library_sources`]) or as any library form,
+//!   prepared ones included ([`PushServer::with_library`]), and feeds
+//!   navigation and completions, and the workspace's units arrive as
+//!   sources ([`PushServer::set_workspace_sources`]) so navigation
+//!   crosses into units the client has not opened.
 
 use lsp_server::{Connection, ErrorCode, Message, Request, Response};
 use lsp_types::request::{Initialize, Request as _, Shutdown};
@@ -94,6 +96,22 @@ impl PushServer {
         }))
     }
 
+    /// A push server whose navigation and completions see `library`. A
+    /// prepared library was resolved when it was prepared, so a session
+    /// resolves the workspace's units against it instead of reading and
+    /// resolving the library's sources again; a workspace that may change
+    /// what the library's own names resolve to (for example a root name the
+    /// library looked up and missed, a root declaration named like one of
+    /// the library's, or a root filter) has the library resolved again with
+    /// it. Any other library form works too: a directory library reads the
+    /// directory and reads and writes an on-disk cache, which a host
+    /// without a filesystem avoids by passing sources or a prepared
+    /// library.
+    #[must_use]
+    pub fn with_library(library: sysmlv2_transform::Library) -> PushServer {
+        Self::new_with(Some(library))
+    }
+
     fn new_with(library: Option<sysmlv2_transform::Library>) -> PushServer {
         let (server_conn, client_conn) = Connection::memory();
         PushServer {
@@ -311,6 +329,8 @@ impl PushServer {
         }
         nav.set_infer_unit_types(self.infer_unit_types);
         nav.set_snippet_completions(crate::snippet_completions(&init));
+        nav.set_insert_replace_completions(crate::insert_replace_completions(&init));
+        nav.set_signature_label_offsets(crate::signature_label_offsets(&init));
         self.server = Some(Server {
             connection,
             encoding,
@@ -545,13 +565,13 @@ mod tests {
             &mut s,
             &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
                 "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
-                                 "version": 1, "text": "package P { part def X; }"}}}),
+                                 "version": 1, "text": "package P { part def X; ref w : }"}}}),
         );
         let out = responses(
             &mut s,
             &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
-                           "position": {"line": 0, "character": 12}}}),
+                           "position": {"line": 0, "character": 32}}}),
         );
         let items = out[0]["result"].as_array().expect("completion items");
         let labels: Vec<&str> = items.iter().filter_map(|i| i["label"].as_str()).collect();
@@ -574,13 +594,13 @@ mod tests {
             &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
                 "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
                                  "version": 1,
-                                 "text": "package P {\n    private import OtherLib::*;\n    part w : \n}\n"}}}),
+                                 "text": "package P {\n    private import OtherLib::*;\n    ref w : \n}\n"}}}),
         );
         let out = responses(
             &mut s,
             &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
-                           "position": {"line": 2, "character": 13}}}),
+                           "position": {"line": 2, "character": 12}}}),
         );
         let items = out[0]["result"].as_array().expect("completion items");
         let widget = items
@@ -631,7 +651,7 @@ mod tests {
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
                            "position": {"line": 1, "character": 26}}}),
         );
-        let items = out[0]["result"].as_array().expect("completion items");
+        let items = &completion_items(&out[0]["result"]);
         let unit = items
             .iter()
             .find(|i| i["label"] == "m/s²")
@@ -655,10 +675,423 @@ mod tests {
         assert_eq!(long["textEdit"]["newText"], "'metre per second squared'");
     }
 
+    /// Inside a quoted name being typed, accepting replaces the whole
+    /// typed spelling from its opening quote — every word, and the
+    /// closing quote an editor inserts along with the opening one — not
+    /// just the last word; each item filters by its quoted spelling,
+    /// which is what an editor matches the text from the quote against.
+    #[test]
+    fn completion_replaces_the_quoted_name_being_typed() {
+        let complete = |text: &str, character: u32| -> Vec<serde_json::Value> {
+            let mut s = two_package_server();
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 1, "character": character}}}),
+            );
+            completion_items(&out[0]["result"])
+        };
+        let edit = |start: u32, end: u32, new_text: &str| {
+            serde_json::json!({
+                "range": {"start": {"line": 1, "character": start},
+                          "end": {"line": 1, "character": end}},
+                "newText": new_text
+            })
+        };
+        let item = |items: &[serde_json::Value], label: &str, text: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered: {text:?}"))
+                .clone()
+        };
+        // The cursor after `sec`; the opening quote at 23.
+        for (text, end, long) in [
+            // Unterminated: the edit brings the closing quote, and the
+            // bracket repair rides behind it.
+            (
+                "package P {\n    attribute g = 9.8 ['metre per sec\n}\n",
+                37,
+                "'metre per second squared']",
+            ),
+            // Closed: the closing quote is replaced too.
+            (
+                "package P {\n    attribute g = 9.8 ['metre per sec'\n}\n",
+                38,
+                "'metre per second squared']",
+            ),
+            (
+                "package P {\n    attribute g = 9.8 ['metre per sec']\n}\n",
+                38,
+                "'metre per second squared'",
+            ),
+        ] {
+            let items = complete(text, 37);
+            let unit = item(&items, "metre per second squared", text);
+            assert_eq!(unit["textEdit"], edit(23, end, long), "{text:?}");
+            assert_eq!(unit["filterText"], "'metre per second squared'");
+        }
+        // A basic name typed quoted is accepted bare; the cursor after
+        // `Wid`, the opening quote at 16. (`alias … for` takes any
+        // element, a class included.)
+        for (text, end) in [
+            ("package P {\n    alias a for 'Wid\n}\n", 20),
+            ("package P {\n    alias a for 'Wid'\n}\n", 21),
+        ] {
+            let items = complete(text, 20);
+            let w = item(&items, "Widget", text);
+            assert_eq!(w["textEdit"], edit(16, end, "Widget"), "{text:?}");
+            assert_eq!(w["filterText"], "'Widget'");
+        }
+
+        // No closing quote on the line: the rest of the word the cursor
+        // sits in is part of the name being typed, replaced with it.
+        let items = complete(
+            "package P {\n    attribute g = 9.8 ['metre per sec\n}\n",
+            35,
+        );
+        let unit = items
+            .iter()
+            .find(|i| i["label"] == "metre per second squared")
+            .expect("unit offered mid-word");
+        assert_eq!(
+            unit["textEdit"],
+            edit(23, 37, "'metre per second squared']")
+        );
+        // A later quoted name on the line does not close the one being
+        // typed: its opening quote would leave the rest of the line
+        // with an unterminated name.
+        let items = complete("package P {\n    ref a : 'Wid, 'Gadget';\n}\n", 16);
+        let w = items
+            .iter()
+            .find(|i| i["label"] == "Widget")
+            .expect("Widget offered");
+        assert_eq!(w["textEdit"], edit(12, 16, "Widget"));
+        // A quote left open on an earlier line — of a quoted name, or of
+        // a string running to the end — does not flip the pairing on this
+        // one: the quote being typed still opens the name.
+        for open in ["'open;", "\"open;"] {
+            let text = format!(
+                "package P {{\n    doc /* it's */\n    attribute s = {open}\n    attribute g = 9.8 ['m/\n}}\n"
+            );
+            let mut s = two_package_server();
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 3, "character": 26}}}),
+            );
+            let unit = out[0]["result"]
+                .as_array()
+                .expect("completion items")
+                .iter()
+                .find(|i| i["label"] == "m/s²")
+                .expect("m/s² offered")
+                .clone();
+            assert_eq!(
+                unit["textEdit"],
+                serde_json::json!({
+                    "range": {"start": {"line": 3, "character": 23},
+                              "end": {"line": 3, "character": 26}},
+                    "newText": "'m/s²']"
+                }),
+                "{open}"
+            );
+        }
+
+        // A quote that opens nothing at the cursor — a closed quoted
+        // name, a comment's apostrophe — leaves the partial word alone.
+        for (text, character) in [
+            ("package P {\n    attribute 'g 1' = 9.8 [m/s\n}\n", 30u32),
+            (
+                "package P {\n    attribute g /* it's */ = 9.8 [m/s\n}\n",
+                37,
+            ),
+        ] {
+            let items = complete(text, character);
+            let unit = items
+                .iter()
+                .find(|i| i["label"] == "m/s²")
+                .unwrap_or_else(|| panic!("m/s² offered: {text:?}"));
+            assert_eq!(
+                unit["textEdit"],
+                edit(character - 3, character, "'m/s²']"),
+                "{text:?}"
+            );
+            assert!(unit["filterText"].is_null(), "{text:?}");
+        }
+    }
+
+    /// Multi-word library names (`'metre per second squared'`) are
+    /// offered only inside an open bracket, where a unit is written —
+    /// never in a plain expression or an import path — while their
+    /// short symbols stay offered there, a qualifier still lists them,
+    /// and the workspace's own multi-word names are unaffected.
+    #[test]
+    fn multiword_library_names_only_inside_brackets() {
+        const LONG: &str = "metre per second squared";
+        for (text, line, character, offered) in [
+            ("package P {\n    ref w = \n}\n", 1u32, 12u32, false),
+            ("package P {\n    attribute g = \n}\n", 1, 18, false),
+            ("package P {\n    attribute g = 9.8 [m\n}\n", 1, 24, true),
+            ("package P {\n    attribute g = 9.8 ['met\n}\n", 1, 27, true),
+            (
+                "package P {\n    attribute g = 9.8 [m] + \n}\n",
+                1,
+                28,
+                false,
+            ),
+            ("package P {\n    private import metre\n}\n", 1, 24, false),
+            ("package P {\n    part w : MiniLib::\n}\n", 1, 22, true),
+        ] {
+            let mut s = two_package_server();
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": line, "character": character}}}),
+            );
+            let items = out[0]["result"].as_array().expect("completion items");
+            let labels = completion_labels(items);
+            assert_eq!(labels.contains(&LONG), offered, "{text:?}: {labels:?}");
+            assert!(labels.contains(&"m/s²"), "short symbol offered: {text:?}");
+        }
+
+        // The workspace's own multi-word names stay offered everywhere.
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    part def 'Vehicle One';\n    part w : \n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": 2, "character": 13}}}),
+        );
+        let items = out[0]["result"].as_array().expect("completion items");
+        let labels = completion_labels(items);
+        assert!(labels.contains(&"Vehicle One"), "{labels:?}");
+        assert!(!labels.contains(&LONG), "{labels:?}");
+    }
+
+    /// A unit name containing whitespace typed word by word without its
+    /// quotes inside a bracket: once the words typed begin the name,
+    /// accepting it replaces them all, and it filters by its own
+    /// spelling, spaces included. Outside a bracket the words before the
+    /// partial one keep their own meaning — a type followed by a keyword,
+    /// a keyword followed by a declared name — and every name stays with
+    /// the partial word, filtering without whitespace.
+    #[test]
+    fn completion_takes_a_multiword_name_typed_word_by_word() {
+        let complete = |text: &str, line: u32, character: u32| -> Vec<serde_json::Value> {
+            let mut s = two_package_server();
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": line, "character": character}}}),
+            );
+            out[0]["result"]
+                .as_array()
+                .expect("completion items")
+                .clone()
+        };
+        let item = |items: &[serde_json::Value], label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"))
+                .clone()
+        };
+        let edit = |line: u32, start: u32, end: u32, new_text: &str| {
+            serde_json::json!({
+                "range": {"start": {"line": line, "character": start},
+                          "end": {"line": line, "character": end}},
+                "newText": new_text
+            })
+        };
+
+        let items = complete("package P {\n    attribute g = 9.8 [metre per\n}\n", 1, 32);
+        let unit = item(&items, "metre per second squared");
+        assert_eq!(
+            unit["textEdit"],
+            edit(1, 23, 32, "'metre per second squared']")
+        );
+        assert!(unit["filterText"].is_null(), "{unit}");
+        // Case aside, in any alphabet. (A unit: a unit bracket lists
+        // nothing else.)
+        let items = complete(
+            "package P {\n    attribute 'Øre per mark' : MeasurementReferences::TensorMeasurementReference;\n    \
+             attribute g = 9.8 [Øre p\n}\n",
+            2,
+            29,
+        );
+        let unit = item(&items, "Øre per mark");
+        assert_eq!(unit["textEdit"], edit(2, 23, 29, "'Øre per mark']"));
+
+        let model = "package P {\n    part def 'Vehicle One'; part def 'Part Number'; \
+                     item def 'Fuel Oil'; part def 'Fuel Tank'; attribute 'Flow Rate'; \
+                     part def 'Front Left Wheel';\n    LINE\n}\n";
+        for (line, character, start, label, filter) in [
+            // A type, then the start of `ordered`.
+            ("part w : Vehicle o", 22, 21, "Vehicle One", "Vehicle_One"),
+            // A declared name, then another word.
+            ("in item fuel O", 18, 17, "Fuel Oil", "Fuel_Oil"),
+            // A feature, then the start of `then`.
+            ("first fuel t", 16, 15, "Fuel Tank", "Fuel_Tank"),
+            // A keyword, then a declared name.
+            ("flow r", 10, 9, "Flow Rate", "Flow_Rate"),
+            // Words that do not begin the name.
+            ("part w : Truck O", 20, 19, "Vehicle One", "Vehicle_One"),
+            // Three words: a typed space still closes the list.
+            (
+                "part w : Front L",
+                20,
+                19,
+                "Front Left Wheel",
+                "Front_Left_Wheel",
+            ),
+        ] {
+            let items = complete(&model.replace("LINE", line), 2, character);
+            let one = item(&items, label);
+            let spelled = format!("'{label}'");
+            assert_eq!(
+                one["textEdit"],
+                edit(2, start, character, &spelled),
+                "{line:?}"
+            );
+            assert_eq!(one["filterText"], filter, "{line:?}");
+        }
+        // A declared name after its keyword takes no element name at all,
+        // so none can replace the keyword either.
+        let items = complete(&model.replace("LINE", "part n"), 2, 10);
+        assert!(
+            items.iter().all(|i| i["label"] != "Part Number"),
+            "{items:?}"
+        );
+    }
+
+    /// A name containing whitespace (a model's own `'Vehicle One'`)
+    /// cannot keep an editor's list open past a typed space. The editor
+    /// refilters an open list by the text typed since each item's range
+    /// start, spaces included, and closes it only when nothing matches;
+    /// a list the `:` trigger opened must therefore empty on the space
+    /// that follows, so the next word opens a fresh list instead of
+    /// being filtered against this one. The name stays reachable by
+    /// typing it: a word of it, or its quoted spelling.
+    #[test]
+    fn a_typed_space_closes_the_list_on_multiword_names() {
+        // The editor's filter, reduced to what decides here: the typed
+        // characters occur in order in the item's filter text.
+        let keeps = |item: &serde_json::Value, typed: &str| {
+            let filter = item["filterText"]
+                .as_str()
+                .or(item["label"].as_str())
+                .expect("label")
+                .to_lowercase();
+            let mut rest = filter.chars();
+            typed.to_lowercase().chars().all(|t| rest.any(|c| c == t))
+        };
+        let mut s = two_package_server();
+        let mut complete = |version: i32, line: &str, character: u32| {
+            let text = format!("package P {{\n    part def 'Vehicle One';\n{line}\n}}\n");
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": format!("file:///w/m{version}.sysml"),
+                                     "languageId": "sysml", "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": version, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": format!("file:///w/m{version}.sysml")},
+                               "position": {"line": 2, "character": character}}}),
+            );
+            out[0]["result"]
+                .as_array()
+                .expect("completion items")
+                .clone()
+        };
+
+        // The list the `:` trigger opens: every item's range starts at
+        // the cursor, so a typed space is the text each is filtered by.
+        let items = complete(1, "    part w :", 12);
+        let one = items
+            .iter()
+            .find(|i| i["label"] == "Vehicle One")
+            .expect("the workspace's multi-word name is offered");
+        assert_eq!(one["textEdit"]["range"]["start"]["character"], 12);
+        let alive: Vec<&str> = items
+            .iter()
+            .filter(|i| keeps(i, " "))
+            .filter_map(|i| i["label"].as_str())
+            .collect();
+        assert!(alive.is_empty(), "a typed space keeps {alive:?}");
+
+        // Typed after the space: a fresh list finds it by a word.
+        let items = complete(2, "    part w : Veh", 16);
+        let one = items
+            .iter()
+            .find(|i| i["label"] == "Vehicle One")
+            .expect("offered after its first word");
+        assert!(keeps(one, "Veh") && keeps(one, "One"), "{one}");
+        assert_eq!(one["textEdit"]["newText"], "'Vehicle One'");
+
+        // Inside quotes the space is part of the name being typed.
+        let items = complete(3, "    part w : 'Vehicle O'", 23);
+        let one = items
+            .iter()
+            .find(|i| i["label"] == "Vehicle One")
+            .expect("offered inside quotes");
+        assert!(keeps(one, "'Vehicle O"), "{one}");
+
+        // In a bracket, where multi-word units are offered too.
+        let items = complete(4, "    attribute g = 9.8 [", 23);
+        assert!(
+            completion_labels(&items).contains(&"metre per second squared"),
+            "units offered in a bracket"
+        );
+        let alive: Vec<&str> = items
+            .iter()
+            .filter(|i| keeps(i, " "))
+            .filter_map(|i| i["label"].as_str())
+            .collect();
+        assert!(alive.is_empty(), "a typed space keeps {alive:?}");
+    }
+
     /// Accepting a suggestion also repairs the statement being typed
-    /// (autofix): unclosed quantity brackets close and the terminal
-    /// `;` appears — riding the main edit on a bare tail, as an
-    /// insertion behind an already-auto-closed bracket otherwise.
+    /// (autofix): an unclosed quantity bracket closes, riding the main
+    /// edit on a bare tail. The terminal `;` is never inserted — not on
+    /// a bare tail, not behind an already-auto-closed bracket.
     #[test]
     fn completion_repairs_the_statement() {
         let mut s = two_package_server();
@@ -682,9 +1115,9 @@ mod tests {
             serde_json::json!({
                 "range": {"start": {"line": 1, "character": 29},
                           "end": {"line": 1, "character": 30}},
-                "newText": "'m/s²'];"
+                "newText": "'m/s²']"
             }),
-            "bracket close + terminator ride the main edit"
+            "the bracket close rides the main edit, no terminator"
         );
         // The import edit rides along as before.
         assert_eq!(
@@ -692,8 +1125,8 @@ mod tests {
             "private import MiniLib::'m/s²';\n    "
         );
 
-        // Auto-closed variant: `]` already after the cursor — the `;`
-        // becomes its own insertion behind it.
+        // Auto-closed variant: `]` already after the cursor — nothing
+        // left to repair.
         responses(
             &mut s,
             &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
@@ -707,22 +1140,17 @@ mod tests {
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
                            "position": {"line": 1, "character": 30}}}),
         );
-        let items = out[0]["result"].as_array().expect("completion items");
+        let items = &completion_items(&out[0]["result"]);
         let unit = items.iter().find(|i| i["label"] == "m/s²").expect("m/s²");
         assert_eq!(
             unit["textEdit"]["newText"], "'m/s²'",
             "no suffix on the main edit"
         );
         let extras = unit["additionalTextEdits"].as_array().expect("extras");
-        assert_eq!(extras.len(), 2, "import + terminator: {extras:?}");
+        assert_eq!(extras.len(), 1, "the import only: {extras:?}");
         assert_eq!(
-            extras[1],
-            serde_json::json!({
-                "range": {"start": {"line": 1, "character": 31},
-                          "end": {"line": 1, "character": 31}},
-                "newText": ";"
-            }),
-            "terminator lands behind the existing `]`"
+            extras[0]["newText"],
+            "private import MiniLib::'m/s²';\n    "
         );
 
         // Already terminated: nothing to repair.
@@ -739,7 +1167,7 @@ mod tests {
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
                            "position": {"line": 1, "character": 30}}}),
         );
-        let items = out[0]["result"].as_array().expect("completion items");
+        let items = &completion_items(&out[0]["result"]);
         let unit = items.iter().find(|i| i["label"] == "m/s²").expect("m/s²");
         assert_eq!(unit["textEdit"]["newText"], "'m/s²'");
         assert_eq!(
@@ -749,9 +1177,75 @@ mod tests {
         );
     }
 
+    /// Unit typing reads where accepted text goes as well as the
+    /// accepts themselves: one read of the text ahead of the cursor
+    /// serves both.
+    #[test]
+    fn completion_reads_the_quoted_name_once_per_request() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    attribute g = 9.8 ['m\n}\n"}}}),
+        );
+        crate::accept::QUOTE_READS.with(|n| n.set(0));
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": 1, "character": 24}}}),
+        );
+        assert!(
+            completion_labels(out[0]["result"].as_array().expect("items")).contains(&"m/s²"),
+            "{out:?}"
+        );
+        assert_eq!(crate::accept::QUOTE_READS.with(std::cell::Cell::get), 1);
+    }
+
+    /// The statement is scanned for repairs once per replacement start
+    /// the request's items share, not once per item: after `[m/` every
+    /// name starts at the cursor but `m/s²`, which reaches back over its
+    /// own characters.
+    #[test]
+    fn completion_scans_the_statement_once_per_replacement_start() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    \
+                                          attribute <u1> unitOne : MeasurementReferences::TensorMeasurementReference;\n    \
+                                          attribute <u2> unitTwo : MeasurementReferences::TensorMeasurementReference;\n    \
+                                          attribute gravity = 9.8 [m/\n}\n"}}}),
+        );
+        crate::autofix::SCANS.with(|n| n.set(0));
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": 3, "character": 31}}}),
+        );
+        let items = out[0]["result"].as_array().expect("completion items");
+        let repaired: Vec<&str> = items
+            .iter()
+            .filter_map(|i| i["textEdit"]["newText"].as_str())
+            .filter(|t| t.ends_with(']'))
+            .collect();
+        assert!(repaired.len() > 2, "names carry the `]`: {repaired:?}");
+        assert!(repaired.contains(&"'m/s²']"), "{repaired:?}");
+        assert_eq!(
+            crate::autofix::SCANS.with(std::cell::Cell::get),
+            2,
+            "one scan per distinct replacement start"
+        );
+    }
+
     /// A snippet-capable client gets the repair suffix behind a `$0`
     /// stop: accepting leaves the cursor after the accepted name,
-    /// before the auto-inserted `];`, where typing continues.
+    /// before the auto-inserted `]`, where typing continues.
     #[test]
     fn snippet_client_gets_cursor_stop_before_repairs() {
         let mut s = two_package_server_with_caps(&serde_json::json!({
@@ -773,12 +1267,12 @@ mod tests {
         let items = out[0]["result"].as_array().expect("completion items");
         let unit = items.iter().find(|i| i["label"] == "m/s²").expect("m/s²");
         assert_eq!(
-            unit["textEdit"]["newText"], "'m/s²'$0];",
+            unit["textEdit"]["newText"], "'m/s²'$0]",
             "cursor stop between the name and the repair suffix"
         );
         assert_eq!(unit["insertTextFormat"], 2, "snippet format declared");
 
-        // An import-context accept carries its `;` the same way.
+        // An import-context accept adds no terminator, so no snippet.
         responses(
             &mut s,
             &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
@@ -797,8 +1291,11 @@ mod tests {
             .iter()
             .find(|i| i["label"] == "Widget")
             .expect("Widget");
-        assert_eq!(widget["textEdit"]["newText"], "MiniLib::Widget$0;");
-        assert_eq!(widget["insertTextFormat"], 2);
+        assert_eq!(widget["textEdit"]["newText"], "MiniLib::Widget");
+        assert!(
+            widget["insertTextFormat"].is_null(),
+            "plain edit stays plain"
+        );
 
         // No repairs → no snippet: the plain quoting edit stays plain.
         responses(
@@ -814,63 +1311,229 @@ mod tests {
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
                            "position": {"line": 1, "character": 30}}}),
         );
-        let items = out[0]["result"].as_array().expect("completion items");
+        let items = &completion_items(&out[0]["result"]);
         let unit = items.iter().find(|i| i["label"] == "m/s²").expect("m/s²");
         assert_eq!(unit["textEdit"]["newText"], "'m/s²'");
         assert!(unit["insertTextFormat"].is_null(), "plain edit stays plain");
-    }
 
-    /// An accept landing mid-chain (`fuelTank.over|.volume`) keeps the
-    /// tail and lands the terminator behind it as its own insertion —
-    /// the cursor (end of the main insertion) stays at the accepted
-    /// name: `fuelTank.overhead|.volume;`.
-    #[test]
-    fn terminator_lands_behind_a_chain_tail() {
-        let mut s = two_package_server();
+        // A filter condition's open bracket closes behind the path.
         responses(
             &mut s,
-            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
-                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
-                                 "version": 1,
-                                 "text": "package P {\n    attribute g = Widge.value\n}\n"}}}),
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "version": 5},
+                "contentChanges": [
+                    {"text": "package P {\n    private import OtherLib::*[@Widge\n}\n"}]}}),
         );
         let out = responses(
             &mut s,
-            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+            &serde_json::json!({"jsonrpc": "2.0", "id": 9, "method": "textDocument/completion",
                 "params": {"textDocument": {"uri": "file:///w/m.sysml"},
-                           "position": {"line": 1, "character": 23}}}),
+                           "position": {"line": 1, "character": 37}}}),
         );
         let items = out[0]["result"].as_array().expect("completion items");
         let widget = items
             .iter()
             .find(|i| i["label"] == "Widget")
             .expect("Widget");
-        let extras = widget["additionalTextEdits"].as_array().expect("extras");
-        let terminator = extras.last().expect("terminator edit");
-        assert_eq!(
-            terminator,
-            &serde_json::json!({
-                "range": {"start": {"line": 1, "character": 29},
-                          "end": {"line": 1, "character": 29}},
-                "newText": ";"
-            }),
-            "terminator lands at the end of the chain tail"
+        assert_eq!(widget["textEdit"]["newText"], "MiniLib::Widget$0]");
+        assert_eq!(widget["insertTextFormat"], 2);
+
+        // A terminator right at the cursor: the `]` rides the main edit
+        // ahead of it — never an extra edit at the main edit's end.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "version": 6},
+                "contentChanges": [
+                    {"text": "package P {\n    attribute gravity = 9.8 [m;\n}\n"}]}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 10, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": 1, "character": 30}}}),
         );
+        let items = out[0]["result"].as_array().expect("completion items");
+        let unit = items.iter().find(|i| i["label"] == "m/s²").expect("m/s²");
+        assert_eq!(unit["textEdit"]["newText"], "'m/s²'$0]");
+        let extras = unit["additionalTextEdits"].as_array().expect("extras");
+        assert_eq!(extras.len(), 1, "the import only: {extras:?}");
     }
 
-    /// After a feature-chain dot (`oxidizerTank.`) the list is the
-    /// members the step can reach — the feature's own body, its
-    /// declared type's features, and inherited ones — not the
-    /// position-blind pile; and the statement still gets its `;`.
+    /// With the cursor inside a word (`Wid|get`), a client that takes
+    /// insert/replace edits gets both ranges on every item, keywords
+    /// included — insert up to the cursor, replace through the rest of
+    /// the word — so its own setting decides. Quoting holds in both; a
+    /// repair behind the word is dropped (it would overlap the
+    /// replacement), one past it stays. Other clients keep the insert
+    /// range alone.
     #[test]
-    fn dot_completions_offer_chain_members() {
-        let mut s = two_package_server();
-        let text = "package P {\n\
-                    \x20   part def Vessel {\n\
-                    \x20       attribute capacity;\n\
-                    \x20   }\n\
-                    \x20   part def Tank :> Vessel {\n\
-                    \x20       part containedliquid;\n\
+    fn mid_word_completions_carry_insert_and_replace_ranges() {
+        let complete = |caps: &serde_json::Value, line: &str, character: u32| {
+            let mut s = two_package_server_with_caps(caps);
+            let text = format!("package P {{\n{line}\n}}\n");
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 1, "character": character}}}),
+            );
+            out[0]["result"]
+                .as_array()
+                .expect("completion items")
+                .clone()
+        };
+        let range = |start: u32, end: u32| {
+            serde_json::json!({"start": {"line": 1, "character": start},
+                               "end": {"line": 1, "character": end}})
+        };
+        let find = |items: &[serde_json::Value], label: &str, kind: Option<u32>| {
+            items
+                .iter()
+                .find(|i| i["label"] == label && kind.is_none_or(|k| i["kind"] == k))
+                .unwrap_or_else(|| panic!("{label} offered"))
+                .clone()
+        };
+        let both = serde_json::json!({
+            "general": {"positionEncodings": ["utf-8"]},
+            "textDocument": {"completion": {"completionItem": {"insertReplaceSupport": true}}}});
+        let insert_only = serde_json::json!({"general": {"positionEncodings": ["utf-8"]}});
+        const CLASS: Option<u32> = Some(7);
+        const KEYWORD: Option<u32> = Some(14);
+
+        // A plain name: `Wid|get` over 12..18.
+        let items = complete(&both, "    ref w : Widget;", 15);
+        let widget = find(&items, "Widget", CLASS);
+        assert_eq!(
+            widget["textEdit"],
+            serde_json::json!({"newText": "Widget", "insert": range(12, 15),
+                               "replace": range(12, 18)})
+        );
+        assert_eq!(
+            widget["additionalTextEdits"][0]["newText"], "private import MiniLib::Widget;\n    ",
+            "the import rides as before"
+        );
+        // A keyword: `pa|rt` over 4..8.
+        let items = complete(&both, "    part w : Widget;", 6);
+        let part = find(&items, "part", KEYWORD);
+        assert_eq!(
+            part["textEdit"],
+            serde_json::json!({"newText": "part", "insert": range(4, 6),
+                               "replace": range(4, 8)})
+        );
+        let items = complete(&insert_only, "    ref w : Widget;", 15);
+        assert!(find(&items, "Widget", CLASS)["textEdit"].is_null());
+        let items = complete(&insert_only, "    part w : Widget;", 6);
+        assert!(find(&items, "part", KEYWORD)["textEdit"].is_null());
+        // At a word's end the two ranges would be one: no edit either.
+        let items = complete(&both, "    ref w : Widget;", 18);
+        assert!(find(&items, "Widget", CLASS)["textEdit"].is_null());
+        let items = complete(&both, "    part w : Widget;", 8);
+        assert!(find(&items, "part", KEYWORD)["textEdit"].is_null());
+
+        // `[m|s` with the bracket open: the `]` would land where the
+        // replacement ends — it rides the main edit with both ranges,
+        // and lands behind the word for an inserting client.
+        let items = complete(&both, "    attribute g = 9.8 [ms", 24);
+        let unit = find(&items, "m/s²", None);
+        assert_eq!(
+            unit["textEdit"],
+            serde_json::json!({"newText": "'m/s²']", "insert": range(23, 24),
+                               "replace": range(23, 25)})
+        );
+        let extras = unit["additionalTextEdits"].as_array().expect("extras");
+        assert_eq!(extras.len(), 1, "the import only: {extras:?}");
+        let items = complete(&insert_only, "    attribute g = 9.8 [ms", 24);
+        let unit = find(&items, "m/s²", None);
+        assert_eq!(
+            unit["textEdit"],
+            serde_json::json!({"newText": "'m/s²'", "range": range(23, 24)})
+        );
+        assert_eq!(
+            unit["additionalTextEdits"][1],
+            serde_json::json!({"newText": "]", "range": range(25, 25)})
+        );
+
+        // `[m|s.x`: the `]` lands past the chain tail, strictly past
+        // either range — kept.
+        let items = complete(&both, "    attribute g = 9.8 [ms.x", 24);
+        let unit = find(&items, "m/s²", None);
+        assert_eq!(
+            unit["textEdit"],
+            serde_json::json!({"newText": "'m/s²'", "insert": range(23, 24),
+                               "replace": range(23, 25)})
+        );
+        assert_eq!(
+            unit["additionalTextEdits"][1],
+            serde_json::json!({"newText": "]", "range": range(27, 27)})
+        );
+    }
+
+    /// An accept landing mid-chain (`fuelTank.over|.volume`) keeps the
+    /// tail and inserts nothing behind it: the only extra edit is the
+    /// name's import.
+    #[test]
+    fn accept_mid_chain_adds_no_terminator() {
+        // A library feature: the operand an expression names.
+        let mut s = PushServer::with_library_sources(
+            vec![(
+                "MiniLib.kerml".to_string(),
+                "standard library package MiniLib { class Widget; feature widgets : Widget; }"
+                    .to_string(),
+            )],
+            None,
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    attribute g = widge.value\n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": 1, "character": 23}}}),
+        );
+        let items = out[0]["result"].as_array().expect("completion items");
+        let widgets = items
+            .iter()
+            .find(|i| i["label"] == "widgets")
+            .expect("widgets");
+        let extras = widgets["additionalTextEdits"].as_array().expect("extras");
+        assert_eq!(extras.len(), 1, "the import only: {extras:?}");
+        assert_eq!(
+            extras[0]["newText"],
+            "private import MiniLib::widgets;\n    "
+        );
+        assert!(widgets["textEdit"].is_null(), "plain insertion: {widgets}");
+    }
+
+    /// After a feature-chain dot (`oxidizerTank.`) the list is the
+    /// members the step can reach — the feature's own body, its
+    /// declared type's features, and inherited ones — not the
+    /// position-blind pile.
+    #[test]
+    fn dot_completions_offer_chain_members() {
+        let mut s = two_package_server();
+        let text = "package P {\n\
+                    \x20   part def Vessel {\n\
+                    \x20       attribute capacity;\n\
+                    \x20   }\n\
+                    \x20   part def Tank :> Vessel {\n\
+                    \x20       part containedliquid;\n\
                     \x20       attribute liquidMass;\n\
                     \x20   }\n\
                     \x20   part propSys {\n\
@@ -896,16 +1559,22 @@ mod tests {
         let labels = completion_labels(items);
         assert_eq!(
             labels,
-            vec!["extra", "containedliquid", "liquidMass", "capacity"],
+            vec![
+                "extra",
+                "containedliquid",
+                "liquidMass",
+                "capacity",
+                "metadata"
+            ],
             "own body, declared type, then inherited — nothing else"
         );
         let mass = items
             .iter()
             .find(|i| i["label"] == "liquidMass")
             .expect("liquidMass");
-        assert_eq!(
-            mass["textEdit"]["newText"], "liquidMass;",
-            "the statement repair rides along"
+        assert!(
+            mass["textEdit"].is_null(),
+            "plain insertion, no terminator: {mass}"
         );
         assert_eq!(mass["detail"], "P::Tank::liquidMass");
 
@@ -933,7 +1602,8 @@ mod tests {
             "the chain resolves hop by hop"
         );
 
-        // An unresolvable head falls back to the position-blind list.
+        // An unresolvable head offers nothing: after a dot, keywords and
+        // the library's names are never what is wanted.
         let broken = text.replace("= oxidizerTank.", "= noSuchTank.");
         responses(
             &mut s,
@@ -948,10 +1618,469 @@ mod tests {
                            "position": {"line": 12, "character": 36}}}),
         );
         let items = out[0]["result"].as_array().expect("completion items");
+        assert!(items.is_empty(), "nothing to offer: {items:?}");
+    }
+
+    /// The model the member-access tests complete in; `§` marks where
+    /// the statement being typed goes.
+    const VEHICLES: &str = "package P {\n\
+                            \x20   port def FuelPort { out item fuel; }\n\
+                            \x20   part def Wheel { attribute diameter; }\n\
+                            \x20   part def Vehicle {\n\
+                            \x20       attribute mass;\n\
+                            \x20       port fuelIn : ~FuelPort;\n\
+                            \x20       part wheels : Wheel [4];\n\
+                            \x20   }\n\
+                            \x20   part vehicle1 : Vehicle;\n\
+                            \x20   attribute def Energy { attribute joules; }\n\
+                            \x20   attribute def Scalar;\n\
+                            \x20   calc def KineticEnergy { in m; in v; return : Energy; }\n\
+                            \x20   calc def Ratio { in a; in b; return : Scalar; }\n\
+                            \x20   part def Q {\n\
+                            \x20       port fp : ~FuelPort;\n\
+                            \x20       calc k : KineticEnergy;\n\
+                            \x20       §\n\
+                            \x20   }\n\
+                            }\n";
+
+    /// The labels completion offers at the `|` in `marked`, opened as
+    /// `uri` on `s` (utf-8 positions, as the fixture negotiates).
+    fn labels_at_mark_in(s: &mut PushServer, uri: &str, marked: &str) -> Vec<String> {
+        completion_labels(&items_at_mark_in(s, uri, marked))
+            .into_iter()
+            .map(str::to_string)
+            .collect()
+    }
+
+    /// The items completion offers at the `|` in `marked` (see
+    /// [`labels_at_mark_in`]).
+    fn items_at_mark_in(s: &mut PushServer, uri: &str, marked: &str) -> Vec<serde_json::Value> {
+        let at = marked.find('|').expect("a cursor mark");
+        let line = marked[..at].matches('\n').count();
+        let character = at - marked[..at].rfind('\n').map_or(0, |i| i + 1);
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": uri, "languageId": "sysml", "version": 1,
+                                 "text": marked.replacen('|', "", 1)}}}),
+        );
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": uri},
+                           "position": {"line": line, "character": character}}}),
+        );
+        completion_items(&out[0]["result"])
+    }
+
+    /// [`labels_at_mark_in`] on a fresh server, `statement` typed at
+    /// [`VEHICLES`]' mark.
+    fn vehicle_labels(statement: &str) -> Vec<String> {
+        let mut s = two_package_server();
+        labels_at_mark_in(
+            &mut s,
+            "file:///w/m.sysml",
+            &VEHICLES.replace('§', statement),
+        )
+    }
+
+    /// A closing brace after the cursor on the same line closes the body
+    /// around the statement being typed: the completion session cuts
+    /// the statement and keeps the brace.
+    #[test]
+    fn member_access_before_a_closing_brace_on_the_same_line() {
+        for statement in [
+            "assert constraint { vehicle1.| }",
+            "assert constraint { vehicle1.|}",
+            "part def R { attribute m = vehicle1.| }",
+        ] {
+            assert_eq!(
+                vehicle_labels(statement),
+                ["mass", "fuelIn", "wheels", "metadata"],
+                "{statement}"
+            );
+        }
+    }
+
+    /// Syntax errors elsewhere — an earlier statement of the document, a
+    /// body left open above, another unit — do not switch member
+    /// completion off.
+    #[test]
+    fn member_access_survives_syntax_errors_elsewhere() {
+        let typed = VEHICLES.replace('§', "attribute m = vehicle1.|");
+        for broken in [
+            typed.replace(
+                "    part def Q {\n",
+                "    part def Broken {\n        attribute x = ;\n    }\n    part def Q {\n",
+            ),
+            typed.replace(
+                "    part def Q {\n",
+                "    part def Broken {\n        attribute x;\n    part def Q {\n",
+            ),
+        ] {
+            let mut s = two_package_server();
+            assert_eq!(
+                labels_at_mark_in(&mut s, "file:///w/m.sysml", &broken),
+                ["mass", "fuelIn", "wheels", "metadata"],
+                "{broken}"
+            );
+        }
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/other.kerml", "languageId": "kerml",
+                                 "version": 1, "text": "package K {\n    feature m\n"}}}),
+        );
+        assert_eq!(
+            labels_at_mark_in(&mut s, "file:///w/m.sysml", &typed),
+            ["mass", "fuelIn", "wheels", "metadata"],
+            "another unit that does not parse"
+        );
+    }
+
+    /// A member the parser cannot read elsewhere in the document — a
+    /// value left out before its `;` (which then reads as a value), a
+    /// group or a name left open at the end of a line — leaves the rest
+    /// of the document in the completion model: member access still
+    /// reaches the declared and the inherited members, above the broken
+    /// member and below it.
+    #[test]
+    fn member_access_survives_an_unreadable_member_elsewhere() {
+        let text = "package P {\n\
+                    \x20   part def Vessel { attribute capacity; }\n\
+                    \x20   part def Tank :> Vessel { attribute liquidMass; }\n\
+                    \x20   §\n\
+                    \x20   part tank : Tank;\n\
+                    \x20   part def Q {\n\
+                    \x20       attribute t = tank.|\n\
+                    \x20       ¶\n\
+                    \x20   }\n\
+                    }\n";
+        for broken in [
+            "part z { attribute = ; }",
+            "part z { attribute q = (1 + ; }",
+            "perform action a { in x = ; }",
+            "attribute q = (1 + ;",
+            "attribute q = f(1, ;",
+            "attribute m = 5 [kg",
+            "attribute q = tank.",
+            "part x : Tank::",
+        ] {
+            for (above, below) in [(broken, ""), ("", broken)] {
+                let mut s = two_package_server();
+                let marked = text.replace('§', above).replace('¶', below);
+                assert_eq!(
+                    labels_at_mark_in(&mut s, "file:///w/m.sysml", &marked),
+                    ["liquidMass", "capacity", "metadata"],
+                    "{marked}"
+                );
+            }
+        }
+    }
+
+    /// A port typed by a conjugated port definition (`~FuelPort`) has
+    /// the original definition's features.
+    #[test]
+    fn member_access_follows_conjugated_port_types() {
+        assert_eq!(vehicle_labels("ref f = vehicle1.fuelIn.|"), ["fuel"]);
+        assert_eq!(vehicle_labels("ref x = fp.|"), ["fuel", "metadata"]);
+    }
+
+    /// An indexed feature's elements have the feature's own type, and an
+    /// invocation evaluates to its callee's result — through a usage
+    /// typed by the callee too; a result type without features offers
+    /// nothing.
+    #[test]
+    fn member_access_after_an_index_or_an_invocation() {
+        assert_eq!(
+            vehicle_labels("attribute d = vehicle1.wheels#(1).|"),
+            ["diameter"]
+        );
+        assert_eq!(
+            vehicle_labels("attribute d = vehicle1.wheels#(1).dia|"),
+            ["diameter"]
+        );
+        assert_eq!(
+            vehicle_labels("attribute e = KineticEnergy(1, 2).|"),
+            ["joules"]
+        );
+        assert_eq!(vehicle_labels("attribute e = k(1, 2).|"), ["joules"]);
+        assert!(vehicle_labels("attribute r = Ratio(1, 2).|").is_empty());
+    }
+
+    /// A receiver whose head is qualified resolves as written, not by its
+    /// last segment alone.
+    #[test]
+    fn member_access_through_a_qualified_head() {
+        assert_eq!(
+            vehicle_labels("attribute d = P::Vehicle::wheels.|"),
+            ["diameter", "metadata"]
+        );
+        assert_eq!(
+            vehicle_labels("attribute d = P::vehicle1.wheels.|"),
+            ["diameter"]
+        );
+        // The same name nearer the cursor does not capture it.
+        let mut s = two_package_server();
+        let text = VEHICLES
+            .replace(
+                "    part vehicle1 : Vehicle;\n",
+                "    part vehicle1 : Vehicle;\n    package Inner { part vehicle1 : Wheel; }\n",
+            )
+            .replace('§', "attribute d = Inner::vehicle1.|");
+        assert_eq!(
+            labels_at_mark_in(&mut s, "file:///w/m.sysml", &text),
+            ["diameter", "metadata"]
+        );
+        // Rooted at the global namespace (`$::`, as a lifted model spells
+        // it): past a nearer declaration of the same name.
+        let mut s = two_package_server();
+        let text = format!(
+            "part def W {{ attribute d; }}\npart vehicle1 : W;\n{}",
+            VEHICLES.replace('§', "attribute d = $::vehicle1.|")
+        );
+        assert_eq!(
+            labels_at_mark_in(&mut s, "file:///w/m.sysml", &text),
+            ["d", "metadata"]
+        );
+        assert_eq!(
+            vehicle_labels("attribute d = $::P::vehicle1.wheels.|"),
+            ["diameter"]
+        );
+    }
+
+    /// A receiver named by a reference also takes the `metadata` keyword
+    /// of a metadata access (`vehicle1.metadata`), listed after its
+    /// members; a package, a chain step, or a name that does not resolve
+    /// does not.
+    #[test]
+    fn member_access_offers_metadata_after_a_reference() {
+        let mut s = two_package_server();
+        let items = items_at_mark_in(
+            &mut s,
+            "file:///w/m.sysml",
+            &VEHICLES.replace('§', "attribute m = vehicle1.|"),
+        );
+        let metadata = items.last().expect("items");
+        assert_eq!(metadata["label"], "metadata");
+        assert_eq!(metadata["kind"], 14, "a keyword: {metadata}");
+        // Listed after every member, which keep their labels' order.
+        for member in &items[..items.len() - 1] {
+            let label = member["label"].as_str().expect("a label");
+            assert_eq!(member["sortText"], format!("0{label}"));
+            assert!(
+                member["sortText"].as_str() < metadata["sortText"].as_str(),
+                "{member} after {metadata}"
+            );
+        }
+        // A package's dot is usually a slip for `::`: nothing there.
+        assert!(vehicle_labels("attribute m = P.|").is_empty());
+        assert_eq!(
+            vehicle_labels("attribute m = vehicle1.wheels.|"),
+            ["diameter"]
+        );
+        assert!(vehicle_labels("attribute m = noSuch.|").is_empty());
+    }
+
+    /// A member name typed quoted right after the dot (`vehicle1.'ma|`,
+    /// or `vehicle1.'ma|'` where an editor closes quotes) lists the
+    /// receiver's members, accepting one replacing the quoted name.
+    #[test]
+    fn member_access_takes_a_member_typed_quoted() {
+        for (statement, end) in [
+            ("attribute m = vehicle1.'ma|", 34),
+            ("attribute m = vehicle1.'ma|'", 35),
+        ] {
+            let text = VEHICLES.replace('§', statement);
+            let line = text[..text.find('|').expect("a cursor mark")]
+                .matches('\n')
+                .count();
+            let mut s = two_package_server();
+            let items = items_at_mark_in(&mut s, "file:///w/m.sysml", &text);
+            assert_eq!(
+                completion_labels(&items),
+                ["mass", "fuelIn", "wheels"],
+                "{statement}"
+            );
+            // The quote opens at 31, after `        attribute m = vehicle1.`.
+            assert_eq!(
+                items[0]["textEdit"],
+                serde_json::json!({
+                    "range": {"start": {"line": line, "character": 31},
+                              "end": {"line": line, "character": end}},
+                    "newText": "mass"
+                }),
+                "{statement}"
+            );
+        }
+    }
+
+    /// In KerML a receiver may use a word the SysML notation reserves as
+    /// a name (`part`): it is read in the document's own dialect.
+    #[test]
+    fn member_access_reads_a_kerml_receiver_in_kerml() {
+        let mut s = two_package_server();
+        assert_eq!(
+            labels_at_mark_in(
+                &mut s,
+                "file:///w/k.kerml",
+                "package K {\n    classifier Wheel { feature diameter; }\n    \
+                 feature part : Wheel[4];\n    feature d = part#(1).|\n}\n",
+            ),
+            ["diameter"]
+        );
+    }
+
+    /// A member an owned feature redefines is offered once, as the
+    /// redefinition (an unnamed `:>> mass` keyed by the name it
+    /// redefines); a private member of the type is not offered.
+    #[test]
+    fn member_access_offers_a_redefinition_once_and_no_private_members() {
+        let text = VEHICLES
+            .replace(
+                "    part vehicle1 : Vehicle;\n",
+                "    part vehicle1 : Vehicle { attribute :>> mass = 1500; }\n",
+            )
+            .replace(
+                "        attribute mass;\n",
+                "        attribute mass;\n        private attribute secret;\n",
+            )
+            .replace('§', "attribute m = vehicle1.|");
+        let mut s = two_package_server();
+        let items = items_at_mark_in(&mut s, "file:///w/m.sysml", &text);
+        assert_eq!(
+            completion_labels(&items),
+            ["mass", "fuelIn", "wheels", "metadata"]
+        );
+        assert_eq!(items[0]["detail"], "P::vehicle1::mass");
+    }
+
+    /// A unit that does not parse still contributes the declarations
+    /// around its error: a receiver typed by a definition declared there
+    /// lists that definition's features.
+    #[test]
+    fn member_access_reaches_types_declared_in_a_unit_that_does_not_parse() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/other.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package O {\n    part def Tank { attribute level; }\n    attribute broken = ;\n}\n"}}}),
+        );
+        assert_eq!(
+            labels_at_mark_in(
+                &mut s,
+                "file:///w/m.sysml",
+                "package M {\n    private import O::*;\n    part t : Tank;\n    attribute x = t.|\n}\n",
+            ),
+            ["level", "metadata"]
+        );
+    }
+
+    /// A declaration whose `;` is still missing counts as declared, the
+    /// way the parser reads it: a receiver it declares lists members.
+    #[test]
+    fn member_access_reaches_a_declaration_missing_its_terminator() {
+        let text = VEHICLES
+            .replace("port fp : ~FuelPort;", "port fp : ~FuelPort")
+            .replace('§', "ref x = fp.|");
+        let mut s = two_package_server();
+        assert_eq!(
+            labels_at_mark_in(&mut s, "file:///w/m.sysml", &text),
+            ["fuel", "metadata"]
+        );
+    }
+
+    /// A quantity's unit bracket offers units and nothing else: no
+    /// keywords, no other names. The fixture library's one unit is
+    /// offered by its short symbol first.
+    #[test]
+    fn unit_brackets_offer_only_units() {
+        for marked in [
+            "package P {\n    attribute g = 9.8 [|\n}\n",
+            "package P {\n    attribute g = 9.8 [|];\n}\n",
+            "package P {\n    part def V { attribute m; assert constraint { m <= 2 [| } }\n}\n",
+        ] {
+            let mut s = two_package_server();
+            assert_eq!(
+                labels_at_mark_in(&mut s, "file:///w/m.sysml", marked),
+                ["m/s²", "metre per second squared"],
+                "{marked:?}"
+            );
+        }
+        // A qualifier there lists its namespace's units alone.
+        let mut s = two_package_server();
+        let labels = labels_at_mark_in(
+            &mut s,
+            "file:///w/m.sysml",
+            "package P {\n    attribute g = 9.8 [MiniLib::|\n}\n",
+        );
+        assert!(labels.contains(&"m/s²".to_string()), "{labels:?}");
+        assert!(!labels.contains(&"Widget".to_string()), "{labels:?}");
+    }
+
+    /// A `[` that opens a multiplicity or an import's filter, or none at
+    /// all (in a comment or a string), offers nothing: an editor that
+    /// opens a list on `[` shows none there.
+    #[test]
+    fn brackets_without_a_unit_offer_nothing() {
+        for marked in [
+            "package P {\n    part w : Widget [|\n}\n",
+            "package P {\n    part w : Widget[|]\n}\n",
+            "package P {\n    part w : Widget [0..|\n}\n",
+            "package P {\n    part w : Widget [1|\n}\n",
+            "package P {\n    part w : Widget [0..5|\n}\n",
+            "package P {\n    part w [|\n}\n",
+            "package P {\n    attribute a : Widget [1] = 5; part w : Widget [|\n}\n",
+            "package P {\n    private import MiniLib::*[|\n}\n",
+            "package P {\n    doc /* see [| */\n}\n",
+            "package P {\n    attribute s = \"a [|\";\n}\n",
+        ] {
+            let mut s = two_package_server();
+            let labels = labels_at_mark_in(&mut s, "file:///w/m.sysml", marked);
+            assert!(labels.is_empty(), "{marked:?}: {labels:?}");
+        }
+    }
+
+    /// A multiplicity's bound may name a feature (`[1..numberOfBolts]`),
+    /// and a filter a metadata definition: once a name is typed there,
+    /// names are offered again — but no unit's long name, which only a
+    /// unit bracket takes.
+    #[test]
+    fn a_name_typed_in_a_bound_or_a_filter_is_completed() {
+        let mut s = two_package_server();
+        let labels = labels_at_mark_in(
+            &mut s,
+            "file:///w/m.sysml",
+            "package P {\n    attribute count;\n    part w : Widget [1..co|\n}\n",
+        );
+        assert!(labels.contains(&"count".to_string()), "{labels:?}");
         assert!(
-            completion_labels(items).contains(&"part"),
-            "fallback keeps the keyword tier"
+            !labels.contains(&"metre per second squared".to_string()),
+            "{labels:?}"
+        );
+        let mut s = two_package_server();
+        let labels = labels_at_mark_in(
+            &mut s,
+            "file:///w/m.sysml",
+            "package P {\n    view def V { expose MiniLib::**[@Wid| }\n}\n",
         );
+        assert!(labels.contains(&"Widget".to_string()), "{labels:?}");
+    }
+
+    /// `[` opens completion like `:` and `.` do.
+    #[test]
+    fn a_bracket_triggers_completion() {
+        let mut s = PushServer::new();
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {}}}),
+        );
+        let triggers = &out[0]["result"]["capabilities"]["completionProvider"]["triggerCharacters"];
+        assert_eq!(triggers, &serde_json::json!([":", ".", "["]));
     }
 
     /// An unresolved-reference diagnostic offers exact-name import
@@ -1089,18 +2218,434 @@ mod tests {
         );
     }
 
-    fn two_package_server() -> PushServer {
-        two_package_server_with_caps(&serde_json::json!(
-            {"general": {"positionEncodings": ["utf-8"]}}))
-    }
-
-    fn two_package_server_with_caps(capabilities: &serde_json::Value) -> PushServer {
-        let mut s = PushServer::with_library_sources(
+    /// A `;` where none belongs — after a body's result expression, or
+    /// standing where a member would start (`;;`, `{ … };`) — is
+    /// removed by a preferred quick fix riding the error the server
+    /// published on it. A `;` an error sits on that the statement still
+    /// needs (`part p : ;`) gets none.
+    #[test]
+    fn code_action_removes_a_stray_terminator() {
+        let fixes = |text: &str| -> Vec<(String, serde_json::Value)> {
+            let mut s = two_package_server();
+            let opened = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let published = opened
+                .iter()
+                .find(|m| m["method"] == "textDocument/publishDiagnostics")
+                .expect("diagnostics published");
+            let diagnostics = published["params"]["diagnostics"].clone();
+            let mut out = Vec::new();
+            for d in diagnostics.as_array().expect("diagnostics") {
+                let answer = responses(
+                    &mut s,
+                    &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/codeAction",
+                        "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                                   "range": d["range"],
+                                   "context": {"diagnostics": [d]}}}),
+                );
+                for a in answer[0]["result"].as_array().expect("actions") {
+                    if a["title"] == "Remove `;`" {
+                        assert_eq!(a["isPreferred"], true, "{a}");
+                        let edit = &a["edit"]["changes"]["file:///w/m.sysml"][0];
+                        out.push((d["message"].as_str().unwrap().to_string(), edit.clone()));
+                    }
+                }
+            }
+            out
+        };
+        let removal = |line: u32, character: u32| {
+            serde_json::json!({"range": {"start": {"line": line, "character": character},
+                                         "end": {"line": line, "character": character + 1}},
+                               "newText": ""})
+        };
+
+        let found = fixes(
+            "part def P {\n    attribute mass;\n    assert constraint {\n        mass <= 2;\n    }\n}\n",
+        );
+        assert_eq!(
+            found,
+            vec![(
+                sysmlv2_parser::parser::RESULT_EXPRESSION_TERMINATOR.to_string(),
+                removal(3, 17)
+            )]
+        );
+        for (text, line, character) in [
+            (
+                "package P {\n    part def A;;\n    part def B;\n}\n",
+                1u32,
+                15u32,
+            ),
+            ("package P {\n    part def A {\n    };\n}\n", 2, 5),
+            ("package P {\n    part def A; /* note */ ;\n}\n", 1, 27),
+        ] {
+            let found = fixes(text);
+            assert_eq!(found.len(), 1, "{text:?}: {found:?}");
+            assert_eq!(found[0].1, removal(line, character), "{text:?}");
+        }
+        // An error expecting something else at the `;` leaves it: the
+        // statement ends there, and what is missing comes before it.
+        for text in [
+            "package P {\n    part p : ;\n}\n",
+            "package P {\n    calc def f { in g; g }\n    attribute a = f({ in x; x };\n}\n",
+            "package P {\n    attribute xs : ScalarValues::Real[*];\n    attribute a = (xs->select { in x; x > 0 };\n}\n",
+        ] {
+            let found = fixes(text);
+            assert!(found.is_empty(), "{text:?}: {found:?}");
+        }
+    }
+
+    /// Completion and signature help cut the same statement out of the
+    /// model they read, so alternating between them at one position
+    /// builds one session — an expression's body passed as an argument
+    /// ahead of the cursor included (`Twice({ in z; z }, v.|`), which
+    /// leaves the statement around it whole for completion too.
+    #[test]
+    fn completion_and_signature_help_share_one_session() {
+        let text = "package P {\n    calc def Twice { in f; in x; }\n    \
+                    part def V { attribute w; }\n    part def U {\n        part v : V;\n        \
+                    attribute a = Twice({ in z; z }, v.\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/p.sysml";
+        put(&mut s, uri, 1, text);
+        // After `v.`.
+        let at = serde_json::json!({"line": 5, "character": 43});
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        for id in 0..2 {
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 10 + id, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": uri}, "position": at}}),
+            );
+            let items = out[0]["result"].as_array().cloned().unwrap_or_default();
+            assert!(items.iter().any(|i| i["label"] == "w"), "{}", out[0]);
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 20 + id, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": uri}, "position": at}}),
+            );
+            let help = &out[0]["result"];
+            assert_eq!(help["signatures"][0]["label"], "Twice(f, x)", "{help}");
+            assert_eq!(help["activeParameter"], 1, "{help}");
+        }
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 1);
+    }
+
+    /// In an invocation's argument list the server answers with the
+    /// invoked callable's signature — the hover card's line — and the
+    /// parameter the argument being typed binds, by position or by
+    /// name; parameters are label offsets for a client that takes them.
+    /// Outside an argument list, or for a name that calls nothing,
+    /// there is no answer.
+    #[test]
+    fn signature_help_names_the_parameter_being_typed() {
+        const MODEL: &str = "package P {\n\
+                             \x20   attribute def Mass;\n\
+                             \x20   attribute def Speed;\n\
+                             \x20   attribute def Energy;\n\
+                             \x20   calc def KineticEnergy {\n\
+                             \x20       doc /* The energy of a moving mass. */\n\
+                             \x20       in m : Mass;\n\
+                             \x20       in v : Speed;\n\
+                             \x20       return : Energy;\n\
+                             \x20   }\n\
+                             \x20   constraint def Positive { in x : Mass; }\n\
+                             \x20   part def V {\n\
+                             \x20       LINE\n\
+                             \x20   }\n\
+                             }\n";
+        let help = |caps: &serde_json::Value, line: &str| -> serde_json::Value {
+            let mut s = two_package_server_with_caps(caps);
+            let character = u32::try_from(line.find('|').expect("cursor") + 8).unwrap();
+            let text = MODEL.replace("LINE", &line.replace('|', ""));
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 12, "character": character}}}),
+            );
+            out[0]["result"].clone()
+        };
+        let plain = serde_json::json!({"general": {"positionEncodings": ["utf-8"]}});
+        let offsets = serde_json::json!({
+            "general": {"positionEncodings": ["utf-8"]},
+            "textDocument": {"signatureHelp": {"signatureInformation": {
+                "parameterInformation": {"labelOffsetSupport": true}}}}});
+
+        let h = help(&plain, "attribute e = KineticEnergy(m, |");
+        let sig = &h["signatures"][0];
+        assert_eq!(sig["label"], "KineticEnergy(m: Mass, v: Speed) → Energy");
+        assert_eq!(
+            sig["parameters"],
+            serde_json::json!([{"label": "m: Mass"}, {"label": "v: Speed"}])
+        );
+        assert_eq!(
+            sig["documentation"]["value"],
+            "The energy of a moving mass."
+        );
+        assert_eq!(h["activeParameter"], 1);
+        let h = help(&offsets, "attribute e = KineticEnergy(|");
+        assert_eq!(
+            h["signatures"][0]["parameters"],
+            serde_json::json!([{"label": [14, 21]}, {"label": [23, 31]}])
+        );
+        assert_eq!(h["activeParameter"], 0);
+        let h = help(&plain, "attribute e = KineticEnergy(v = 2, m = |");
+        assert_eq!(h["activeParameter"], 0, "{h}");
+        // A body closing on the cursor's line stays in the model.
+        let h = help(&plain, "assert constraint { Positive(|) }");
+        assert_eq!(h["signatures"][0]["label"], "Positive(x: Mass)", "{h}");
+        // A usage declaring no parameters of its own calls with its
+        // definition's, under its own name.
+        let h = help(&plain, "calc ke : KineticEnergy; attribute e = ke(m, |");
+        assert_eq!(
+            h["signatures"][0]["label"], "ke(m: Mass, v: Speed) → Energy",
+            "{h}"
+        );
+        assert_eq!(h["activeParameter"], 1);
+        // Documented nowhere itself, it reads its definition's.
+        assert_eq!(
+            h["signatures"][0]["documentation"]["value"],
+            "The energy of a moving mass."
+        );
+        // A declared multiplicity other than one follows the type, as a
+        // library callable's does.
+        let h = help(
+            &plain,
+            "calc def Many { in xs : Mass[0..*]; in one : Mass[1]; } attribute e = Many(|",
+        );
+        assert_eq!(
+            h["signatures"][0]["label"], "Many(xs: Mass[0..*], one: Mass)",
+            "{h}"
+        );
+        // Parameters inherited follow the callable's own — a definition
+        // specializing another, a usage typed by one — each redefined
+        // one replaced by what redefines it, by name, explicitly, or by
+        // position; the result is the closest declaration's.
+        for (line, label) in [
+            (
+                "calc def KE2 :> KineticEnergy; attribute e = KE2(m, |",
+                "KE2(m: Mass, v: Speed) → Energy",
+            ),
+            (
+                "calc def KE2 :> KineticEnergy; calc ke2 : KE2; attribute e = ke2(m, |",
+                "ke2(m: Mass, v: Speed) → Energy",
+            ),
+            (
+                "attribute def Heavy :> Mass; \
+                 calc def KE3 :> KineticEnergy { in m : Heavy; } attribute e = KE3(m, |",
+                "KE3(m: Heavy, v: Speed) → Energy",
+            ),
+            (
+                "attribute def Heavy :> Mass; \
+                 calc def KE4 :> KineticEnergy { in :>> m : Heavy; } attribute e = KE4(m, |",
+                "KE4(m: Heavy, v: Speed) → Energy",
+            ),
+            (
+                "attribute def Heavy :> Mass; \
+                 calc def KE5 :> KineticEnergy { in mass : Heavy; } attribute e = KE5(m, |",
+                "KE5(mass: Heavy, v: Speed) → Energy",
+            ),
+            (
+                "attribute def Joules :> Energy; \
+                 calc def KE7 :> KineticEnergy { return : Joules; } attribute e = KE7(m, |",
+                "KE7(m: Mass, v: Speed) → Joules",
+            ),
+            // Redefining only, it reads with the type it redefines; unnamed
+            // in an inherited parameter's place, with that one's name.
+            (
+                "calc def KE8 :> KineticEnergy { in :>> m; } attribute e = KE8(m, |",
+                "KE8(m: Mass, v: Speed) → Energy",
+            ),
+            (
+                "attribute def Heavy :> Mass; \
+                 calc def KE9 :> KineticEnergy { in : Heavy; } attribute e = KE9(m, |",
+                "KE9(m: Heavy, v: Speed) → Energy",
+            ),
+        ] {
+            let h = help(&plain, line);
+            assert_eq!(h["signatures"][0]["label"], label, "{line:?}: {h}");
+            assert_eq!(h["activeParameter"], 1, "{line:?}");
+        }
+        // The parameters an evaluation binds. An own parameter takes over
+        // the general's at its place even when it redefines another one
+        // explicitly, so `KE6` has one parameter that both of
+        // `KineticEnergy`'s stand for; and a place pairs with the general's
+        // parameters, its own then the inherited ones after them, so `b`
+        // takes over the `v` that `KE3` inherits.
+        for (line, label) in [
+            (
+                "calc def KE6 :> KineticEnergy { in :>> v; } attribute e = KE6(|",
+                "KE6(v: Speed) → Energy",
+            ),
+            (
+                "attribute def Heavy :> Mass; \
+                 calc def KE3 :> KineticEnergy { in m : Heavy; } \
+                 calc def KE10 :> KE3 { in a : Heavy; in b : Speed; } attribute e = KE10(|",
+                "KE10(a: Heavy, b: Speed) → Energy",
+            ),
+        ] {
+            let h = help(&plain, line);
+            assert_eq!(h["signatures"][0]["label"], label, "{line:?}: {h}");
+            assert_eq!(h["activeParameter"], 0, "{line:?}");
+        }
+        // Arguments bind the inputs, in order: an output declared among
+        // them holds no argument's place.
+        let h = help(
+            &plain,
+            "calc def Mixed { out o : Energy; in m : Mass; in v : Speed; } attribute e = Mixed(m, |",
+        );
+        assert_eq!(
+            h["signatures"][0]["label"], "Mixed(out o: Energy, m: Mass, v: Speed)",
+            "{h}"
+        );
+        assert_eq!(h["activeParameter"], 2, "{h}");
+        let h = help(
+            &plain,
+            "calc def Mixed { out o : Energy; in m : Mass; in v : Speed; } attribute e = Mixed(o = |",
+        );
+        assert_eq!(h["activeParameter"], 3, "{h}");
+        // An inherited parameter named.
+        let h = help(
+            &plain,
+            "calc def KE2 :> KineticEnergy; attribute e = KE2(v = |",
+        );
+        assert_eq!(h["activeParameter"], 1, "{h}");
+        // Documented nowhere itself, a definition reads the one it
+        // specializes.
+        assert_eq!(
+            h["signatures"][0]["documentation"]["value"],
+            "The energy of a moving mass."
+        );
+        // An unnamed usage redefining one, reached on a chain, is called
+        // by the name it redefines.
+        let h = help(
+            &plain,
+            "part def Holder { calc ke : KineticEnergy; } part h2 : Holder { calc :>> ke; } \
+             attribute e = h2.ke(m, |",
+        );
+        assert_eq!(
+            h["signatures"][0]["label"], "ke(m: Mass, v: Speed) → Energy",
+            "{h}"
+        );
+        // A feature chain's step: a member of what its receiver reaches.
+        let h = help(
+            &plain,
+            "part w { calc ke : KineticEnergy; } attribute e = w.ke(m, |",
+        );
+        assert_eq!(
+            h["signatures"][0]["label"], "ke(m: Mass, v: Speed) → Energy",
+            "{h}"
+        );
+        assert_eq!(h["activeParameter"], 1);
+        // After a body expression passed as an argument, and past a
+        // string holding a statement's punctuation.
+        for line in [
+            "attribute e = KineticEnergy({ in z; z }, |",
+            "attribute e = KineticEnergy(\"a;b}\", |",
+        ] {
+            let h = help(&plain, line);
+            assert_eq!(
+                h["signatures"][0]["label"], "KineticEnergy(m: Mass, v: Speed) → Energy",
+                "{line:?}: {h}"
+            );
+            assert_eq!(h["activeParameter"], 1, "{line:?}");
+        }
+
+        for line in [
+            "attribute e = KineticEnergy(m, v)|",
+            "attribute e = Mass(|",
+            "attribute e = Unknown(|",
+        ] {
+            assert!(help(&plain, line).is_null(), "{line:?}");
+        }
+
+        // KerML: a function invoked in a feature value.
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/k.kerml", "languageId": "kerml", "version": 1,
+                                 "text": "package K {\n    classifier Num;\n    function Twice { in x : Num; return : Num; }\n    feature y = Twice(\n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/signatureHelp",
+                "params": {"textDocument": {"uri": "file:///w/k.kerml"},
+                           "position": {"line": 3, "character": 22}}}),
+        );
+        assert_eq!(
+            out[0]["result"]["signatures"][0]["label"],
+            "Twice(x: Num) → Num"
+        );
+        // A function specializing another: its general's parameters,
+        // one of its own taking the place of the general's at its
+        // position.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/s.kerml", "languageId": "kerml", "version": 1,
+                                 "text": "package S {\n    classifier Num;\n    function Twice { in x : Num; return : Num; }\n    function Again specializes Twice;\n    function Other specializes Twice { in y : Num; }\n    feature a = Again(\n    feature b = Other(\n}\n"}}}),
+        );
+        for (line, label) in [(5, "Again(x: Num) → Num"), (6, "Other(y: Num) → Num")] {
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 4, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": "file:///w/s.kerml"},
+                               "position": {"line": line, "character": 22}}}),
+            );
+            assert_eq!(out[0]["result"]["signatures"][0]["label"], label);
+        }
+        // A feature typed by a function, reached on a chain.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/c.kerml", "languageId": "kerml", "version": 1,
+                                 "text": "package C {\n    classifier Num;\n    function Twice { in x : Num; return : Num; }\n    classifier Holder { feature double : Twice; }\n    feature h : Holder;\n    feature y = h.double(\n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/signatureHelp",
+                "params": {"textDocument": {"uri": "file:///w/c.kerml"},
+                           "position": {"line": 5, "character": 25}}}),
+        );
+        assert_eq!(
+            out[0]["result"]["signatures"][0]["label"],
+            "double(x: Num) → Num"
+        );
+
+        let caps = crate::capabilities(crate::Encoding::Utf8);
+        let triggers = caps
+            .signature_help_provider
+            .and_then(|o| o.trigger_characters)
+            .unwrap_or_default();
+        assert_eq!(triggers, ["(", ","]);
+    }
+
+    fn two_package_server() -> PushServer {
+        two_package_server_with_caps(&serde_json::json!(
+            {"general": {"positionEncodings": ["utf-8"]}}))
+    }
+
+    fn two_package_server_with_caps(capabilities: &serde_json::Value) -> PushServer {
+        let mut s = PushServer::with_library_sources(
             vec![(
                 "MiniLib.kerml".to_string(),
                 "standard library package MiniLib { class Widget; class Gadget; \
-                 feature <'m/s²'> 'metre per second squared'; } \
-                 standard library package OtherLib { class Bolt; }"
+                 feature <'m/s²'> 'metre per second squared' \
+                 : MeasurementReferences::TensorMeasurementReference; } \
+                 standard library package OtherLib { class Bolt; } \
+                 standard library package MeasurementReferences { \
+                 datatype TensorMeasurementReference; }"
                     .to_string(),
             )],
             None,
@@ -1117,6 +2662,17 @@ mod tests {
         items.iter().filter_map(|i| i["label"].as_str()).collect()
     }
 
+    /// The items of a completion response: an array, or the items of a
+    /// list sent incomplete for the client to ask again as the user
+    /// types.
+    fn completion_items(result: &serde_json::Value) -> Vec<serde_json::Value> {
+        result
+            .as_array()
+            .or_else(|| result["items"].as_array())
+            .expect("completion items")
+            .clone()
+    }
+
     /// After `Foo::`, only the members of `Foo` are offered — no
     /// keywords, no other packages, no workspace names (import and
     /// non-import sites alike).
@@ -1187,6 +2743,139 @@ mod tests {
         assert_eq!(edit["range"]["end"]["character"], 31);
     }
 
+    /// After a qualifier in an import or expose path the wildcards come
+    /// with the members: `*` for the members, `**` for everything below
+    /// them, inserted as typed rather than quoted as names. A qualifier
+    /// in a reference offers none.
+    #[test]
+    fn import_paths_offer_wildcards() {
+        for (text, character, offered) in [
+            (
+                "package P {\n    private import MiniLib::\n}\n",
+                28u32,
+                true,
+            ),
+            ("package P {\n    view v { expose MiniLib::\n}\n", 29, true),
+            ("package P {\n    part w : MiniLib::\n}\n", 22, false),
+        ] {
+            let mut s = two_package_server();
+            let items = completion_in_m(&mut s, text, 1, character);
+            assert!(completion_labels(&items).contains(&"Widget"), "{text:?}");
+            for wildcard in ["*", "**"] {
+                let item = items.iter().find(|i| i["label"] == wildcard);
+                assert_eq!(item.is_some(), offered, "{text:?}: `{wildcard}`");
+                if let Some(item) = item {
+                    assert_eq!(item["textEdit"]["newText"], wildcard, "{item}");
+                    assert_eq!(item["textEdit"]["range"]["start"]["character"], character);
+                    assert_ne!(
+                        item["kind"],
+                        serde_json::json!(lsp_types::CompletionItemKind::KEYWORD)
+                    );
+                }
+            }
+        }
+    }
+
+    /// An import path usually names a package: packages sort ahead of
+    /// the members the same word matches, so `Vehi` focuses
+    /// `VehicleModel`, not its `Vehicle`. A workspace package is not
+    /// annotated as standard library.
+    #[test]
+    fn import_paths_rank_packages_first() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package VehicleModel {\n    part def Vehicle;\n    \
+                                          package VehicleStates;\n    part vehicle1 : Vehicle;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    private import Vehi\n}\n", 1, 23);
+        let item = |label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"))
+        };
+        let sort = |label: &str| item(label)["sortText"].as_str().map(str::to_lowercase);
+        for package in ["VehicleModel", "VehicleStates"] {
+            for member in ["Vehicle", "vehicle1"] {
+                assert!(
+                    sort(package).is_some() && sort(package) < sort(member),
+                    "{package} before {member}: {:?} {:?}",
+                    sort(package),
+                    sort(member)
+                );
+            }
+        }
+        assert_ne!(item("VehicleModel")["detail"], "standard library");
+        assert_eq!(item("MiniLib")["detail"], "standard library");
+    }
+
+    /// The wildcards come with an import or expose statement's keyword,
+    /// not with the word in a comment or string of another statement.
+    #[test]
+    fn wildcards_need_an_import_or_expose_keyword() {
+        for (text, character) in [
+            (
+                "package P {\n    part w : /* expose */ MiniLib::\n}\n",
+                36u32,
+            ),
+            ("package P {\n    part w : /* import */ MiniLib::\n}\n", 36),
+            (
+                "package P {\n    part w : // import\n        MiniLib::\n}\n",
+                17,
+            ),
+        ] {
+            let line = u32::try_from(
+                text.lines()
+                    .position(|l| l.contains("MiniLib::"))
+                    .expect("line"),
+            )
+            .expect("line");
+            let mut s = two_package_server();
+            let items = completion_in_m(&mut s, text, line, character);
+            let labels = completion_labels(&items);
+            assert!(labels.contains(&"Widget"), "{text:?}: {labels:?}");
+            assert!(!labels.contains(&"*"), "{text:?}: {labels:?}");
+        }
+    }
+
+    /// An import path offers what a package owns — packages and their
+    /// members — never a feature of a definition, such as a
+    /// requirement's subject: importing it by path is no way to reach
+    /// it.
+    #[test]
+    fn import_completion_offers_only_package_members() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Model {\n    part def Vehicle { part engine; }\n    \
+                                          requirement def MassReq { subject vehicle : Vehicle; }\n    \
+                                          part vehicle1 : Vehicle;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    private import veh\n}\n", 1, 22);
+        let inserted: Vec<&str> = items
+            .iter()
+            .filter_map(|i| i["textEdit"]["newText"].as_str())
+            .filter(|t| t.starts_with("Model::"))
+            .collect();
+        assert!(
+            inserted.contains(&"Model::Vehicle") && inserted.contains(&"Model::vehicle1"),
+            "{inserted:?}"
+        );
+        for feature in ["Model::MassReq::vehicle", "Model::Vehicle::engine"] {
+            assert!(
+                !inserted.contains(&feature),
+                "`{feature}` offered: {inserted:?}"
+            );
+        }
+    }
+
     /// Host-seeded workspace sources feed navigation: definition on an
     /// import-introduced name jumps into a unit that was seeded but
     /// never opened (the filesystem-less host's cross-file shape), and
@@ -1230,6 +2919,169 @@ mod tests {
         assert_eq!(definition(&mut s, 3), serde_json::Value::Null);
     }
 
+    /// A prepared library answers exactly as the sources it was prepared
+    /// from: completions, hover and a definition inside a library unit.
+    #[test]
+    fn prepared_library_answers_like_its_sources() {
+        let units = || {
+            vec![(
+                "Mini Lib/MiniLib.sysml".to_string(),
+                "package MiniLib {\n    part def Widget;\n    part def Gadget;\n}\n".to_string(),
+            )]
+        };
+        let answers = |mut s: PushServer| {
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                    "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+            );
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                     "version": 1,
+                                     "text": "package P {\n    private import MiniLib::*;\n    part w : Widget;\n    part def X;\n}\n"}}}),
+            );
+            // Completion in the typing's position, where the library's
+            // definitions are offered.
+            [
+                ("textDocument/completion", 2, 13),
+                ("textDocument/hover", 2, 14),
+                ("textDocument/definition", 2, 14),
+            ]
+            .into_iter()
+            .map(|(method, line, character)| {
+                responses(
+                    &mut s,
+                    &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": method,
+                        "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                                   "position": {"line": line, "character": character}}}),
+                )
+            })
+            .collect::<Vec<_>>()
+        };
+        let prepared = sysmlv2_transform::Library::prepared_sources(units(), None).unwrap();
+        let expected = answers(PushServer::with_library_sources(units(), None));
+        assert_eq!(answers(PushServer::with_library(prepared)), expected);
+        assert_eq!(
+            expected[2][0]["result"]["uri"], "sysmlv2-lib:/Mini%20Lib/MiniLib.sysml",
+            "{expected:?}"
+        );
+        let items = expected[0][0]["result"]
+            .as_array()
+            .expect("completion items");
+        assert!(items.iter().any(|i| i["label"] == "Gadget"), "{items:?}");
+    }
+
+    /// Hover, go-to-definition and document highlights answer while a
+    /// unit does not parse — a member the parser cannot read elsewhere
+    /// in the document, another document ending mid-declaration — off a
+    /// session the broken units join salvaged, at the positions the
+    /// documents hold (a `;` written over a line break shifts none).
+    /// References, which a blanked member would leave short, answer
+    /// nothing until everything parses. The session is built once for
+    /// the documents as they stand.
+    #[test]
+    fn read_only_navigation_survives_syntax_errors() {
+        let text = "package P {\n    private import B::*;\n    part def Vehicle { attribute mass; }\n    \
+                    part z { attribute = ; }\n    part vehicle1 : Vehicle;\n    part y : Y;\n}\n";
+        let other = "package B {\npart def X\npart def Y;\npart def W :> ;\n}\n";
+        let mut s = two_package_server();
+        for (uri, body) in [("file:///w/m.sysml", text), ("file:///w/b.sysml", other)] {
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": uri, "languageId": "sysml", "version": 1,
+                                     "text": body}}}),
+            );
+        }
+        let at = |line: u32, character: u32| {
+            serde_json::json!({"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": line, "character": character}})
+        };
+        let ask = |s: &mut PushServer, id: i32, method: &str, params: serde_json::Value| {
+            let mut params = params;
+            if method == "textDocument/references" {
+                params["context"] = serde_json::json!({"includeDeclaration": true});
+            }
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params}),
+            )[0]["result"]
+                .clone()
+        };
+        let hover = ask(&mut s, 2, "textDocument/hover", at(4, 22));
+        assert!(
+            hover["contents"]["value"]
+                .as_str()
+                .is_some_and(|v| v.contains("P::Vehicle")),
+            "{hover}"
+        );
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        let definition = ask(&mut s, 3, "textDocument/definition", at(4, 22));
+        assert_eq!(definition["uri"], "file:///w/m.sysml", "{definition}");
+        assert_eq!(definition["range"]["start"]["line"], 2, "{definition}");
+        assert_eq!(
+            definition["range"]["start"]["character"], 13,
+            "{definition}"
+        );
+        // Into the other document, below a declaration missing its `;`.
+        let definition = ask(&mut s, 4, "textDocument/definition", at(5, 13));
+        assert_eq!(definition["uri"], "file:///w/b.sysml", "{definition}");
+        assert_eq!(definition["range"]["start"]["line"], 2, "{definition}");
+        assert_eq!(definition["range"]["start"]["character"], 9, "{definition}");
+        let highlights = ask(&mut s, 5, "textDocument/documentHighlight", at(2, 15));
+        let lines: Vec<u64> = highlights
+            .as_array()
+            .map(|h| {
+                h.iter()
+                    .filter_map(|h| h["range"]["start"]["line"].as_u64())
+                    .collect()
+            })
+            .unwrap_or_default();
+        assert_eq!(lines, [2, 4], "{highlights}");
+        assert_eq!(
+            ask(&mut s, 6, "textDocument/references", at(2, 15)),
+            serde_json::Value::Null
+        );
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+    }
+
+    /// A document that stops parsing leaves the strict session stale,
+    /// answering nothing for the new versions: building the tolerant one
+    /// lets it go, so no more than two models are held at once.
+    #[test]
+    fn a_stale_strict_session_is_let_go_for_the_tolerant_one() {
+        let valid = "package P {\n    part def Vehicle;\n    part v : Vehicle;\n}\n";
+        let broken = "package P {\n    part def Vehicle;\n    part v : Vehicle;\n    part z { attribute = ; }\n}\n";
+        let mut s = two_package_server();
+        let hover = |s: &mut PushServer, id: i32| {
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": id, "method": "textDocument/hover",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 2, "character": 14}}}),
+            )[0]["result"]
+                .clone()
+        };
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1, "text": valid}}}),
+        );
+        assert!(!hover(&mut s, 2).is_null());
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "version": 2},
+                "contentChanges": [{"text": broken}]}}),
+        );
+        assert!(!hover(&mut s, 3).is_null());
+        let held = s.server.as_ref().expect("initialized").nav.sessions_held();
+        assert_eq!(held, 1, "the tolerant session alone");
+    }
+
     /// Definition on a library-typed reference lands inside the library
     /// unit, addressed by the `sysmlv2-lib:/` scheme (the host serves
     /// that text as a read-only virtual document). Unit names keep their
@@ -1270,9 +3122,9 @@ mod tests {
         assert_eq!(loc["range"]["start"]["character"], 13, "{loc:?}");
     }
 
-    /// The half-typed import parses as a declaration of the typed word
-    /// itself; that phantom symbol must not be offered back (it would
-    /// outrank the real target with a self-referential path).
+    /// The half-typed import is an outline node named by the typed word
+    /// itself; it must not be offered back (it would outrank the real
+    /// target with a self-referential path).
     #[test]
     fn import_completion_omits_the_phantom_self_symbol() {
         let mut s = two_package_server();
@@ -1300,6 +3152,5654 @@ mod tests {
         );
     }
 
+    /// An import missing its `;` runs into the next statement, which
+    /// makes that statement an import context. When the statement
+    /// declares the word being typed — a keyword whose next word may be
+    /// a new name keeps completion on (`flow Widg`) — that declaration
+    /// must not be offered back as an import (`P::Widg`), and a
+    /// declared name after a declaring keyword gets no names at all.
+    #[test]
+    fn import_context_omits_the_declaration_being_typed() {
+        for marked in [
+            "package P {\n    private import MiniLib::*\n    flow Widg|\n}\n",
+            "package P {\n    private import MiniLib::*\n    succession flow Widg|\n}\n",
+            "package P {\n    private import MiniLib::*\n    message Widg|\n}\n",
+        ] {
+            let items = complete_in("file:///w/m.sysml", marked);
+            assert!(
+                items
+                    .iter()
+                    .any(|i| i["textEdit"]["newText"] == "MiniLib::Widget"),
+                "import context: {items:?}"
+            );
+            let phantom: Vec<&serde_json::Value> = items
+                .iter()
+                .filter(|i| i["textEdit"]["newText"].as_str() == Some("P::Widg"))
+                .collect();
+            assert!(phantom.is_empty(), "phantom offered: {phantom:?}");
+        }
+        let items = complete_in(
+            "file:///w/m.sysml",
+            "package P {\n    private import MiniLib::*\n    part def Widg|;\n}\n",
+        );
+        assert!(items.is_empty(), "a declared name: {items:?}");
+    }
+
+    /// An import missing its `;` runs into a bare word on the next line,
+    /// which the parse declares: the import path list must not offer
+    /// that word back as `P::Widg`.
+    #[test]
+    fn import_context_omits_a_bare_word_the_parse_declares() {
+        let items = complete_at("package P {\n    private import MiniLib::*\n    Widg|;\n}\n");
+        assert!(
+            items
+                .iter()
+                .any(|i| i["textEdit"]["newText"] == "MiniLib::Widget"),
+            "import context: {items:?}"
+        );
+        assert!(
+            items
+                .iter()
+                .all(|i| i["textEdit"]["newText"].as_str() != Some("P::Widg")),
+            "phantom offered: {items:?}"
+        );
+    }
+
+    /// A server over one in-memory library unit, initialized for
+    /// utf-8 positions.
+    fn library_server(library: &str) -> PushServer {
+        let mut s = PushServer::with_library_sources(
+            vec![("Lib.kerml".to_string(), library.to_string())],
+            None,
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+        );
+        s
+    }
+
+    /// Open (or replace) `file:///w/m.sysml` with `text` and complete
+    /// at `line`/`character`.
+    fn completion_in_m(
+        s: &mut PushServer,
+        text: &str,
+        line: u32,
+        character: u32,
+    ) -> Vec<serde_json::Value> {
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1, "text": text}}}),
+        );
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "position": {"line": line, "character": character}}}),
+        );
+        out[0]["result"]
+            .as_array()
+            .expect("completion items")
+            .clone()
+    }
+
+    /// `import` and `expose` members declare nothing: neither the
+    /// library's nor the workspace's own become completion symbols —
+    /// not by simple name, not as members of their owner, not in an
+    /// import path — while an alias stays a member and the outline
+    /// still lists every import.
+    #[test]
+    fn import_members_are_not_completion_symbols() {
+        let mut s = library_server(
+            "standard library package Parts { class Bolt; } \
+             standard library package Kit { private import Parts::Bolt; \
+             public import Parts::*; alias Fastener for Parts::Bolt; class Crate; }",
+        );
+
+        // Unqualified: the library's `Parts::Bolt` import is no name,
+        // and the workspace's own `import Kit::*` and `expose Parts::*`
+        // do not shadow the library packages they name.
+        let text = "package P {\n    private import Kit::*;\n    view v { expose Parts::*; }\n    ref b : \n}\n";
+        let items = completion_in_m(&mut s, text, 3, 12);
+        let labels = completion_labels(&items);
+        let paths: Vec<&str> = labels
+            .iter()
+            .copied()
+            .filter(|l| l.contains("::"))
+            .collect();
+        assert!(paths.is_empty(), "import paths offered as names: {paths:?}");
+        for package in ["Kit", "Parts"] {
+            let item = items
+                .iter()
+                .find(|i| i["label"] == package)
+                .unwrap_or_else(|| panic!("{package} offered"));
+            assert_eq!(item["detail"], "standard library", "{item}");
+            assert!(item.get("additionalTextEdits").is_none(), "{item}");
+        }
+        let alias = items
+            .iter()
+            .find(|i| i["label"] == "Fastener")
+            .expect("alias offered");
+        assert_eq!(alias["detail"], "Kit::Fastener");
+
+        // Qualified: an import is not a member of its owner.
+        let text = "package P {\n    private import Kit::*;\n    part b : Kit::\n}\n";
+        let items = completion_in_m(&mut s, text, 2, 18);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Crate") && labels.contains(&"Fastener"),
+            "{labels:?}"
+        );
+        assert!(
+            !labels.iter().any(|l| l.starts_with("Parts")),
+            "imports listed as members: {labels:?}"
+        );
+
+        // Import path: one `Kit`, the package itself.
+        let text = "package P {\n    private import Kit::*;\n    private import Ki\n}\n";
+        let items = completion_in_m(&mut s, text, 2, 21);
+        let inserted: Vec<&str> = items
+            .iter()
+            .filter(|i| i["label"] == "Kit")
+            .filter_map(|i| i["textEdit"]["newText"].as_str())
+            .collect();
+        assert_eq!(inserted, ["Kit"]);
+        assert!(
+            !items.iter().any(|i| i["textEdit"]["newText"]
+                .as_str()
+                .is_some_and(|t| t.starts_with("Kit::Parts"))),
+            "an import's target offered under its owner"
+        );
+
+        // The outline is unchanged: it lists the imports.
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/documentSymbol",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"}}}),
+        );
+        let children = out[0]["result"][0]["children"]
+            .as_array()
+            .expect("package members");
+        assert!(
+            children.iter().any(|c| c["name"] == "Kit"
+                && c["kind"] == serde_json::json!(lsp_types::SymbolKind::MODULE)),
+            "{children:?}"
+        );
+    }
+
+    /// After a qualifier, a namespace offers what it makes visible: its
+    /// own members, then what its public imports bring in — a whole
+    /// namespace (`::*`), one member, a namespace recursively (`::**`),
+    /// and, transitively, what the imported namespaces re-export —
+    /// once per name, an owned member hiding an imported one. Private
+    /// imports re-export nothing; no visibility keyword is public.
+    #[test]
+    fn qualifier_offers_what_public_imports_bring_in() {
+        let mut s = library_server(
+            "standard library package Base { class Widget; class Gadget; } \
+             standard library package More { class Bolt; } \
+             standard library package Hidden { class Secret; } \
+             standard library package Solo { class Nut; class Washer; } \
+             standard library package Deep { package Inner { class Pin; } } \
+             standard library package Facade { public import Base::*; import More::*; \
+             private import Hidden::*; public import Solo::Nut; public import Deep::**; \
+             class Own; class Gadget; } \
+             standard library package Outer { public import Facade::*; }",
+        );
+        // The members offered (an import path also offers wildcards).
+        let offered = |items: &[serde_json::Value]| -> Vec<(String, String)> {
+            items
+                .iter()
+                .filter(|i| i["label"] != "*" && i["label"] != "**")
+                .map(|i| {
+                    let text = |v: &serde_json::Value| v.as_str().unwrap_or_default().to_string();
+                    (text(&i["label"]), text(&i["detail"]))
+                })
+                .collect()
+        };
+        let expected = [
+            ("Own", "Facade::Own"),
+            ("Gadget", "Facade::Gadget"),
+            ("Widget", "Base::Widget"),
+            ("Bolt", "More::Bolt"),
+            ("Nut", "Solo::Nut"),
+            ("Deep", "Deep"),
+            ("Inner", "Deep::Inner"),
+            ("Pin", "Deep::Inner::Pin"),
+        ]
+        .map(|(l, d)| (l.to_string(), d.to_string()));
+        // Right after each qualifier, on line 1.
+        for (text, character) in [
+            ("package P {\n    part w : Facade::\n}\n", 21u32),
+            ("package P {\n    private import Facade::\n}\n", 27),
+        ] {
+            let items = completion_in_m(&mut s, text, 1, character);
+            assert_eq!(offered(&items), expected, "{text:?}");
+        }
+        // Transitively: `Outer` re-exports what `Facade` makes visible.
+        let items = completion_in_m(&mut s, "package P {\n    part w : Outer::\n}\n", 1, 20);
+        let labels = completion_labels(&items);
+        for name in ["Own", "Widget", "Bolt", "Nut", "Pin"] {
+            assert!(labels.contains(&name), "`{name}` missing: {labels:?}");
+        }
+        assert!(!labels.contains(&"Secret") && !labels.contains(&"Washer"));
+    }
+
+    /// An existing namespace import admits what the imported namespace
+    /// re-exports: after `import Facade::*;` a member `Facade`
+    /// re-exports from `Base` needs no import of its own — transitively
+    /// too, and through a workspace package an import names relative
+    /// to its own — while a private import re-exports nothing. The
+    /// "Add import" fix holds to the same check.
+    #[test]
+    fn import_admission_follows_reexports() {
+        let library = "standard library package Base { class Widget; } \
+                       standard library package Facade { public import Base::*; } \
+                       standard library package Outer { public import Facade::*; } \
+                       standard library package Sealed { private import Base::*; }";
+        for (text, line, character, admitted) in [
+            (
+                "package P {\n    private import Facade::*;\n    ref w : \n}\n",
+                2u32,
+                12u32,
+                true,
+            ),
+            (
+                "package P {\n    private import Outer::*;\n    ref w : \n}\n",
+                2,
+                12,
+                true,
+            ),
+            (
+                "package P {\n    private import Sealed::*;\n    ref w : \n}\n",
+                2,
+                12,
+                false,
+            ),
+            (
+                "package P {\n    package Kit { public import Base::*; }\n    package Use {\n        \
+                 private import Kit::*;\n        ref w : \n    }\n}\n",
+                4,
+                16,
+                true,
+            ),
+        ] {
+            let mut s = library_server(library);
+            let items = completion_in_m(&mut s, text, line, character);
+            let widget = items
+                .iter()
+                .find(|i| i["label"] == "Widget")
+                .expect("Widget offered");
+            assert_eq!(
+                widget.get("additionalTextEdits").is_none(),
+                admitted,
+                "{text:?}: {widget}"
+            );
+
+            // The quick fix on an unresolved `Widget` at the same spot.
+            let fixed = text.replacen("ref w : \n", "ref w : Widget;\n", 1);
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "version": 2},
+                    "contentChanges": [{"text": fixed}]}}),
+            );
+            let range = serde_json::json!({"start": {"line": line, "character": character},
+                                           "end": {"line": line, "character": character + 6}});
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/codeAction",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "range": range,
+                               "context": {"diagnostics": [
+                                   {"range": range, "message": "unresolved reference `Widget`"}]}}}),
+            );
+            let fixes = out[0]["result"]
+                .as_array()
+                .expect("actions")
+                .iter()
+                .filter(|a| {
+                    a["title"]
+                        .as_str()
+                        .is_some_and(|t| t.starts_with("Add import"))
+                })
+                .count();
+            assert_eq!(fixes == 0, admitted, "{fixed:?}");
+        }
+    }
+
+    /// An inserted import names the conventional path: through the
+    /// package of the symbol's family when that package re-exports it
+    /// (`Kit::Crate` for `KitParts::Crate`), through a top-level
+    /// package when that is shorter (`Top::Deep` for `Top::Inner::Deep`),
+    /// and the symbol's own path otherwise — also when the family's
+    /// package declares a member of the same name, or the name only
+    /// begins like the package's (`Car` is no family of `Cargo`).
+    /// Completion's auto-import, the "Add import" fix, and import-path
+    /// completion agree.
+    #[test]
+    fn imports_name_the_conventional_path() {
+        let library = "standard library package KitParts { class Crate; } \
+                       standard library package Kit { public import KitParts::*; } \
+                       standard library package Other { public import KitParts::*; } \
+                       standard library package Base { class Widget; } \
+                       standard library package Facade { public import Base::*; } \
+                       standard library package Top { package Inner { class Deep; } \
+                       public import Inner::*; } \
+                       standard library package LotParts { class Box; } \
+                       standard library package Lot { public import LotParts::*; class Box; } \
+                       standard library package Cargo { class Pallet; } \
+                       standard library package Car { public import Cargo::*; }";
+        let mut s = library_server(library);
+
+        // Completion: the auto-import and its `import …` annotation.
+        let items = completion_in_m(&mut s, "package P {\n    ref w : \n}\n", 1, 12);
+        for (label, path) in [
+            ("Crate", "Kit::Crate"),
+            ("Widget", "Base::Widget"),
+            ("Pallet", "Cargo::Pallet"),
+        ] {
+            let item = items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"));
+            assert_eq!(
+                item["additionalTextEdits"][0]["newText"],
+                format!("private import {path};\n    "),
+                "{item}"
+            );
+            let package = path.rsplit_once("::").map(|(p, _)| p).unwrap_or_default();
+            assert_eq!(
+                item["labelDetails"]["description"],
+                format!("import {package}")
+            );
+        }
+        let boxes: Vec<&serde_json::Value> = items.iter().filter(|i| i["label"] == "Box").collect();
+        assert!(
+            boxes
+                .iter()
+                .any(|i| i["additionalTextEdits"][0]["newText"]
+                    == "private import LotParts::Box;\n    "),
+            "{boxes:?}"
+        );
+
+        // The quick fix on an unresolved name.
+        for (name, path) in [("Crate", "Kit::Crate"), ("Deep", "Top::Deep")] {
+            let text = format!("package P {{\n    part w : {name};\n}}\n");
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                    "textDocument": {"uri": "file:///w/m.sysml", "version": 3},
+                    "contentChanges": [{"text": text}]}}),
+            );
+            let range = serde_json::json!({"start": {"line": 1, "character": 13},
+                                           "end": {"line": 1, "character": 13 + name.len()}});
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 4, "method": "textDocument/codeAction",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "range": range,
+                               "context": {"diagnostics": [
+                                   {"range": range,
+                                    "message": format!("unresolved reference `{name}`")}]}}}),
+            );
+            let titles: Vec<&str> = out[0]["result"]
+                .as_array()
+                .expect("actions")
+                .iter()
+                .filter_map(|a| a["title"].as_str())
+                .collect();
+            assert!(
+                titles.contains(&format!("Add import {path}").as_str()),
+                "{titles:?}"
+            );
+        }
+
+        // Import-path completion inserts the same path.
+        for (typed, label, path) in [("Cra", "Crate", "Kit::Crate"), ("Dee", "Deep", "Top::Deep")] {
+            let text = format!("package P {{\n    private import {typed}\n}}\n");
+            // Right after the typed word.
+            let items = completion_in_m(&mut s, &text, 1, 22);
+            let item = items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"));
+            assert_eq!(item["textEdit"]["newText"], path);
+            assert_eq!(item["detail"], path);
+        }
+    }
+
+    /// An inserted import's annotation names its package as the
+    /// statement spells it: a restricted name quoted.
+    #[test]
+    fn an_import_annotation_quotes_restricted_names() {
+        let mut s = library_server("standard library package 'Model Lib' { class Gear; }");
+        let items = completion_in_m(&mut s, "package P {\n    ref w : \n}\n", 1, 12);
+        let gear = items
+            .iter()
+            .find(|i| i["label"] == "Gear")
+            .expect("Gear offered");
+        assert_eq!(
+            gear["additionalTextEdits"][0]["newText"],
+            "private import 'Model Lib'::Gear;\n    "
+        );
+        assert_eq!(gear["labelDetails"]["description"], "import 'Model Lib'");
+    }
+
+    /// The statement being typed declares its names ahead of the cursor:
+    /// none is offered in its own value or specialization.
+    #[test]
+    fn a_statement_does_not_offer_its_own_name() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        for (text, character, own) in [
+            ("package P {\n    attribute zz = \n}\n", 19, "zz"),
+            ("package P {\n    attribute <z> zz = \n}\n", 23, "z"),
+            ("package P {\n    part def Gear :> \n}\n", 21, "Gear"),
+        ] {
+            let items = completion_in_m(&mut s, text, 1, character);
+            let labels = completion_labels(&items);
+            assert!(!labels.contains(&own), "{text:?}: {labels:?}");
+        }
+    }
+
+    /// The "Add import" titles offered for an unresolved bare `name`
+    /// written as `part w : <name>;` inside `package P` after `imports`.
+    fn import_fix_titles(s: &mut PushServer, imports: &str, name: &str) -> Vec<String> {
+        let text = format!("package P {{\n{imports}    part w : {name};\n}}\n");
+        let line = text
+            .lines()
+            .position(|l| l.contains("part w : "))
+            .expect("line");
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 9, "text": text}}}),
+        );
+        let range = serde_json::json!({"start": {"line": line, "character": 13},
+                                       "end": {"line": line, "character": 13 + name.len()}});
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 5, "method": "textDocument/codeAction",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "range": range,
+                           "context": {"diagnostics": [
+                               {"range": range,
+                                "message": format!("unresolved reference `{name}`")}]}}}),
+        );
+        out[0]["result"]
+            .as_array()
+            .expect("actions")
+            .iter()
+            .filter_map(|a| a["title"].as_str())
+            .filter(|t| t.starts_with("Add import"))
+            .map(str::to_string)
+            .collect()
+    }
+
+    /// "Add import" titles for `part w : <name>;` in `package P`, with
+    /// `prefix` at the root of the document ahead of it.
+    fn root_fix_titles(s: &mut PushServer, prefix: &str, name: &str) -> Vec<String> {
+        let text = format!("{prefix}package P {{\n    part w : {name};\n}}\n");
+        let line = text
+            .lines()
+            .position(|l| l.contains("part w : "))
+            .expect("line");
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 9, "text": text}}}),
+        );
+        let range = serde_json::json!({"start": {"line": line, "character": 13},
+                                       "end": {"line": line, "character": 13 + name.len()}});
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 5, "method": "textDocument/codeAction",
+                "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                           "range": range,
+                           "context": {"diagnostics": [
+                               {"range": range,
+                                "message": format!("unresolved reference `{name}`")}]}}}),
+        );
+        out[0]["result"]
+            .as_array()
+            .expect("actions")
+            .iter()
+            .filter_map(|a| a["title"].as_str())
+            .filter(|t| t.starts_with("Add import"))
+            .map(str::to_string)
+            .collect()
+    }
+
+    /// The path an inserted import names does not depend on the
+    /// questions asked before: a layer's routes are shared with the
+    /// layers above it, and one of those can declare a package of the
+    /// route's name itself (here the document's own `Kit`, whose
+    /// `Crate` takes the name, so `Kit::Crate` would name it).
+    #[test]
+    fn import_routes_do_not_depend_on_earlier_requests() {
+        let library = "standard library package KitParts { class Crate; } \
+                       standard library package Kit { public import KitParts::*; }";
+        let own_kit = "package Kit {\n    part def Crate;\n}\n";
+        let fresh = |prefix: &str| root_fix_titles(&mut library_server(library), prefix, "Crate");
+        let (with_own_kit, without) = (fresh(own_kit), fresh(""));
+        assert_eq!(
+            with_own_kit,
+            ["Add import Kit::Crate", "Add import KitParts::Crate"]
+        );
+        assert_eq!(without, ["Add import Kit::Crate"]);
+        let mut s = library_server(library);
+        assert_eq!(root_fix_titles(&mut s, "", "Crate"), without);
+        assert_eq!(root_fix_titles(&mut s, own_kit, "Crate"), with_own_kit);
+        assert_eq!(root_fix_titles(&mut s, "", "Crate"), without);
+    }
+
+    /// A private import elsewhere of a package the document declares
+    /// changes nothing any namespace makes visible, so a keystroke
+    /// still reworks only its own document.
+    #[test]
+    fn a_private_import_of_the_document_keeps_the_rest_cached() {
+        let mut s = library_server("standard library package Lib { class Unused; }");
+        let open = |s: &mut PushServer, uri: &str, text: &str| {
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen",
+                    "params": {"textDocument": {"uri": uri, "languageId": "sysml",
+                                                "version": 1, "text": text}}}),
+            );
+        };
+        open(
+            &mut s,
+            "file:///w/uses.sysml",
+            "package Uses {\n    private import P::*;\n    part def Wheel;\n}\n",
+        );
+        let complete = |s: &mut PushServer, typed: &str| {
+            let text = format!("package P {{\n    part w : {typed}\n}}\n");
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                                "version": 1, "text": text}}}),
+            );
+            let out = responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 1, "character": 13 + typed.len()}}}),
+            );
+            out[0]["result"].as_array().expect("items").len()
+        };
+        assert!(complete(&mut s, "") > 0);
+        crate::nav::WORK.with(|w| w.set([0; 3]));
+        assert!(complete(&mut s, "W") > 0);
+        assert_eq!(
+            crate::nav::WORK.with(std::cell::Cell::get),
+            [2, 0, 0],
+            "symbols indexed, names, route walks"
+        );
+    }
+
+    /// Taking an alias as what it names reads one name in each namespace
+    /// on the way, not everything the namespace makes visible: a request
+    /// whose list needs no namespace's names works none out, though the
+    /// document's alias `C` reads `Crate` through the import of `Kit`'s
+    /// members and the table holding it is built anew.
+    #[test]
+    fn aliases_resolve_without_working_out_whole_namespaces() {
+        let mut s = library_server("standard library package Kit { class Crate; class Pallet; }");
+        let text = "package P {\n    private import Kit::*;\n    alias C for Crate;\n    \
+                    package Q {\n        part def Leaf;\n    }\n    ref w : Q::\n}\n";
+        crate::nav::WORK.with(|w| w.set([0; 3]));
+        let items = completion_in_m(&mut s, text, 6, 15);
+        assert_eq!(completion_labels(&items), ["Leaf"]);
+        assert_eq!(
+            crate::nav::WORK.with(std::cell::Cell::get)[1],
+            0,
+            "namespaces whose names were worked out"
+        );
+    }
+
+    /// An import's filter condition is an expression, not the path:
+    /// a qualifier there (`[@MiniLib::`) offers no wildcards.
+    #[test]
+    fn an_import_filter_offers_no_wildcards() {
+        let mut s = two_package_server();
+        let text = "package P {\n    private import OtherLib::*[@MiniLib::\n}\n";
+        let items = completion_in_m(&mut s, text, 1, 41);
+        let labels = completion_labels(&items);
+        assert!(labels.contains(&"Widget"), "{labels:?}");
+        assert!(
+            !labels.contains(&"*") && !labels.contains(&"**"),
+            "{labels:?}"
+        );
+    }
+
+    /// A private member is visible only inside its namespace or through
+    /// an `import all`, where it needs no import, and no inserted import
+    /// makes it visible anywhere else: it is offered bare there, and
+    /// elsewhere neither with an import, nor in an import path, nor by
+    /// the "Add import" fix, nor after its namespace's qualifier.
+    #[test]
+    fn private_members_are_offered_only_where_visible() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/hidden.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Hidden {\n    private part def Secret;\n    \
+                                          part def Open;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : \n}\n", 1, 13);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && !labels.contains(&"Secret"),
+            "{labels:?}"
+        );
+        // An import of the namespace brings in its public members; only
+        // an `import all` brings in the others.
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Hidden::*;\n    part w : \n}\n",
+            2,
+            13,
+        );
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && !labels.contains(&"Secret"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import all Hidden::*;\n    part w : \n}\n",
+            2,
+            13,
+        );
+        let secret = items
+            .iter()
+            .find(|i| i["label"] == "Secret")
+            .expect("offered through an `import all`");
+        assert!(secret.get("additionalTextEdits").is_none(), "{secret}");
+        let items = completion_in_m(&mut s, "package P {\n    private import Sec\n}\n", 1, 22);
+        assert!(!completion_labels(&items).contains(&"Secret"));
+        assert!(import_fix_titles(&mut s, "", "Secret").is_empty());
+        // Inside its namespace: offered as is.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": "file:///w/hidden.sysml", "version": 2},
+                "contentChanges": [{"text": "package Hidden {\n    private part def Secret;\n    \
+                                              part w : \n}\n"}]}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/hidden.sysml"},
+                           "position": {"line": 2, "character": 13}}}),
+        );
+        let items = out[0]["result"].as_array().expect("items");
+        let secret = items
+            .iter()
+            .find(|i| i["label"] == "Secret")
+            .expect("offered inside its namespace");
+        assert!(secret.get("additionalTextEdits").is_none(), "{secret}");
+        // After its namespace's qualifier: inside the namespace, not
+        // outside it.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": "file:///w/hidden.sysml", "version": 3},
+                "contentChanges": [{"text": "package Hidden {\n    private part def Secret;\n    \
+                                              part w : Hidden::\n}\n"}]}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 4, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": "file:///w/hidden.sysml"},
+                           "position": {"line": 2, "character": 21}}}),
+        );
+        let labels = completion_labels(out[0]["result"].as_array().expect("items"));
+        assert!(labels.contains(&"Secret"), "{labels:?}");
+        let items = completion_in_m(&mut s, "package P {\n    part w : Hidden::\n}\n", 1, 21);
+        let labels = completion_labels(&items);
+        assert!(!labels.contains(&"Secret"), "{labels:?}");
+    }
+
+    /// The import edits of the items labeled `label`.
+    fn import_edits_of(items: &[serde_json::Value], label: &str) -> Vec<String> {
+        items
+            .iter()
+            .filter(|i| i["label"] == label)
+            .map(|i| {
+                i["additionalTextEdits"][0]["newText"]
+                    .as_str()
+                    .unwrap_or_default()
+                    .to_string()
+            })
+            .collect()
+    }
+
+    /// A name that two of a namespace's public imports bring in denotes
+    /// no one element there: `Kit::Crate` is an ambiguous reference
+    /// when `Kit` re-exports both `KitA::Crate` and `KitB::Crate` (the
+    /// standard library's `ISQ` does so for eleven names). No inserted
+    /// import runs through such a namespace, an existing import of it
+    /// does not count as providing the name, and a qualifier does not
+    /// offer it; its unambiguous neighbours are unaffected.
+    #[test]
+    fn ambiguous_reexports_are_not_imported_through() {
+        let mut s = library_server(
+            "standard library package KitA { class Crate; class Only; } \
+             standard library package KitB { class Crate; } \
+             standard library package Kit { public import KitA::*; public import KitB::*; }",
+        );
+        // Auto-import: the declaring package, not the facade.
+        let items = completion_in_m(&mut s, "package P {\n    ref w : \n}\n", 1, 12);
+        assert_eq!(
+            import_edits_of(&items, "Crate"),
+            ["private import KitA::Crate;\n    "]
+        );
+        assert_eq!(
+            import_edits_of(&items, "Only"),
+            ["private import Kit::Only;\n    "]
+        );
+        // An existing `import Kit::*;` provides `Only`, not `Crate`.
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Kit::*;\n    ref w : \n}\n",
+            2,
+            12,
+        );
+        let crate_item = items.iter().find(|i| i["label"] == "Crate").expect("Crate");
+        assert!(
+            crate_item.get("additionalTextEdits").is_some(),
+            "{crate_item}"
+        );
+        let only = items.iter().find(|i| i["label"] == "Only").expect("Only");
+        assert!(only.get("additionalTextEdits").is_none(), "{only}");
+        // After `Kit::`: `Only`, not the ambiguous `Crate`.
+        let items = completion_in_m(&mut s, "package P {\n    part w : Kit::\n}\n", 1, 18);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Only") && !labels.contains(&"Crate"),
+            "{labels:?}"
+        );
+        // Import-path completion: each `Crate` by its own path, once.
+        let items = completion_in_m(&mut s, "package P {\n    private import Cra\n}\n", 1, 22);
+        let mut paths: Vec<&str> = items
+            .iter()
+            .filter(|i| i["label"] == "Crate")
+            .filter_map(|i| i["textEdit"]["newText"].as_str())
+            .collect();
+        paths.sort_unstable();
+        assert_eq!(paths, ["KitA::Crate", "KitB::Crate"]);
+        // The quick fix agrees.
+        let mut titles = import_fix_titles(&mut s, "", "Crate");
+        titles.sort();
+        assert_eq!(titles, ["Add import KitA::Crate", "Add import KitB::Crate"]);
+    }
+
+    /// An owned member hides an imported one of the same name at every
+    /// step of a re-export chain: `Outer` re-exports `Facade`'s own
+    /// `Gadget`, not the `BaseP::Inner::Gadget` that `Facade` imports,
+    /// so `Outer::Gadget` would silently name the other element.
+    #[test]
+    fn hidden_reexports_are_not_imported_through() {
+        let mut s = library_server(
+            "standard library package BaseP { package Inner { class Gadget; } } \
+             standard library package Facade { public import BaseP::Inner::*; class Gadget; } \
+             standard library package Outer { public import Facade::*; }",
+        );
+        let items = completion_in_m(&mut s, "package P {\n    private import Gadg\n}\n", 1, 23);
+        let mut paths: Vec<&str> = items
+            .iter()
+            .filter(|i| i["label"] == "Gadget")
+            .filter_map(|i| i["textEdit"]["newText"].as_str())
+            .collect();
+        paths.sort_unstable();
+        assert_eq!(paths, ["BaseP::Inner::Gadget", "Facade::Gadget"]);
+        let mut titles = import_fix_titles(&mut s, "", "Gadget");
+        titles.sort();
+        assert_eq!(
+            titles,
+            [
+                "Add import BaseP::Inner::Gadget",
+                "Add import Facade::Gadget"
+            ]
+        );
+        // The hidden name is no ambiguity: `Outer::Gadget` is `Facade`'s
+        // own, listed after the qualifier and provided by an import of
+        // `Outer`, which does not provide the one it hides.
+        let items = completion_in_m(&mut s, "package P {\n    part w : Outer::\n}\n", 1, 20);
+        let gadget = items
+            .iter()
+            .find(|i| i["label"] == "Gadget")
+            .expect("Gadget listed");
+        assert_eq!(gadget["detail"], "Facade::Gadget");
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Outer::*;\n    ref w : \n}\n",
+            2,
+            12,
+        );
+        for (detail, provided) in [("Facade::Gadget", true), ("BaseP::Inner::Gadget", false)] {
+            let edits: Vec<bool> = items
+                .iter()
+                .filter(|i| i["detail"] == detail)
+                .map(|i| i.get("additionalTextEdits").is_none())
+                .collect();
+            assert!(
+                edits.is_empty() || edits == [provided],
+                "{detail}: {edits:?}"
+            );
+        }
+        let gadget = items
+            .iter()
+            .find(|i| i["label"] == "Gadget")
+            .expect("Gadget offered");
+        assert_eq!(gadget["detail"], "Facade::Gadget");
+        assert!(gadget.get("additionalTextEdits").is_none(), "{gadget}");
+    }
+
+    /// A filtered import brings in only the members its condition
+    /// admits (`[@Safety]`, or a `filter` member of the importing
+    /// package), which a syntax tier cannot evaluate: such a package
+    /// counts as re-exporting nothing — no inserted import runs through
+    /// it (`SafeParts::Bolt` does not resolve), an existing import of
+    /// it provides nothing, and its qualifier offers nothing imported.
+    #[test]
+    fn filtered_reexports_are_not_imported_through() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/lib.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Lib {\n    metadata def Safety;\n    \
+                                          package Parts {\n        part def Bolt;\n        \
+                                          part def Nut { @Safety; }\n    }\n}\n\
+                                          package SafeParts {\n    \
+                                          public import Lib::Parts::*[@Lib::Safety];\n}\n\
+                                          package SafeParts2 {\n    \
+                                          public import Lib::Parts::*;\n    \
+                                          filter @Lib::Safety;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : \n}\n", 1, 13);
+        for (label, path) in [("Bolt", "Lib::Parts::Bolt"), ("Nut", "Lib::Parts::Nut")] {
+            assert_eq!(
+                import_edits_of(&items, label),
+                [format!("private import {path};\n    ")],
+                "{label}"
+            );
+        }
+        for facade in ["SafeParts", "SafeParts2"] {
+            let text =
+                format!("package P {{\n    private import {facade}::*;\n    part w : \n}}\n");
+            let items = completion_in_m(&mut s, &text, 2, 13);
+            let bolt = items.iter().find(|i| i["label"] == "Bolt").expect("Bolt");
+            assert!(
+                bolt.get("additionalTextEdits").is_some(),
+                "{facade}: {bolt}"
+            );
+            let text = format!("package P {{\n    part w : {facade}::\n}}\n");
+            let items = completion_in_m(
+                &mut s,
+                &text,
+                1,
+                u32::try_from(15 + facade.len()).expect("column"),
+            );
+            let labels = completion_labels(&items);
+            assert!(!labels.contains(&"Bolt"), "{facade}: {labels:?}");
+        }
+        let titles = import_fix_titles(&mut s, "", "Bolt");
+        assert!(
+            titles.contains(&"Add import Lib::Parts::Bolt".to_string())
+                && !titles.iter().any(|t| t.contains("SafeParts")),
+            "{titles:?}"
+        );
+    }
+
+    /// The document's own filtered import provides only what its
+    /// condition admits, which completion cannot tell, so it counts as
+    /// providing none of the names the imported package re-exports —
+    /// whether the condition is the import's own `[…]` or a `filter`
+    /// member beside it — and accepting one still inserts its import.
+    #[test]
+    fn own_filtered_imports_admit_no_reexports() {
+        let mut s = library_server(
+            "standard library package Base { class Widget; metadata def Safety; } \
+             standard library package Facade { public import Base::*; }",
+        );
+        for (imports, provided) in [
+            ("    private import Facade::*;\n", true),
+            ("    private import Facade::*[@Base::Safety];\n", false),
+            (
+                "    private import Facade::*;\n    filter @Base::Safety;\n",
+                false,
+            ),
+        ] {
+            let text = format!("package P {{\n{imports}    ref w : \n}}\n");
+            let line = u32::try_from(text.lines().count() - 2).expect("line");
+            let items = completion_in_m(&mut s, &text, line, 12);
+            let widget = items
+                .iter()
+                .find(|i| i["label"] == "Widget")
+                .expect("Widget offered");
+            assert_eq!(
+                widget.get("additionalTextEdits").is_none(),
+                provided,
+                "{imports:?}: {widget}"
+            );
+        }
+    }
+
+    /// A private member is no member of its package for anyone outside
+    /// it, so a package that imports it does not re-export it either:
+    /// `Facade::Hidden` does not resolve.
+    #[test]
+    fn private_members_are_not_reexported() {
+        let mut s = library_server(
+            "standard library package Base { class Open; private class Hidden; } \
+             standard library package Facade { public import Base::*; }",
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : Facade::\n}\n", 1, 21);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && !labels.contains(&"Hidden"),
+            "{labels:?}"
+        );
+    }
+
+    /// Two imports of a scope bringing in different elements under one
+    /// name make it ambiguous there, so neither is named bare: the name
+    /// comes with an import of its one member, which is found ahead of
+    /// what the namespace imports bring in — and with that import in
+    /// place, it comes bare.
+    #[test]
+    fn a_name_two_imports_bring_in_comes_with_an_import_of_it() {
+        let mut s = library_server(
+            "standard library package KitA { class Crate; class Pallet; } \
+             standard library package KitB { class Crate; }",
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import KitA::*;\n    private import KitB::*;\n    \
+             ref w : \n}\n",
+            3,
+            12,
+        );
+        assert_eq!(
+            import_edits_of(&items, "Crate"),
+            ["\n    private import KitA::Crate;"]
+        );
+        assert_eq!(import_edits_of(&items, "Pallet"), [""]);
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import KitA::*;\n    private import KitB::*;\n    \
+             private import KitA::Crate;\n    ref w : \n}\n",
+            4,
+            12,
+        );
+        assert_eq!(import_edits_of(&items, "Crate"), [""]);
+    }
+
+    /// A name an import of one member brings in finds that member ahead
+    /// of anything an inserted import beside it could bring in, so no
+    /// other element of that name is offered with an import: here the
+    /// library's `Crate` comes bare, not the workspace's with one.
+    #[test]
+    fn an_import_of_one_member_keeps_its_name() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/q.sysml", "languageId": "sysml",
+                                 "version": 1, "text": "package Q {\n    part def Crate;\n}\n"}}}),
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Kit::Crate;\n    ref w : \n}\n",
+            2,
+            12,
+        );
+        let crates: Vec<&serde_json::Value> =
+            items.iter().filter(|i| i["label"] == "Crate").collect();
+        assert_eq!(crates.len(), 1, "{crates:?}");
+        assert_eq!(crates[0]["detail"], "Kit::Crate", "{:?}", crates[0]);
+        assert!(
+            crates[0].get("additionalTextEdits").is_none(),
+            "{:?}",
+            crates[0]
+        );
+    }
+
+    /// A name an enclosing package declares finds that element inside
+    /// the packages it holds too, so no other element of that name
+    /// comes with an import: one in the nearest package would take the
+    /// name from every reference there (`Inner::Deep` would stop
+    /// resolving). The element the name finds is offered, bare.
+    #[test]
+    fn a_name_an_enclosing_package_declares_keeps_it() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let items = completion_in_m(
+            &mut s,
+            "package BaseP {\n    package Inner {\n        part def Gadget;\n    }\n}\n\
+             package Hidden {\n    package Inner {\n        part def Deep;\n    }\n    \
+             package Vault {\n        part existing : Inner::Deep;\n        ref w : \n    }\n}\n",
+            11,
+            16,
+        );
+        let inners: Vec<&serde_json::Value> =
+            items.iter().filter(|i| i["label"] == "Inner").collect();
+        assert_eq!(inners.len(), 1, "{inners:?}");
+        assert_eq!(inners[0]["detail"], "Hidden::Inner", "{:?}", inners[0]);
+        assert!(
+            inners[0].get("additionalTextEdits").is_none(),
+            "{:?}",
+            inners[0]
+        );
+    }
+
+    /// The same for a name one namespace import of the package brings
+    /// in: an import of another `Mass` beside it would be found ahead
+    /// of it, and `existing` would name that one, silently.
+    #[test]
+    fn a_name_a_namespace_import_brings_in_keeps_it() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let items = completion_in_m(
+            &mut s,
+            "package Other {\n    part def Mass;\n}\npackage Lib {\n    part def Mass;\n}\n\
+             package P {\n    private import Lib::*;\n    part existing : Mass;\n    ref w : \n}\n",
+            9,
+            12,
+        );
+        let masses: Vec<&serde_json::Value> =
+            items.iter().filter(|i| i["label"] == "Mass").collect();
+        assert_eq!(masses.len(), 1, "{masses:?}");
+        assert_eq!(masses[0]["detail"], "Lib::Mass", "{:?}", masses[0]);
+        assert!(
+            masses[0].get("additionalTextEdits").is_none(),
+            "{:?}",
+            masses[0]
+        );
+    }
+
+    /// A private member is no member of its package for a client, so it
+    /// hides nothing from one either: what a public import brings in
+    /// under its name is what the client finds (`Facade::Part` is
+    /// `Base::Part`).
+    #[test]
+    fn private_members_hide_nothing_from_clients() {
+        let mut s = library_server(
+            "standard library package Base { class Part; } \
+             standard library package Facade { private class Part; public import Base::*; }",
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : Facade::\n}\n", 1, 21);
+        let part = items
+            .iter()
+            .find(|i| i["label"] == "Part")
+            .expect("offered after the qualifier");
+        assert_eq!(part["detail"], "Base::Part");
+    }
+
+    /// A usage without a name of its own is found by the name of the
+    /// feature it redefines (`attribute redefines mass = 5;`, `part :>>
+    /// engine`): listed under it after its owner's qualifier, which
+    /// lists what paths through it reach too, and counted when names
+    /// are compared — a recursive import of `Config` brings in two
+    /// `mass`es, so `Analysis::` lists neither, and nothing inside the
+    /// unnamed `engine`, which a recursive import does not reach into.
+    #[test]
+    fn unnamed_usages_are_found_by_the_name_they_redefine() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Defs {\n    part def Vehicle {\n        \
+                                          attribute mass;\n        part engine;\n    }\n}\n\
+                                          package Config {\n    part vehicle_b : Defs::Vehicle {\n        \
+                                          attribute redefines mass = 5;\n        \
+                                          part :>> engine {\n            part piston;\n        }\n    \
+                                          }\n    part other {\n        attribute mass;\n    }\n}\n\
+                                          package Analysis {\n    public import Config::**;\n}\n"}}}),
+        );
+        let labels = |s: &mut PushServer, qualifier: &str| -> Vec<String> {
+            let text = format!("package P {{\n    ref w : {qualifier}::\n}}\n");
+            let character = u32::try_from(14 + qualifier.len()).expect("column");
+            completion_labels(&completion_in_m(s, &text, 1, character))
+                .into_iter()
+                .map(str::to_string)
+                .collect()
+        };
+        assert_eq!(labels(&mut s, "Config::vehicle_b"), ["mass", "engine"]);
+        assert_eq!(labels(&mut s, "Config::vehicle_b::engine"), ["piston"]);
+        let analysis = labels(&mut s, "Analysis");
+        assert!(analysis.contains(&"engine".to_string()), "{analysis:?}");
+        assert!(
+            !analysis.contains(&"mass".to_string()) && !analysis.contains(&"piston".to_string()),
+            "{analysis:?}"
+        );
+    }
+
+    /// A `perform` or a `satisfy` without a name of its own is found by
+    /// the name of what it references — for a `perform`, the last step
+    /// of a feature chain: `C::p::` lists `act`, `step`, and `req`.
+    #[test]
+    fn unnamed_usages_are_found_by_what_they_reference() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Acts {\n    action def Act;\n    \
+                                          action act : Act {\n        action step;\n    }\n    \
+                                          requirement req;\n}\npackage C {\n    part p {\n        \
+                                          perform Acts::act;\n        perform Acts::act.step;\n        \
+                                          satisfy Acts::req by p;\n    }\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    ref w : C::p::\n}\n", 1, 19);
+        assert_eq!(completion_labels(&items), ["act", "step", "req"]);
+    }
+
+    /// A usage without a name of its own is offered by the name it is
+    /// found by only after its owner's qualifier: in the list a name
+    /// brings up anywhere, `spec` is the requirement a package declares,
+    /// with its import, not the `satisfy` that references it.
+    #[test]
+    fn unnamed_usages_leave_their_names_to_what_declares_them() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Model {\n    part def V;\n    package Parts {\n        \
+                                          part v : V {\n            satisfy Reqs::spec by v;\n        \
+                                          }\n    }\n    package Reqs {\n        requirement spec;\n    \
+                                          }\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    alias a for \n}\n", 1, 16);
+        let specs: Vec<&serde_json::Value> =
+            items.iter().filter(|i| i["label"] == "spec").collect();
+        assert_eq!(specs.len(), 1, "{specs:?}");
+        assert_eq!(specs[0]["detail"], "Model::Reqs::spec", "{:?}", specs[0]);
+        assert_eq!(
+            import_edits_of(&items, "spec"),
+            ["    private import Model::Reqs::spec;\n"]
+        );
+    }
+
+    /// An import resolves its path from where it sits: where a name
+    /// there takes the path's first segment from the top-level package
+    /// — here the `Reqs` that `Facade` re-exports — the inserted import
+    /// writes the path from the global scope.
+    #[test]
+    fn an_inserted_import_whose_first_segment_is_taken_starts_at_the_root() {
+        let mut s = library_server("standard library package Reqs { class check; }");
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/conf.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Conf {\n    package Reqs {\n        \
+                                          part def Other;\n    }\n}\n\
+                                          package Facade {\n    public import Conf::*;\n}\n"}}}),
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Facade::*;\n    ref w : \n}\n",
+            2,
+            12,
+        );
+        assert_eq!(
+            import_edits_of(&items, "check"),
+            ["\n    private import $::Reqs::check;"]
+        );
+        assert_eq!(
+            import_fix_titles(&mut s, "    private import Facade::*;\n", "check"),
+            ["Add import $::Reqs::check"]
+        );
+        // Without the import, the path is written as it is.
+        let items = completion_in_m(&mut s, "package P {\n    ref w : \n}\n", 1, 12);
+        assert_eq!(
+            import_edits_of(&items, "check"),
+            ["private import Reqs::check;\n    "]
+        );
+    }
+
+    /// Inside the element holding it, a redefinition without a name of
+    /// its own is what the name it redefines finds: at an operand in
+    /// `SportCar`, `engine` is `SportCar`'s, named so, not `Car`'s.
+    #[test]
+    fn a_redefinition_is_offered_as_itself_inside_its_owner() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let text = "package P {\n    part def Car {\n        part engine;\n    }\n    \
+                    part def SportCar :> Car {\n        part :>> engine {\n            \
+                    attribute hp;\n        }\n        attribute y = \n    }\n}\n";
+        let items = completion_in_m(&mut s, text, 8, 22);
+        let engines: Vec<&serde_json::Value> =
+            items.iter().filter(|i| i["label"] == "engine").collect();
+        assert_eq!(engines.len(), 1, "{engines:?}");
+        assert_eq!(
+            engines[0]["detail"], "P::SportCar::engine",
+            "{:?}",
+            engines[0]
+        );
+    }
+
+    /// A member of a type is offered by simple name wherever that name
+    /// finds it, bare: inherited into a specialization or into a usage
+    /// the type types — at an operand, a `perform`, or a level deeper —
+    /// and brought in by an import of the type's members, of the one
+    /// member, or of everything below the type.
+    #[test]
+    fn members_of_types_are_offered_wherever_their_names_find_them() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let lib = "package Lib {\n    action def Go;\n    part def Car {\n        \
+                   attribute wheelbase;\n        part chassis {\n            \
+                   attribute stiffness;\n        }\n        action drive : Go;\n    }\n}\n";
+        for (body, want) in [
+            (
+                "    part def SportCar :> Lib::Car {\n        attribute x = ",
+                "Lib::Car::wheelbase",
+            ),
+            (
+                "    part car : Lib::Car {\n        attribute x = ",
+                "Lib::Car::wheelbase",
+            ),
+            (
+                "    part car : Lib::Car {\n        part inner {\n            attribute x = ",
+                "Lib::Car::chassis",
+            ),
+            (
+                "    part car : Lib::Car {\n        perform ",
+                "Lib::Car::drive",
+            ),
+            (
+                "    private import Lib::Car::*;\n    attribute x = ",
+                "Lib::Car::wheelbase",
+            ),
+            (
+                "    private import Lib::Car::wheelbase;\n    attribute x = ",
+                "Lib::Car::wheelbase",
+            ),
+            (
+                "    private import Lib::Car::**;\n    attribute x = ",
+                "Lib::Car::chassis::stiffness",
+            ),
+        ] {
+            let before = format!("{lib}package P {{\n{body}");
+            let line = u32::try_from(before.matches('\n').count()).expect("short text");
+            let character = u32::try_from(before.rsplit('\n').next().unwrap_or_default().len())
+                .expect("short line");
+            let open = body.matches('{').count();
+            let text = format!("{before}\n{}}}\n", "    }\n".repeat(open));
+            let items = completion_in_m(&mut s, &text, line, character);
+            let label = want.rsplit("::").next().unwrap_or(want);
+            let item = items.iter().find(|i| i["label"] == label);
+            assert_eq!(
+                item.map(|i| i["detail"].clone()),
+                Some(serde_json::json!(want)),
+                "{body:?}: {label} offered as {item:?}"
+            );
+            assert!(
+                item.is_some_and(|i| i.get("additionalTextEdits").is_none()),
+                "{body:?}: {item:?}"
+            );
+        }
+    }
+
+    /// An alias comes bare by its own name beside an import of a package
+    /// that re-exports it, as beside an import of the package declaring
+    /// it: the name finds the alias, which names the element it is an
+    /// alias for — the one element, not another.
+    #[test]
+    fn an_alias_is_offered_through_a_package_re_exporting_it() {
+        let mut s = library_server(
+            "standard library package ISQBase { attribute def DurationValue; } \
+             standard library package ISQSpaceTime { private import ISQBase::*; \
+             alias TimeValue for DurationValue; } \
+             standard library package ISQ { public import ISQBase::*; \
+             public import ISQSpaceTime::*; }",
+        );
+        for import in ["ISQ::*", "Defs::*", "Outer::*"] {
+            let text = format!(
+                "package Outer {{\n    public import Defs::*;\n}}\n\
+                 package Defs {{\n    public import ISQ::*;\n}}\n\
+                 package P {{\n    private import {import};\n    attribute x : \n}}\n"
+            );
+            let cursor = text.find("attribute x : ").expect("cursor") + "attribute x : ".len();
+            let line = u32::try_from(text[..cursor].matches('\n').count()).expect("short text");
+            let character =
+                u32::try_from(text[..cursor].rsplit('\n').next().unwrap_or_default().len())
+                    .expect("short line");
+            let items = completion_in_m(&mut s, &text, line, character);
+            let found: Vec<_> = items.iter().filter(|i| i["label"] == "TimeValue").collect();
+            assert_eq!(found.len(), 1, "{import}: {found:?}");
+            assert_eq!(
+                found[0]["detail"], "ISQSpaceTime::TimeValue",
+                "{import}: {found:?}"
+            );
+            assert!(
+                found[0].get("additionalTextEdits").is_none(),
+                "{import}: {found:?}"
+            );
+        }
+    }
+
+    /// A member of a type comes bare through a package re-exporting it —
+    /// one importing the type's members publicly, the one member, or
+    /// everything below the type — beside an import of that package's
+    /// members.
+    #[test]
+    fn members_of_types_are_offered_through_a_re_exporting_package() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let lib = "package Lib {\n    part def Car {\n        attribute wheelbaseQq;\n        \
+                   part chassisQq {\n            attribute stiffnessQq;\n        }\n    }\n}\n";
+        for (export, want) in [
+            ("public import Lib::Car::*;", "Lib::Car::wheelbaseQq"),
+            (
+                "public import Lib::Car::wheelbaseQq;",
+                "Lib::Car::wheelbaseQq",
+            ),
+            (
+                "public import Lib::Car::**;",
+                "Lib::Car::chassisQq::stiffnessQq",
+            ),
+        ] {
+            let text = format!(
+                "{lib}package Pub {{\n    {export}\n}}\n\
+                 package P {{\n    private import Pub::*;\n    attribute x = \n}}\n"
+            );
+            let cursor = text.find("attribute x = ").expect("cursor") + "attribute x = ".len();
+            let line = u32::try_from(text[..cursor].matches('\n').count()).expect("short text");
+            let character =
+                u32::try_from(text[..cursor].rsplit('\n').next().unwrap_or_default().len())
+                    .expect("short line");
+            let items = completion_in_m(&mut s, &text, line, character);
+            let label = want.rsplit("::").next().unwrap_or(want);
+            let item = items.iter().find(|i| i["label"] == label);
+            assert_eq!(
+                item.map(|i| i["detail"].clone()),
+                Some(serde_json::json!(want)),
+                "{export}: {label} offered as {item:?}"
+            );
+            assert!(
+                item.is_some_and(|i| i.get("additionalTextEdits").is_none()),
+                "{export}: {item:?}"
+            );
+        }
+    }
+
+    /// Inside elements nested in one another, a name finds the innermost
+    /// one's own or inherited member first: in `vehicle_b`'s `engine`,
+    /// `mass` and `fuelCmdPort` are the engine's, `range` the vehicle's,
+    /// and in `vehicle_b`, a member redefining `range` hides the one it
+    /// inherits.
+    #[test]
+    fn inherited_members_are_found_innermost_first() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let lib = "package Lib {\n    part def Engine {\n        attribute mass;\n        \
+                   port fuelCmdPort;\n    }\n    part def Vehicle {\n        attribute mass;\n        \
+                   port fuelCmdPort;\n        attribute range;\n        part engine : Engine;\n    \
+                   }\n}\n";
+        let engine = "    part vehicle_b : Lib::Vehicle {\n        part :>> engine {\n            \
+                      attribute x = ";
+        let vehicle = "    part vehicle_b : Lib::Vehicle {\n        attribute x = ";
+        let redefined = "    part vehicle_b : Lib::Vehicle {\n        attribute :>> range = 5;\n        \
+             attribute x = ";
+        for (body, label, want) in [
+            (engine, "mass", "Lib::Engine::mass"),
+            (engine, "fuelCmdPort", "Lib::Engine::fuelCmdPort"),
+            (engine, "range", "Lib::Vehicle::range"),
+            (vehicle, "mass", "Lib::Vehicle::mass"),
+            (redefined, "range", "P::vehicle_b::range"),
+        ] {
+            let before = format!("{lib}package P {{\n{body}");
+            let line = u32::try_from(before.matches('\n').count()).expect("short text");
+            let character = u32::try_from(before.rsplit('\n').next().unwrap_or_default().len())
+                .expect("short line");
+            let open = body.matches('{').count();
+            let text = format!("{before}\n{}}}\n", "    }\n".repeat(open));
+            let items = completion_in_m(&mut s, &text, line, character);
+            let found: Vec<_> = items.iter().filter(|i| i["label"] == label).collect();
+            assert_eq!(found.len(), 1, "{body:?}: {label} offered as {found:?}");
+            assert_eq!(found[0]["detail"], want, "{body:?}: {found:?}");
+            assert!(found[0].get("additionalTextEdits").is_none(), "{found:?}");
+        }
+    }
+
+    /// The ends a connection names as it connects them are its own
+    /// features: inside it, such an end hides the member of its type it
+    /// redefines, which is not offered for its name there.
+    #[test]
+    fn a_connections_named_ends_hide_what_its_type_declares() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let text = "package Lib {\n    port def P;\n    interface def I {\n        end a : P;\n        \
+                    end b : P;\n    }\n}\n\
+                    package M {\n    part x {\n        port pa : Lib::P;\n    }\n    part y {\n        \
+                    port pb : Lib::P;\n    }\n    \
+                    interface i : Lib::I connect a ::> x.pa to b ::> y.pb {\n        attribute z = \n    \
+                    }\n}\n";
+        let items = completion_in_m(&mut s, text, 15, 22);
+        let ends: Vec<_> = items
+            .iter()
+            .filter(|i| i["detail"] == "Lib::I::a" || i["detail"] == "Lib::I::b")
+            .collect();
+        assert!(ends.is_empty(), "{ends:?}");
+    }
+
+    /// Definitions specializing each other in a cycle pass on what each
+    /// declares, the cycle cut where it closes.
+    #[test]
+    fn inherited_members_come_through_a_specialization_cycle() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let text = "package Lib {\n    part def A :> B {\n        attribute fromA;\n    }\n    \
+                    part def B :> A {\n        attribute fromB;\n    }\n}\n\
+                    package P {\n    part x : Lib::A {\n        attribute y = \n    }\n}\n";
+        let items = completion_in_m(&mut s, text, 10, 22);
+        for (label, want) in [("fromA", "Lib::A::fromA"), ("fromB", "Lib::B::fromB")] {
+            let found: Vec<_> = items.iter().filter(|i| i["label"] == label).collect();
+            assert_eq!(found.len(), 1, "{label}: {found:?}");
+            assert_eq!(found[0]["detail"], want);
+        }
+    }
+
+    /// A name an inherited member takes at the cursor is offered as that
+    /// member, bare — not as a library element of the same name with an
+    /// import the member would shadow.
+    #[test]
+    fn an_inherited_member_keeps_its_name_from_the_library() {
+        let mut s = library_server(
+            "standard library package ISQSpaceTime { attribute speed; } \
+             standard library package ISQ { public import ISQSpaceTime::*; }",
+        );
+        let text = "package Lib {\n    part def Car {\n        attribute speed;\n    }\n}\n\
+                    package P {\n    part def SportCar :> Lib::Car {\n        attribute x = \n    \
+                    }\n}\n";
+        let items = completion_in_m(&mut s, text, 7, 22);
+        let speeds: Vec<_> = items.iter().filter(|i| i["label"] == "speed").collect();
+        assert_eq!(speeds.len(), 1, "{speeds:?}");
+        assert_eq!(speeds[0]["detail"], "Lib::Car::speed");
+        assert!(speeds[0].get("additionalTextEdits").is_none(), "{speeds:?}");
+    }
+
+    /// Where the enclosing element's features are named (`:>>`), each
+    /// label comes once, an inherited member's too: the feature the
+    /// position names, or the member as the symbol tables hold it.
+    #[test]
+    fn an_inherited_member_is_offered_once_where_features_are_named() {
+        let mut s = library_server("standard library package Kit { class Crate; }");
+        let text = "package Lib {\n    part def Car {\n        attribute speed;\n        \
+                    part wheel;\n    }\n}\n\
+                    package P {\n    part def SportCar :> Lib::Car {\n        part :>> \n    \
+                    }\n}\n";
+        let items = completion_in_m(&mut s, text, 8, 17);
+        let labels = completion_labels(&items);
+        for label in ["speed", "wheel"] {
+            assert_eq!(
+                labels.iter().filter(|l| **l == label).count(),
+                1,
+                "{label}: {labels:?}"
+            );
+        }
+        let unique: std::collections::HashSet<&&str> = labels.iter().collect();
+        assert_eq!(unique.len(), labels.len(), "{labels:?}");
+    }
+
+    /// A recursive import brings in what the elements below its
+    /// namespace inherit from the workspace's types — `own`, through
+    /// `c : Defs::M` — but not what a library type passes on, which
+    /// also comes to elements no declaration shows inheriting it, so
+    /// that the name may denote several.
+    #[test]
+    fn a_recursive_import_brings_in_what_the_elements_below_inherit() {
+        let mut s =
+            library_server("standard library package L { part def T { attribute shared; } }");
+        let text = "package Defs {\n    part def M {\n        attribute own;\n    }\n}\n\
+                    package Config {\n    part a : L::T;\n    part c : Defs::M;\n}\n\
+                    package Analysis {\n    public import Config::**;\n}\n\
+                    package Q {\n    attribute y : Analysis::\n}\n";
+        let items = completion_in_m(&mut s, text, 13, 28);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"own") && !labels.contains(&"shared"),
+            "{labels:?}"
+        );
+    }
+
+    /// A member of a type has no path an import could name: where its
+    /// simple name does not find it — beside `Cars`, outside `Car` and
+    /// what inherits from it — it is not offered; inside its owner it
+    /// is.
+    #[test]
+    fn members_of_types_are_offered_by_name_only_where_their_names_find_them() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/cars.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Cars {\n    part def Car {\n        \
+                                          part wheel;\n    }\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    alias a for \n}\n", 1, 16);
+        assert!(!completion_labels(&items).contains(&"wheel"));
+        let items = completion_in_m(
+            &mut s,
+            "package Trucks {\n    part def Truck {\n        part axle;\n        \
+             alias a for \n    }\n}\n",
+            3,
+            20,
+        );
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"axle") && !labels.contains(&"wheel"),
+            "{labels:?}"
+        );
+    }
+
+    /// A member of a private package has no path outside the namespace
+    /// owning that package: it is offered there (inside `Outer`, with an
+    /// import), and elsewhere only through a package re-exporting it —
+    /// `Deep2` with an import of `Outer2::Deep2` — never `Deep`: not by
+    /// simple name, through an import of its package's members, in an
+    /// import path, by the "Add import" fix, after its package's
+    /// qualifier, nor through a recursive import of `Outer3`, which
+    /// shows its clients nothing of a private package.
+    #[test]
+    fn members_of_a_private_package_are_offered_only_where_they_resolve() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/nested.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Outer {\n    private package Inner {\n        \
+                                          part def Deep;\n    }\n}\n\
+                                          package Outer2 {\n    private package Inner2 {\n        \
+                                          part def Deep2;\n    }\n    public import Inner2::*;\n}\n\
+                                          package Outer3 {\n    private package Inner3 {\n        \
+                                          part def Deep3;\n    }\n}\n\
+                                          package Facade3 {\n    public import Outer3::**;\n}\n"}}}),
+        );
+        for (imports, edit) in [
+            ("", "private import Outer2::Deep2;\n    "),
+            (
+                "    private import Outer::Inner::*;\n",
+                "\n    private import Outer2::Deep2;",
+            ),
+        ] {
+            let text = format!("package P {{\n{imports}    ref w : \n}}\n");
+            let line = text
+                .lines()
+                .position(|l| l.contains("ref w"))
+                .expect("line");
+            let line = u32::try_from(line).expect("line");
+            let items = completion_in_m(&mut s, &text, line, 12);
+            assert!(import_edits_of(&items, "Deep").is_empty(), "{imports:?}");
+            assert_eq!(import_edits_of(&items, "Deep2"), [edit], "{imports:?}");
+        }
+        let items = completion_in_m(&mut s, "package P {\n    private import \n}\n", 1, 19);
+        let labels = completion_labels(&items);
+        assert!(
+            !labels.contains(&"Deep") && labels.contains(&"Deep2"),
+            "{labels:?}"
+        );
+        assert!(import_fix_titles(&mut s, "", "Deep").is_empty());
+        assert_eq!(
+            import_fix_titles(&mut s, "", "Deep2"),
+            ["Add import Outer2::Deep2"]
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    ref w : Outer::Inner::\n}\n",
+            1,
+            26,
+        );
+        assert!(!completion_labels(&items).contains(&"Deep"));
+        let items = completion_in_m(&mut s, "package P {\n    ref w : Facade3::\n}\n", 1, 21);
+        assert!(!completion_labels(&items).contains(&"Deep3"));
+        // Inside `Outer`, its path resolves.
+        let items = completion_in_m(
+            &mut s,
+            "package Outer {\n    private package Inner {\n        part def Deep;\n    }\n    \
+             ref w : \n}\n",
+            4,
+            12,
+        );
+        assert_eq!(
+            import_edits_of(&items, "Deep"),
+            ["private import Outer::Inner::Deep;\n    "]
+        );
+    }
+
+    /// An `import all` brings in a namespace's members whatever their
+    /// visibility, so a public one re-exports them all: `AllFacade::`
+    /// lists `Secret`, which `PlainFacade::` does not, and an import of
+    /// `AllFacade`'s members lets `Secret` be named bare.
+    #[test]
+    fn a_public_import_all_reexports_every_member() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/hidden.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Hidden {\n    private part def Secret;\n    \
+                                          part def Open;\n}\npackage AllFacade {\n    \
+                                          public import all Hidden::*;\n}\n\
+                                          package PlainFacade {\n    \
+                                          public import Hidden::*;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : AllFacade::\n}\n", 1, 24);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && labels.contains(&"Secret"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    part w : PlainFacade::\n}\n",
+            1,
+            26,
+        );
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && !labels.contains(&"Secret"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import AllFacade::*;\n    part w : \n}\n",
+            2,
+            13,
+        );
+        let secret = items
+            .iter()
+            .find(|i| i["label"] == "Secret")
+            .expect("offered through the facade's `import all`");
+        assert!(secret.get("additionalTextEdits").is_none(), "{secret}");
+    }
+
+    /// An `import all` path names a namespace's members whatever their
+    /// visibility: after `import all Hidden::` its private members are
+    /// listed, after `import Hidden::` they are not.
+    #[test]
+    fn an_import_all_path_lists_every_member() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/hidden.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Hidden {\n    private part def Secret;\n    \
+                                          protected part def Guarded;\n    \
+                                          part def Open;\n}\n"}}}),
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import all Hidden::\n}\n",
+            1,
+            31,
+        );
+        let labels = completion_labels(&items);
+        for label in ["Secret", "Guarded", "Open"] {
+            assert!(labels.contains(&label), "{label}: {labels:?}");
+        }
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import Hidden::\n}\n",
+            1,
+            27,
+        );
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"Open") && !labels.contains(&"Secret") && !labels.contains(&"Guarded"),
+            "{labels:?}"
+        );
+    }
+
+    /// A library package's private member is a name for a model only
+    /// through an `import all`: named bare where one is in scope, and
+    /// listed after `import all Base::`.
+    #[test]
+    fn private_library_members_come_in_through_import_all() {
+        let mut s =
+            library_server("standard library package Base { class Open; private class Hidden; }");
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import all Base::*;\n    ref w : \n}\n",
+            2,
+            12,
+        );
+        let hidden = items
+            .iter()
+            .find(|i| i["label"] == "Hidden")
+            .expect("offered through the `import all`");
+        assert!(hidden.get("additionalTextEdits").is_none(), "{hidden}");
+        let items = completion_in_m(
+            &mut s,
+            "package P {\n    private import all Base::\n}\n",
+            1,
+            29,
+        );
+        assert!(completion_labels(&items).contains(&"Hidden"));
+    }
+
+    /// A library package's private member is no name for a model: not
+    /// offered by simple name, in an import path, after its package's
+    /// qualifier, or by the "Add import" fix.
+    #[test]
+    fn private_library_members_are_not_offered() {
+        let mut s = library_server(
+            "standard library package Base { class Open; private class Hidden; \
+             protected class Kept; }",
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {
+    ref w : 
+}
+",
+            1,
+            12,
+        );
+        let labels = completion_labels(&items);
+        assert!(labels.contains(&"Open"), "{labels:?}");
+        assert!(
+            !labels.contains(&"Hidden") && !labels.contains(&"Kept"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {
+    private import 
+}
+",
+            1,
+            19,
+        );
+        let labels = completion_labels(&items);
+        assert!(labels.contains(&"Open"), "{labels:?}");
+        assert!(
+            !labels.contains(&"Hidden") && !labels.contains(&"Kept"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package P {
+    part w : Base::
+}
+",
+            1,
+            19,
+        );
+        assert_eq!(completion_labels(&items), ["Open"]);
+        assert!(import_fix_titles(&mut s, "", "Hidden").is_empty());
+    }
+
+    /// A single-member re-export routes an import of that member alone:
+    /// `Top` re-exports `Deep::Inner::Pin`, so an inserted import names
+    /// `Top::Pin`, while `Inner`'s other members keep their own paths.
+    #[test]
+    fn single_member_reexports_route_that_member() {
+        let mut s = library_server(
+            "standard library package Deep { package Inner { class Pin; class Peg; } } \
+             standard library package Top { public import Deep::Inner::Pin; }",
+        );
+        let titles = import_fix_titles(&mut s, "", "Pin");
+        assert_eq!(titles, ["Add import Top::Pin"]);
+        let titles = import_fix_titles(&mut s, "", "Peg");
+        assert_eq!(titles, ["Add import Deep::Inner::Peg"]);
+        let items = completion_in_m(&mut s, "package P {\n    private import P\n}\n", 1, 20);
+        let path = |label: &str| -> Vec<&str> {
+            items
+                .iter()
+                .filter(|i| i["label"] == label)
+                .filter_map(|i| i["textEdit"]["newText"].as_str())
+                .collect()
+        };
+        assert_eq!(path("Pin"), ["Top::Pin"]);
+        assert_eq!(path("Peg"), ["Deep::Inner::Peg"]);
+    }
+
+    /// Typing in one document costs a completion request that
+    /// document's symbols alone: the rest of the workspace is not
+    /// re-read, and what its namespaces and the library's make visible,
+    /// and which packages route their members, is not worked out again
+    /// — until another document changes.
+    #[test]
+    fn a_keystroke_reworks_only_its_own_document() {
+        let mut s = library_server(
+            "standard library package Base { class Widget; class Gadget; } \
+             standard library package Facade { public import Base::*; }",
+        );
+        let open = |s: &mut PushServer, uri: &str, version: i32, text: &str| {
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen",
+                    "params": {"textDocument": {"uri": uri, "languageId": "sysml",
+                                                "version": version, "text": text}}}),
+            );
+        };
+        let model = "package Model {\n    public import Facade::*;\n    package Parts {\n        \
+                     part def Wheel;\n    }\n    public import Parts::*;\n}\n";
+        open(&mut s, "file:///w/model.sysml", 1, model);
+        let doc = |typed: &str| format!("package P {{\n    part w : {typed}\n}}\n");
+        let complete = |s: &mut PushServer, typed: &str| {
+            let out = responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": "file:///w/m.sysml"},
+                               "position": {"line": 1,
+                                            "character": 13 + typed.len()}}}),
+            );
+            out[0]["result"].as_array().expect("items").len()
+        };
+        let change = |s: &mut PushServer, uri: &str, version: i32, text: &str| {
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange",
+                    "params": {"textDocument": {"uri": uri, "version": version},
+                               "contentChanges": [{"text": text}]}}),
+            );
+        };
+        open(&mut s, "file:///w/m.sysml", 1, &doc(""));
+        assert!(complete(&mut s, "") > 0);
+        let reset = || crate::nav::WORK.with(|w| w.set([0; 3]));
+        let work = || crate::nav::WORK.with(std::cell::Cell::get);
+
+        // A keystroke: the document's own symbols, nothing else.
+        reset();
+        change(&mut s, "file:///w/m.sysml", 2, &doc("W"));
+        assert!(complete(&mut s, "W") > 0);
+        assert_eq!(work(), [2, 0, 0], "symbols indexed, names, route walks");
+
+        // Another document changed: the rest of the workspace is read
+        // anew, and what depends on it worked out again.
+        change(
+            &mut s,
+            "file:///w/model.sysml",
+            2,
+            &model.replace("Wheel", "Tire"),
+        );
+        reset();
+        assert!(complete(&mut s, "W") > 0);
+        let [symbols, names, walks] = work();
+        assert!(symbols > 2 && names > 0 && walks > 0, "{:?}", work());
+    }
+
+    /// An import target reached through other packages' re-exports
+    /// resolves however long the chain: `Z` imports `A::Deep`, which `A`
+    /// re-exports from `B::X`, which `B` re-exports from `C`.
+    #[test]
+    fn import_targets_resolve_through_any_chain() {
+        let mut s = library_server(
+            "standard library package C { package X { class Deep; } } \
+             standard library package B { public import C::*; } \
+             standard library package A { public import B::X::*; } \
+             standard library package Z { public import A::Deep; }",
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : Z::\n}\n", 1, 16);
+        assert_eq!(completion_labels(&items), ["Deep"]);
+    }
+
+    /// A document reopened with new text at the version it had counts as
+    /// changed: completion offers what the new text declares.
+    #[test]
+    fn a_document_reopened_at_its_old_version_is_read_again() {
+        let mut s = library_server("standard library package Lib { class Unused; }");
+        let open = |s: &mut PushServer, text: &str| {
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen",
+                    "params": {"textDocument": {"uri": "file:///w/model.sysml", "languageId": "sysml",
+                                                "version": 1, "text": text}}}),
+            );
+        };
+        open(&mut s, "package Model { part def Wheel; }");
+        let labels = |s: &mut PushServer| -> Vec<String> {
+            let items = completion_in_m(s, "package P {\n    part w : \n}\n", 1, 13);
+            completion_labels(&items)
+                .into_iter()
+                .map(str::to_string)
+                .collect()
+        };
+        assert!(labels(&mut s).contains(&"Wheel".to_string()));
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didClose",
+                "params": {"textDocument": {"uri": "file:///w/model.sysml"}}}),
+        );
+        open(&mut s, "package Model { part def Tire; }");
+        let offered = labels(&mut s);
+        assert!(
+            offered.contains(&"Tire".to_string()) && !offered.contains(&"Wheel".to_string()),
+            "{offered:?}"
+        );
+    }
+
+    /// Another document's import can name a namespace the document being
+    /// completed declares: what it re-exports is still offered, and an
+    /// import through it still admits and routes.
+    #[test]
+    fn imports_into_the_document_being_completed_still_count() {
+        let mut s = library_server("standard library package Lib { class Unused; }");
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen",
+                "params": {"textDocument": {"uri": "file:///w/uses.sysml", "languageId": "sysml",
+                                            "version": 1,
+                                            "text": "package Uses {\n    public import Defs::*;\n}\n"}}}),
+        );
+        let items = completion_in_m(
+            &mut s,
+            "package Defs {\n    part def Engine;\n}\npackage P {\n    part e : Uses::\n}\n",
+            4,
+            19,
+        );
+        let labels = completion_labels(&items);
+        assert!(labels.contains(&"Engine"), "{labels:?}");
+    }
+
+    /// An alias completes as what it names: with its target's kind (and
+    /// icon) when the target is a sibling — by name or by short name,
+    /// through further aliases — and with the module kind when a
+    /// syntax-tier lookup cannot follow it. The outline still shows an
+    /// alias as one.
+    #[test]
+    fn aliases_complete_as_what_they_name() {
+        use lsp_types::CompletionItemKind as K;
+        let mut s = library_server(
+            "standard library package Kit { class Bolt; feature <m> metre; function twice; \
+             package Parts; alias Fastener for Bolt; alias Meter for m; alias Double for twice; \
+             alias Stock for Parts; alias Screw for Fastener; alias Lost for Missing; \
+             alias Far for Other::Thing; }",
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : Kit::\n}\n", 1, 18);
+        for (label, kind) in [
+            ("Fastener", K::CLASS),
+            ("Meter", K::VARIABLE),
+            ("Double", K::FUNCTION),
+            ("Stock", K::MODULE),
+            ("Screw", K::CLASS),
+            ("Lost", K::MODULE),
+            ("Far", K::MODULE),
+        ] {
+            let item = items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"));
+            assert_eq!(item["kind"], serde_json::json!(kind), "{item}");
+        }
+
+        // A workspace alias, and the outline of its document.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/cars.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package Cars {\n    part def Car;\n    alias Auto for Car;\n}\n"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    part w : \n}\n", 1, 13);
+        let auto = items
+            .iter()
+            .find(|i| i["label"] == "Auto")
+            .expect("Auto offered");
+        assert_eq!(auto["kind"], serde_json::json!(K::CLASS), "{auto}");
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/documentSymbol",
+                "params": {"textDocument": {"uri": "file:///w/cars.sysml"}}}),
+        );
+        let outline = &out[0]["result"][0]["children"];
+        assert_eq!(outline[1]["name"], "Auto");
+        assert_eq!(
+            outline[1]["kind"],
+            serde_json::json!(lsp_types::SymbolKind::MODULE)
+        );
+    }
+
+    /// A function named by an operator (`'+'`, `'['`) or a word
+    /// operator (`'not'`), and an alias naming one (`alias '*' for
+    /// times;`), is written as that operator, never by name:
+    /// unqualified completion — the flat list and an import path's
+    /// first segment — leaves it out, while a qualifier still lists
+    /// it. The element decides, not the spelling: a unit spelled `%`
+    /// stays, as a short name or as an alias, and so does a function
+    /// whose quoted name holds a word (`'cartesian+'`).
+    #[test]
+    fn operator_functions_complete_only_through_a_qualifier() {
+        // What an item offers from a package: its label, by the
+        // qualified path in its detail.
+        let from = |items: &[serde_json::Value], package: &str| -> Vec<String> {
+            items
+                .iter()
+                .filter(|i| {
+                    i["detail"]
+                        .as_str()
+                        .is_some_and(|d| d.starts_with(&format!("{package}::")))
+                })
+                .filter_map(|i| i["label"].as_str().map(str::to_string))
+                .collect()
+        };
+        for units in [
+            "feature <'%'> percent;",
+            "feature percent; alias '%' for percent;",
+        ] {
+            let mut s = library_server(&format!(
+                "standard library package Ops {{ function '%'; function '+'; function '['; \
+                 function 'not'; predicate '<'; function 'cartesian+'; function sum; \
+                 function times; alias '*' for times; }} \
+                 standard library package Units {{ {units} }}"
+            ));
+
+            let items = completion_in_m(&mut s, "package P {\n    attribute a = \n}\n", 1, 18);
+            assert_eq!(
+                from(&items, "Ops"),
+                ["cartesian+", "sum", "times"],
+                "{units}"
+            );
+            assert_eq!(from(&items, "Units"), ["percent", "%"], "{units}");
+
+            let items = completion_in_m(&mut s, "package P {\n    private import \n}\n", 1, 19);
+            assert_eq!(
+                from(&items, "Ops"),
+                ["cartesian+", "sum", "times"],
+                "{units}"
+            );
+            assert_eq!(from(&items, "Units"), ["percent", "%"], "{units}");
+            assert!(completion_labels(&items).contains(&"Ops"));
+
+            let items = completion_in_m(&mut s, "package P {\n    attribute a = Ops::\n}\n", 1, 23);
+            assert_eq!(
+                completion_labels(&items),
+                ["%", "+", "[", "not", "<", "cartesian+", "sum", "times", "*"]
+            );
+        }
+    }
+
+    /// Workspace symbol search finds declarations: an `import` or
+    /// `expose` member declares nothing and is not listed, while the
+    /// declarations around it and an alias are.
+    #[test]
+    fn workspace_symbols_skip_import_members() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    private import MiniLib::*;\n    \
+                                          alias Part for MiniLib::Widget;\n    \
+                                          view v { expose OtherLib::*; }\n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "workspace/symbol",
+                "params": {"query": ""}}),
+        );
+        let names: Vec<&str> = out[0]["result"]
+            .as_array()
+            .expect("symbols")
+            .iter()
+            .filter_map(|s| s["name"].as_str())
+            .collect();
+        assert_eq!(names, ["P", "Part", "v"]);
+    }
+
+    /// Workspace symbol search finds names: an anonymous member (the
+    /// outline's `«part»`) is not listed, while the named members
+    /// inside it are.
+    #[test]
+    fn workspace_symbols_skip_anonymous_members() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/m.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package P {\n    part def V {\n        part : V {\n            \
+                                          attribute inner;\n        }\n    }\n}\n"}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "workspace/symbol",
+                "params": {"query": ""}}),
+        );
+        let names: Vec<&str> = out[0]["result"]
+            .as_array()
+            .expect("symbols")
+            .iter()
+            .filter_map(|s| s["name"].as_str())
+            .collect();
+        assert_eq!(names, ["P", "V", "inner"]);
+    }
+
+    /// Keywords are the only keyword-kind items: metadata definitions
+    /// and usages complete with a kind of their own.
+    #[test]
+    fn only_keywords_complete_as_keywords() {
+        let mut s = two_package_server();
+        let text = "package P {\n    metadata def Safety;\n    part w { metadata tag : Safety; }\n    \n}\n";
+        // A type position offers the definition, an expression beside
+        // the usage the usage and the literal keywords.
+        let mut items = completion_in_m(&mut s, &text.replace("    \n}", "    ref x : \n}"), 3, 12);
+        items.extend(completion_in_m(
+            &mut s,
+            &text.replace("Safety; }", "Safety;\n        attribute y = \n    }"),
+            3,
+            22,
+        ));
+        let keyword = serde_json::json!(lsp_types::CompletionItemKind::KEYWORD);
+        let not_keywords: Vec<&str> = items
+            .iter()
+            .filter(|i| i["kind"] == keyword)
+            .filter_map(|i| i["label"].as_str())
+            .filter(|l| !crate::tokens::VOCABULARY.contains(l))
+            .collect();
+        assert!(
+            not_keywords.is_empty(),
+            "names with the keyword kind: {not_keywords:?}"
+        );
+        let reference = serde_json::json!(lsp_types::CompletionItemKind::REFERENCE);
+        for name in ["Safety", "tag"] {
+            let item = items
+                .iter()
+                .find(|i| i["label"] == name)
+                .unwrap_or_else(|| panic!("{name} offered"));
+            assert_eq!(item["kind"], reference, "{item}");
+        }
+    }
+
+    /// The workspace's own operator functions are held to the same
+    /// rule as the library's: out of the flat list, listed after a
+    /// qualifier.
+    #[test]
+    fn workspace_operator_functions_complete_only_through_a_qualifier() {
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/ops.kerml", "languageId": "kerml",
+                                 "version": 1,
+                                 "text": "package WOps { function '+'; function plus; }"}}}),
+        );
+        let items = completion_in_m(&mut s, "package P {\n    attribute a = \n}\n", 1, 18);
+        let labels = completion_labels(&items);
+        assert!(
+            labels.contains(&"plus") && !labels.contains(&"+"),
+            "{labels:?}"
+        );
+        let items = completion_in_m(&mut s, "package P {\n    attribute a = WOps::\n}\n", 1, 24);
+        assert_eq!(completion_labels(&items), ["+", "plus"]);
+    }
+
+    /// The completion items a fresh [`two_package_server`] answers at
+    /// the `|` in `marked`, opened (marker removed) as a `.sysml`
+    /// document.
+    fn complete_at(marked: &str) -> Vec<serde_json::Value> {
+        complete_in("file:///w/m.sysml", marked)
+    }
+
+    /// [`complete_at`] for a document opened under `uri`.
+    fn complete_in(uri: &str, marked: &str) -> Vec<serde_json::Value> {
+        let at = marked.find('|').expect("cursor marker");
+        let text = marked.replacen('|', "", 1);
+        let line = marked[..at].matches('\n').count();
+        let character = at - marked[..at].rfind('\n').map_or(0, |i| i + 1);
+        let mut s = two_package_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": uri, "languageId": "sysml",
+                                 "version": 1, "text": text}}}),
+        );
+        let out = responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": uri},
+                           "position": {"line": line, "character": character}}}),
+        );
+        out[0]["result"]
+            .as_array()
+            .expect("completion items")
+            .clone()
+    }
+
+    /// Inside a comment, a note, a documentation body, or a string
+    /// literal nothing is offered — not even when a trigger character
+    /// (`.`, `:`) opened the request — while a quoted name being typed
+    /// completes as any name does.
+    #[test]
+    fn no_completions_in_comments_or_strings() {
+        for marked in [
+            "package P {\n    part def V {\n        doc /* A vehicle part.| */\n    }\n}\n",
+            "package P {\n    // TODO:|\n}\n",
+            "package P {\n    //* see Widget.| */\n}\n",
+            "package P {\n    comment about P /* see MiniLib::| */\n}\n",
+            "package P {\n    attribute s = \"v1.|\";\n}\n",
+        ] {
+            assert_eq!(
+                complete_at(marked),
+                Vec::<serde_json::Value>::new(),
+                "{marked:?}"
+            );
+        }
+        for marked in [
+            "package P {\n    ref w : 'Widg|';\n}\n",
+            "package P {\n    /* done */ ref w : Widg|\n}\n",
+        ] {
+            let items = complete_at(marked);
+            assert!(completion_labels(&items).contains(&"Widget"), "{marked:?}");
+        }
+    }
+
+    /// A number's decimal point or exponent and a range bound are no
+    /// place for a name: nothing is offered there.
+    #[test]
+    fn no_completions_in_numbers_or_range_bounds() {
+        for marked in [
+            "package P {\n    attribute x = 5.|\n}\n",
+            "package P {\n    attribute x = 5.4|\n}\n",
+            "package P {\n    attribute x = 1.5e|\n}\n",
+            "package P {\n    attribute x = 12|\n}\n",
+            "package P {\n    part ws : Widget [0.|\n}\n",
+            "package P {\n    part ws : Widget [0..|\n}\n",
+            "package P {\n    part ws : Widget [1..*|\n}\n",
+        ] {
+            assert_eq!(
+                complete_at(marked),
+                Vec::<serde_json::Value>::new(),
+                "{marked:?}"
+            );
+        }
+        // A bound may name a feature; a product takes any operand.
+        for marked in [
+            "package P {\n    attribute count;\n    part ws : Widget [0..cou|\n}\n",
+            "package P {\n    attribute count;\n    attribute x = 2 * cou|\n}\n",
+        ] {
+            let items = complete_at(marked);
+            assert!(completion_labels(&items).contains(&"count"), "{marked:?}");
+        }
+    }
+
+    /// Where the word being typed is a name the statement declares, no
+    /// element's name is offered — accepting one would replace the new
+    /// name — only the keywords that may stand there instead. Positions
+    /// that take references keep their names.
+    #[test]
+    fn declared_names_are_offered_no_element_names() {
+        for (marked, keywords) in [
+            ("package P {\n    abstract part def Widg|\n}\n", vec![]),
+            ("package P {\n    part Widg|\n}\n", vec!["def", "redefines"]),
+            ("package P {\n    part def <Widg|\n}\n", vec![]),
+            (
+                "package P {\n    action def A {\n        in item Widg|\n    }\n}\n",
+                vec!["redefines"],
+            ),
+            (
+                "package P {\n    enum def E {\n        Widg|\n    }\n}\n",
+                vec![
+                    "comment",
+                    "doc",
+                    "enum",
+                    "language",
+                    "locale",
+                    "metadata",
+                    "private",
+                    "protected",
+                    "public",
+                    "rep",
+                ],
+            ),
+        ] {
+            let items = complete_at(marked);
+            assert_eq!(completion_labels(&items), keywords, "{marked:?}");
+            assert!(items.iter().all(|i| i["kind"] == 14), "keywords: {items:?}");
+        }
+        for (marked, name) in [
+            (
+                "package P {\n    action widgetAction;\n    perform widg|\n}\n",
+                "widgetAction",
+            ),
+            ("package P {\n    alias A for Widg|\n}\n", "Widget"),
+            (
+                "package P {\n    state widgetState;\n    transition widg|\n}\n",
+                "widgetState",
+            ),
+            ("package P {\n    ref w : Widg|\n}\n", "Widget"),
+        ] {
+            let items = complete_at(marked);
+            assert!(completion_labels(&items).contains(&name), "{marked:?}");
+        }
+
+        // A KerML document reads its own grammar's declarations; a
+        // SysML keyword there is a name like any other.
+        let kerml = "file:///w/m.kerml";
+        let items = complete_in(kerml, "package P {\n    class Widg|\n}\n");
+        assert_eq!(completion_labels(&items), vec!["all"]);
+        for marked in [
+            "package P {\n    feature w : Widg|\n}\n",
+            "package P {\n    part Widg|\n}\n",
+        ] {
+            let items = complete_in(kerml, marked);
+            assert!(completion_labels(&items).contains(&"Widget"), "{marked:?}");
+        }
+    }
+
+    /// A comment above the statement being completed is not part of
+    /// it: a `[` in the comment asks for no `]` on accepting.
+    #[test]
+    fn a_bracket_in_a_comment_above_needs_no_repair() {
+        let items = complete_at("package P {\n    /* note; [draft */\n    ref x : Widg|\n}\n");
+        let widget = items
+            .iter()
+            .find(|i| i["label"] == "Widget")
+            .expect("Widget");
+        assert!(widget["textEdit"].is_null(), "no `]` repair: {widget}");
+    }
+
+    /// An `import` in a note above the statement being completed does
+    /// not make it an import: the name inserts bare, with its import.
+    #[test]
+    fn an_import_in_a_note_above_is_no_import_statement() {
+        let items =
+            complete_at("package P {\n    // import the library below\n    ref w : Widg|\n}\n");
+        let widget = items
+            .iter()
+            .find(|i| i["label"] == "Widget")
+            .expect("Widget");
+        assert!(widget["textEdit"].is_null(), "no import path: {widget}");
+        assert_eq!(
+            widget["additionalTextEdits"][0]["newText"],
+            "private import MiniLib::Widget;\n    "
+        );
+    }
+
+    /// A `;` in a comment above a feature chain does not start the
+    /// statement inside the comment: the text cut out for the semantic
+    /// session is the statement alone, so the chain still resolves.
+    #[test]
+    fn a_terminator_in_a_comment_above_keeps_chains_resolving() {
+        let items = complete_at(
+            "package P {\n    part def Tank { attribute level; }\n    part t : Tank;\n    \
+             /* note; see below */\n    attribute x = t.|\n}\n",
+        );
+        assert_eq!(completion_labels(&items), vec!["level", "metadata"]);
+    }
+
+    /// A model with a definition of every kind the positions below
+    /// take, opened beside the document under test.
+    const VEHICLE_MODEL: &str = "package VehicleModel {\n\
+        \x20   private import ScalarValues::*;\n\
+        \x20   private import ISQ::*;\n\
+        \x20   private import SI::*;\n\
+        \x20   enum def Color { enum red; enum green; }\n\
+        \x20   attribute def Speed :> ISQ::SpeedValue;\n\
+        \x20   item def Fuel;\n\
+        \x20   item def Signal;\n\
+        \x20   port def FuelPort { out item fuel : Fuel; }\n\
+        \x20   interface def FuelInterface { end a : FuelPort; end b : ~FuelPort; }\n\
+        \x20   part def Vehicle { attribute mass : ISQ::MassValue; port fuelIn : ~FuelPort; }\n\
+        \x20   part def Car :> Vehicle;\n\
+        \x20   part def Driver;\n\
+        \x20   action def Drive;\n\
+        \x20   state def VehicleStates { state off; state on; }\n\
+        \x20   calc def KineticEnergy { in m : ISQ::MassValue; }\n\
+        \x20   requirement def MaxMassReq;\n\
+        \x20   metadata def Safety;\n\
+        }\n";
+
+    /// A push server over the standard library with [`VEHICLE_MODEL`] open.
+    fn standard_library_server() -> PushServer {
+        let mut files = Vec::new();
+        sysmlv2_testkit::collect_files(&sysmlv2_testkit::library_dir(), &mut files);
+        let units = files
+            .iter()
+            .map(|f| {
+                let text = std::fs::read_to_string(f).expect("library unit");
+                (f.display().to_string(), text)
+            })
+            .collect();
+        let mut s = PushServer::with_library_sources(units, None);
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/vehicles.sysml", "languageId": "sysml",
+                                 "version": 1, "text": VEHICLE_MODEL}}}),
+        );
+        s
+    }
+
+    /// The labels an editor lists at the `|` in `body` — a member
+    /// position of `part def P` in a package importing the vehicle
+    /// model and the quantities — narrowed to those starting with the
+    /// word typed before the cursor, in the order it lists them:
+    /// `sortText`, then label.
+    fn listed(s: &mut PushServer, uri: &str, body: &str) -> (Vec<String>, Vec<serde_json::Value>) {
+        let header = "package Survey {\n    private import VehicleModel::*;\n    \
+                      private import ISQ::*;\n    private import SI::*;\n    \
+                      private import ScalarValues::*;\n    part def P {\n        ";
+        let marked = format!("{header}{body}\n    }}\n}}\n");
+        let at = marked.find('|').expect("cursor marker");
+        let text = marked.replacen('|', "", 1);
+        let line = marked[..at].matches('\n').count();
+        let character = at - marked[..at].rfind('\n').map_or(0, |i| i + 1);
+        let typed: String = marked[..at]
+            .chars()
+            .rev()
+            .take_while(|c| c.is_alphanumeric() || *c == '_')
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+            .collect();
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": uri, "languageId": "sysml", "version": 1, "text": text}}}),
+        );
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": uri},
+                           "position": {"line": line, "character": character}}}),
+        );
+        let items = out[0]["result"]
+            .as_array()
+            .expect("completion items")
+            .clone();
+        // Closed again: its unfinished statement must not keep the next
+        // document's semantic session from building.
+        responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didClose", "params": {
+                "textDocument": {"uri": uri}}}),
+        );
+        let mut shown: Vec<&serde_json::Value> = items
+            .iter()
+            .filter(|i| {
+                let label = i["label"].as_str().unwrap_or_default().to_lowercase();
+                label.starts_with(&typed.to_lowercase())
+            })
+            .collect();
+        shown.sort_by_key(|i| {
+            (
+                i["sortText"].as_str().unwrap_or_default().to_string(),
+                i["label"].as_str().unwrap_or_default().to_string(),
+            )
+        });
+        let labels = shown
+            .iter()
+            .map(|i| i["label"].as_str().unwrap_or_default().to_string())
+            .collect();
+        (labels, items)
+    }
+
+    /// At a type position the list holds the definitions a usage of the
+    /// statement's kind may be typed by, the best-fitting first — no
+    /// keyword, no unit, no definition of another kind.
+    #[test]
+    fn typing_positions_offer_the_kinds_definitions() {
+        let mut s = standard_library_server();
+        let has =
+            |items: &[serde_json::Value], label: &str| items.iter().any(|i| i["label"] == label);
+        let keywordless = |items: &[serde_json::Value]| items.iter().all(|i| i["kind"] != 14);
+
+        let (shown, items) = listed(&mut s, "file:///w/a.sysml", "attribute x : Rea|");
+        assert!(shown[..3].contains(&"Real".to_string()), "{shown:?}");
+        assert!(keywordless(&items));
+        assert!(has(&items, "MassValue") && has(&items, "Color"));
+        assert!(
+            !has(&items, "kg") && !has(&items, "Vehicle"),
+            "no units, no part definitions"
+        );
+
+        let (shown, items) = listed(&mut s, "file:///w/b.sysml", "part p : Veh|");
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("Vehicle"),
+            "{shown:?}"
+        );
+        assert!(keywordless(&items));
+        assert!(!has(&items, "Speed") && !has(&items, "MassValue") && !has(&items, "kg"));
+
+        let (shown, items) = listed(&mut s, "file:///w/c.sysml", "port p : ~Fu|");
+        assert_eq!(shown, vec!["FuelPort"], "port definitions only");
+        assert!(!has(&items, "Fuel") && !has(&items, "FuelInterface"));
+
+        let (shown, _) = listed(&mut s, "file:///w/d.sysml", "action d : Dr|");
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("Drive"),
+            "{shown:?}"
+        );
+        assert!(
+            !shown.contains(&"Driver".to_string()),
+            "a part definition types no action"
+        );
+    }
+
+    /// After `:>` on a definition: definitions of its kind first, those
+    /// of the kinds it specializes after — no unit, no usage.
+    #[test]
+    fn specialization_offers_the_definitions_kind_first() {
+        let mut s = standard_library_server();
+        let (shown, items) = listed(&mut s, "file:///w/a.sysml", "part def Sedan :> C|");
+        assert!(shown[..3].contains(&"Car".to_string()), "{shown:?}");
+        assert!(
+            items
+                .iter()
+                .all(|i| i["label"] != "kg" && i["label"] != "mass")
+        );
+        let car = shown.iter().position(|l| l == "Car").unwrap();
+        let color = shown.iter().position(|l| l == "Color");
+        assert!(color.is_none(), "an enumeration is no supertype of a part");
+        assert!(car < 3);
+    }
+
+    /// Keywords come from the document's dialect and rank where the
+    /// position needs them: the body's own keywords at a statement's
+    /// start, the declaring keyword after `exhibit`, `true` for a
+    /// Boolean's value.
+    #[test]
+    fn keywords_rank_where_the_position_needs_them() {
+        let mut s = standard_library_server();
+        let (shown, _) = listed(&mut s, "file:///w/a.sysml", "cons|");
+        assert!(
+            shown.contains(&"constant".to_string()) && shown.contains(&"constraint".to_string())
+        );
+        assert!(
+            !shown.contains(&"const".to_string()),
+            "a KerML word: {shown:?}"
+        );
+
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/b.sysml",
+            "state def S {\n            ent|\n        }",
+        );
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("entry"),
+            "{shown:?}"
+        );
+        assert!(!shown.contains(&"enthalpy".to_string()), "{shown:?}");
+
+        let (shown, _) = listed(&mut s, "file:///w/c.sysml", "exhibit st|");
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("state"),
+            "{shown:?}"
+        );
+
+        let (shown, items) = listed(
+            &mut s,
+            "file:///w/d.sysml",
+            "action def A {\n            fo|\n        }",
+        );
+        assert!(
+            matches!(shown.first().map(String::as_str), Some("for" | "fork")),
+            "{shown:?}"
+        );
+        assert!(
+            items.iter().all(|i| i["label"] != "foot"),
+            "no names at an action's statement"
+        );
+
+        let (shown, _) = listed(&mut s, "file:///w/e.sysml", "attribute b : Boolean = t|");
+        assert_eq!(shown.first().map(String::as_str), Some("true"), "{shown:?}");
+
+        let (shown, _) = listed(&mut s, "file:///w/f.sysml", "satisfy Max|");
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("MaxMassReq"),
+            "{shown:?}"
+        );
+    }
+
+    /// Measurement units write quantities' values and other units: in
+    /// an expression they rank after every other name, and first where
+    /// the statement's type is a unit type.
+    #[test]
+    fn units_rank_by_the_declared_type() {
+        let mut s = standard_library_server();
+        let before = |shown: &[String], a: &str, b: &str| {
+            let at = |l: &str| shown.iter().position(|x| x == l);
+            at(a).zip(at(b)).is_some_and(|(a, b)| a < b)
+        };
+        let (shown, _) = listed(&mut s, "file:///w/a.sysml", "attribute f : ForceUnit = m|");
+        assert!(before(&shown, "metre", "mass"), "units first: {shown:?}");
+        // A library quantity against a unit: the workspace's `mass`
+        // would outrank every library name, units or not.
+        let (shown, _) = listed(&mut s, "file:///w/b.sysml", "attribute f : MassValue = m|");
+        assert!(
+            before(&shown, "machNumber", "metre"),
+            "units last: {shown:?}"
+        );
+        let (shown, _) = listed(&mut s, "file:///w/c.sysml", "attribute f = me|");
+        let unit = shown
+            .iter()
+            .position(|l| l == "metre")
+            .expect("metre offered");
+        assert!(
+            shown[unit..].iter().all(|l| !l.starts_with("mean")),
+            "every quantity ahead of the units: {shown:?}"
+        );
+    }
+
+    /// An alias whose target another unit declares ranks, and shows, as
+    /// what it names, which the symbol tables find through the imports
+    /// of the alias's namespace — private ones included — and outward:
+    /// the library's `TimeValue` (an alias of `ISQBase::DurationValue`,
+    /// which `ISQSpaceTime` imports privately) as that attribute
+    /// definition at a type, typed in part too, a model's own `Torque`
+    /// (for `ISQ::TorqueValue`) likewise, and `vmass` (for the vehicle
+    /// model's `Vehicle::mass`) as a feature at a feature and an operand.
+    #[test]
+    fn aliases_of_other_units_elements_rank_as_what_they_name() {
+        let mut s = standard_library_server();
+        let aliases = "alias Torque for ISQ::TorqueValue;\n        \
+                       alias vmass for VehicleModel::Vehicle::mass;\n        ";
+        let item = |items: &[serde_json::Value], label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"))
+                .clone()
+        };
+        let group = |item: &serde_json::Value| {
+            item["sortText"]
+                .as_str()
+                .map(|k| k[..1].to_string())
+                .unwrap_or_default()
+        };
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/a0.sysml",
+            &format!("{aliases}attribute t : |"),
+        );
+        for (alias, target) in [("TimeValue", "DurationValue"), ("Torque", "TorqueValue")] {
+            let (alias, target) = (item(&items, alias), item(&items, target));
+            assert_eq!(alias["kind"], target["kind"], "{alias}");
+            assert_eq!(group(&alias), group(&target), "{alias}");
+            assert_eq!(group(&alias), "1", "{alias}");
+        }
+        // Typed in part, it is listed as the word is typed, ranked so.
+        let (shown, items) = listed(
+            &mut s,
+            "file:///w/a3.sysml",
+            &format!("{aliases}attribute t : TimeV|"),
+        );
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("TimeValue"),
+            "{shown:?}"
+        );
+        assert_eq!(group(&item(&items, "TimeValue")), "1");
+        for (i, body) in ["ref r ::> |", "attribute x = |"].into_iter().enumerate() {
+            let uri = format!("file:///w/a{}.sysml", i + 1);
+            let (_, items) = listed(&mut s, &uri, &format!("{aliases}{body}"));
+            let vmass = item(&items, "vmass");
+            assert_ne!(
+                vmass["kind"],
+                serde_json::json!(lsp_types::CompletionItemKind::MODULE),
+                "{body:?}: {vmass}"
+            );
+            assert_eq!(group(&vmass), "1", "{body:?}: {vmass}");
+        }
+    }
+
+    /// An alias ranks, and shows, as what the one lookup behind both
+    /// finds it naming: a sibling (`Rim` for `Wheel`), an element of an
+    /// enclosing namespace (`Tyre`, in a package of its own, for the
+    /// same `Wheel`), or an element of another unit (`Chauffeur` for the
+    /// vehicle model's `Driver`) — each ranked and shown as that part
+    /// definition, here inside the package holding `Tyre`.
+    #[test]
+    fn aliases_rank_and_show_as_what_they_name() {
+        let mut s = base_library_server();
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/r.sysml",
+            "part def Wheel;\n        alias Rim for Wheel;\n        \
+             alias Chauffeur for VehicleModel::Driver;\n        \
+             package Spares {\n            alias Tyre for Wheel;\n            \
+             part p : |\n        }",
+        );
+        let item = |label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .unwrap_or_else(|| panic!("{label} offered"))
+                .clone()
+        };
+        let group = |item: &serde_json::Value| {
+            item["sortText"]
+                .as_str()
+                .map(|k| k[..2].to_string())
+                .unwrap_or_default()
+        };
+        let wheel = item("Wheel");
+        for alias in ["Rim", "Tyre", "Chauffeur"] {
+            let alias = item(alias);
+            assert_eq!(alias["kind"], wheel["kind"], "{alias}");
+            assert_eq!(group(&alias), group(&wheel), "{alias}");
+        }
+    }
+
+    /// An alias's target is looked for as the notation resolves a name:
+    /// a qualified target through its qualifier, not by its last
+    /// segment (`Defs::Engine` names the part definition, not the usage
+    /// beside the alias that shares its name), and a one-segment target
+    /// outward from the alias (`Motor` in the enclosing package, not an
+    /// attribute of that name declared earlier elsewhere in the unit).
+    #[test]
+    fn aliases_follow_their_target_as_written() {
+        let mut s = base_library_server();
+        for (i, (body, alias)) in [
+            (
+                "package Defs { part def Engine; }\n        package Uses {\n            \
+                 part Engine : Defs::Engine;\n            alias E for Defs::Engine;\n            \
+                 part p : |\n        }",
+                "E",
+            ),
+            (
+                "package A { attribute Motor; }\n        package B {\n            \
+                 part def Motor;\n            package C {\n                \
+                 alias M for Motor;\n                part p : |\n            }\n        }",
+                "M",
+            ),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/t{i}.sysml");
+            let (_, items) = listed(&mut s, &uri, body);
+            let item = items
+                .iter()
+                .find(|it| it["label"] == alias)
+                .unwrap_or_else(|| panic!("{alias} offered: {items:?}"));
+            assert_eq!(
+                item["kind"],
+                serde_json::json!(lsp_types::CompletionItemKind::CLASS),
+                "{item}"
+            );
+            assert!(
+                item["sortText"]
+                    .as_str()
+                    .is_some_and(|k| k.starts_with('1')),
+                "{item}"
+            );
+        }
+    }
+
+    /// A definition qualifies the features it owns (`redefines
+    /// Vehicle::mass`, `= WheelAssy::wheel`): the workspace's
+    /// definitions stay offered where features are named and in
+    /// expressions, after every other name. The library's do not — they
+    /// would double those lists.
+    #[test]
+    fn definitions_qualify_the_features_they_own() {
+        let mut s = base_library_server();
+        for (i, body) in [
+            "attribute m redefines Veh|",
+            "attribute :>> Veh|",
+            "attribute m = Veh|",
+            "attribute ok = mass == Veh|",
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/q{i}.sysml");
+            let (shown, _) = listed(
+                &mut s,
+                &uri,
+                &format!("part def Car2 :> Vehicle {{\n            {body}\n        }}"),
+            );
+            assert!(
+                shown.contains(&"Vehicle".to_string()),
+                "{body:?}: {shown:?}"
+            );
+        }
+        let (shown, _) = listed(&mut s, "file:///w/q9.sysml", "attribute m = Rend|");
+        assert!(shown.is_empty(), "no library definition: {shown:?}");
+    }
+
+    /// A payload is typed by whatever it carries: after `accept` and a
+    /// flow's or a message's `of`, the statement's own kind no longer
+    /// decides the typing.
+    #[test]
+    fn payloads_take_any_definition() {
+        let mut s = base_library_server();
+        for (i, (body, name)) in [
+            ("action trigger accept sig : Sig|", "Signal"),
+            ("message of sig : Sig|", "Signal"),
+            ("flow of fuel : Fu|", "Fuel"),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/p{i}.sysml");
+            let (shown, _) = listed(&mut s, &uri, body);
+            assert!(shown.contains(&name.to_string()), "{body:?}: {shown:?}");
+        }
+    }
+
+    /// A succession steps between occurrences of any kind — parts and
+    /// messages as well as actions and states, the behaviors first —
+    /// and a transition may start from the entry action a state machine
+    /// starts from.
+    #[test]
+    fn successions_name_occurrences_of_any_kind() {
+        let mut s = base_library_server();
+        for (i, (body, name)) in [
+            (
+                "part front;\n        part rear;\n        first fr|",
+                "front",
+            ),
+            (
+                "message m1;\n        message m2;\n        first m1 then m|",
+                "m2",
+            ),
+            (
+                "state def S {\n            entry action initial;\n            \
+                 state off;\n            transition init|\n        }",
+                "initial",
+            ),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/s{i}.sysml");
+            let (shown, _) = listed(&mut s, &uri, body);
+            assert!(shown.contains(&name.to_string()), "{body:?}: {shown:?}");
+        }
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/s9.sysml",
+            "part zone;\n        action zap;\n        first z|",
+        );
+        assert_eq!(shown, ["zap", "zone"], "the behavior first");
+    }
+
+    /// An individual definition specializes the occurrence definition it
+    /// is an individual of, of whatever kind (`individual def Vehicle_1
+    /// :> Vehicle`), and a definition of a user-defined kind (`#Service
+    /// def`) may be of any kind, so every position taking definitions
+    /// takes it.
+    #[test]
+    fn individuals_and_user_kinds_keep_their_supertypes() {
+        let mut s = base_library_server();
+        let service = "metadata def Service;\n        #Service def APIService;\n        ";
+        for (i, (body, name)) in [
+            ("individual def Vehicle_1 :> Veh|", "Vehicle"),
+            ("port def ApiPort :> APIS|", "APIService"),
+            ("attribute a : APIS|", "APIService"),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/i{i}.sysml");
+            let (shown, _) = listed(&mut s, &uri, &format!("{service}{body}"));
+            assert!(shown.contains(&name.to_string()), "{body:?}: {shown:?}");
+        }
+    }
+
+    /// A connector end's multiplicity (`bind [1] a = [1] b`) is no
+    /// operand: a feature follows it. Neither is the function an arrow
+    /// invokes: a function reference may follow it (`->reduce max`).
+    #[test]
+    fn end_multiplicities_and_function_references_take_names() {
+        let mut s = base_library_server();
+        for (i, (body, name)) in [
+            (
+                "part front;\n        part rear;\n        bind [1] front = [1] re|",
+                "rear",
+            ),
+            (
+                "attribute es : Real[*];\n        attribute e = es->reduce Kin|",
+                "KineticEnergy",
+            ),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/m{i}.sysml");
+            let (shown, _) = listed(&mut s, &uri, body);
+            assert!(shown.contains(&name.to_string()), "{body:?}: {shown:?}");
+        }
+    }
+
+    /// KerML's type operators take features, which are types too — a
+    /// feature's operands are features first — and a binding's `of` its
+    /// first end, a feature.
+    #[test]
+    fn type_operators_and_binding_ends_take_features() {
+        let model = "package K {\n    feature links;\n    feature objects;\n    \
+                     feature left;\n    LINE\n}\n";
+        for (line, name) in [
+            ("feature both intersects links, obj|", "objects"),
+            ("feature f unions li|", "links"),
+            ("feature f differences li|", "links"),
+            ("feature f disjoint from li|", "links"),
+            ("binding bnd of le|", "left"),
+            ("classifier C unions li|", "links"),
+        ] {
+            let items = complete_in("file:///w/k.kerml", &model.replace("LINE", line));
+            assert!(
+                items.iter().any(|i| i["label"] == name),
+                "{line:?}: {:?}",
+                completion_labels(&items)
+            );
+        }
+    }
+
+    /// Within a group, shorter names rank first: the word typed is more
+    /// of a short name, which the quantity library's long names sharing
+    /// its first letters would bury alphabetically (`MassValue` after
+    /// `MassAttenuationCoefficientValue` and thirty others).
+    #[test]
+    fn shorter_names_rank_first_within_a_group() {
+        let mut s = standard_library_server();
+        for (i, (body, name)) in [
+            ("attribute x : Mas|", "MassValue"),
+            ("attribute x : Spe|", "SpeedValue"),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let uri = format!("file:///w/r{i}.sysml");
+            let (shown, _) = listed(&mut s, &uri, body);
+            let at = shown.iter().position(|l| l == name);
+            assert!(at.is_some_and(|at| at < 3), "{body:?}: {shown:?}");
+        }
+    }
+
+    /// A push server over a small library holding the base every action
+    /// implicitly specializes and two renderings, with
+    /// [`VEHICLE_MODEL`] open.
+    fn base_library_server() -> PushServer {
+        let mut s = PushServer::with_library_sources(
+            vec![(
+                "Bases.sysml".to_string(),
+                "standard library package Actions {\n\
+                 \x20   abstract action def Action {\n\
+                 \x20       action start;\n\
+                 \x20       action done;\n\
+                 \x20       abstract action subactions[0..*];\n\
+                 \x20   }\n\
+                 }\n\
+                 standard library package Views {\n\
+                 \x20   abstract rendering def Rendering;\n\
+                 \x20   rendering asTreeDiagram : Rendering;\n\
+                 \x20   rendering asElementTable : Rendering;\n\
+                 }\n"
+                .to_string(),
+            )],
+            None,
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+        );
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/vehicles.sysml", "languageId": "sysml",
+                                 "version": 1, "text": VEHICLE_MODEL}}}),
+        );
+        s
+    }
+
+    /// While a quoted name is being typed at an operand, the units only
+    /// a quoted name writes are offered: a derived unit's definition
+    /// names them so (`Btu_IT/'°F'`, `referenceUnit = 'm⋅s⁻²'`).
+    #[test]
+    fn a_quoted_operand_offers_the_units_spelled_apart() {
+        let mut s = standard_library_server();
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/h.sysml",
+            "attribute c : ThermalResistanceUnit = s/'°|",
+        );
+        for spelled in ["°F", "°C"] {
+            assert!(items.iter().any(|i| i["label"] == spelled), "{spelled}");
+        }
+    }
+
+    /// An expression's operand outside a unit bracket offers no unit only
+    /// a quoted name writes (`m/s`, `m²/(V⋅s)`): a `)` typed after an
+    /// argument (`KineticEnergy(m, v)`) would match its symbol and leave
+    /// it the one item Enter accepts. Units spelled as plain names stay,
+    /// and a unit bracket still offers every unit.
+    #[test]
+    fn operands_offer_no_unit_spelled_apart() {
+        let mut s = standard_library_server();
+        let has = |items: &[serde_json::Value], label: &str| {
+            let quoted = format!("'{label}'");
+            items
+                .iter()
+                .any(|i| i["label"] == label || i["label"] == quoted.as_str())
+        };
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/f.sysml",
+            "attribute ke = KineticEnergy(1, v|",
+        );
+        for spelled in ["m/s", "m²/(V⋅s)", "m²"] {
+            assert!(!has(&items, spelled), "{spelled}");
+        }
+        for plain in ["kg", "N"] {
+            assert!(has(&items, plain), "{plain}");
+        }
+        let (_, items) = listed(&mut s, "file:///w/g.sysml", "attribute a = 9.8 [m|");
+        assert!(has(&items, "m/s"));
+    }
+
+    /// A qualified name's position is read off the text ahead of it, so
+    /// the namespace's members rank as that position ranks names: a
+    /// typing puts definitions first (`attribute x : ISQ::` puts
+    /// `MassValue` among the first, the quantity features after every
+    /// definition), a specialization its kinds, an import anything alike;
+    /// in a unit bracket (`[SI::`) only units, the declared quantity's
+    /// first — at `[SI::k` a mass takes `kg` ahead of kelvin's `K`, which
+    /// gives up its whole match.
+    #[test]
+    fn a_qualified_position_takes_what_the_position_does() {
+        let mut s = standard_library_server();
+        let (shown, items) = listed(&mut s, "file:///w/a.sysml", "attribute x : ISQ::|");
+        let has =
+            |items: &[serde_json::Value], label: &str| items.iter().any(|i| i["label"] == label);
+        assert!(
+            shown.iter().take(10).any(|l| l == "MassValue"),
+            "{:?}",
+            &shown[..shown.len().min(10)]
+        );
+        let key = |items: &[serde_json::Value], label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .and_then(|i| i["sortText"].as_str().map(str::to_string))
+                .unwrap_or_else(|| panic!("{label} offered"))
+        };
+        assert!(key(&items, "mass") > key(&items, "AbsoluteActivityValue"));
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/b.sysml",
+            "part def Car3 :> VehicleModel::|",
+        );
+        assert!(key(&items, "Vehicle") < key(&items, "Speed"));
+        let (_, items) = listed(&mut s, "file:///w/c.sysml", "private import ISQ::Mas|");
+        assert!(has(&items, "MassValue") && has(&items, "mass"));
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/d.sysml",
+            "attribute m : MassValue = 5 [SI::|",
+        );
+        assert!(has(&items, "kg") && has(&items, "g"));
+        assert!(!has(&items, "MassValue") && !has(&items, "mass"));
+        let (shown, items) = listed(
+            &mut s,
+            "file:///w/e.sysml",
+            "attribute m : MassValue = 5 [SI::k|",
+        );
+        assert_eq!(shown.first().map(String::as_str), Some("kg"), "{shown:?}");
+        let kelvin = items.iter().find(|i| i["label"] == "K").expect("K");
+        assert_eq!(kelvin["filterText"], "K_kelvin");
+    }
+
+    /// After a qualifier the namespace's members rank as names do
+    /// anywhere else, shorter labels first within a group: `ISQ::Mas`
+    /// puts `MassValue` ahead of the longer `Mass…` names.
+    #[test]
+    fn qualified_members_rank_shorter_labels_first() {
+        let mut s = standard_library_server();
+        let (shown, _) = listed(&mut s, "file:///w/q.sysml", "attribute x : ISQ::Mas|");
+        // As an editor matches the word typed, the case of its letters too.
+        let shown: Vec<&String> = shown.iter().filter(|l| l.starts_with("Mas")).collect();
+        let at = shown.iter().position(|l| *l == "MassValue");
+        assert!(
+            at.is_some_and(|i| i < 2),
+            "{:?}",
+            &shown[..shown.len().min(6)]
+        );
+    }
+
+    /// Below the best group only a label of one or two characters, which
+    /// a letter or two typed matches whole by chance, gives up that
+    /// match: a longer name typed whole still comes first, ahead of the
+    /// members it begins (`mass` at `attribute m :> mass`).
+    #[test]
+    fn a_longer_name_typed_whole_keeps_its_match() {
+        let mut s = standard_library_server();
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/e.sysml",
+            "part def Engine {\n            attribute m :> mas|\n        }",
+        );
+        let mass = items.iter().find(|i| i["label"] == "mass").expect("mass");
+        assert!(mass["filterText"].is_null(), "{mass}");
+    }
+
+    /// An editor ranks a label the typed word matches whole ahead of
+    /// every other, whatever the server's order: for a label of one or
+    /// two characters only the best group a list holds keeps that. At a
+    /// member position a name that is no member is filtered by its label
+    /// and more (`m` by `m_m`), and in a quantity's unit bracket a unit of
+    /// another quantity by its symbol and name (`K` by `K_kelvin` for a
+    /// mass): `m` ranks `mass` first, `k` `kg`. Where no group comes
+    /// first, nothing is held back.
+    #[test]
+    fn only_the_best_group_keeps_the_whole_match() {
+        let mut s = standard_library_server();
+        let filter = |items: &[serde_json::Value], label: &str| {
+            items
+                .iter()
+                .find(|i| i["label"] == label)
+                .map(|i| i["filterText"].clone())
+        };
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/a.sysml",
+            "part def Car2 :> Vehicle {\n            attribute :>> m|\n        }",
+        );
+        // The library's unit `m`, a name no member of `Car2` has.
+        assert_eq!(filter(&items, "m"), Some(serde_json::json!("m_metre")));
+        assert_eq!(filter(&items, "mass"), Some(serde_json::Value::Null));
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/b.sysml",
+            "attribute m : MassValue = 5 [k|",
+        );
+        assert_eq!(filter(&items, "K"), Some(serde_json::json!("K_kelvin")));
+        assert_eq!(filter(&items, "kg"), Some(serde_json::Value::Null));
+        for (uri, body) in [
+            ("file:///w/c.sysml", "attribute x = m|"),
+            ("file:///w/d.sysml", "attribute y = 5 [K|"),
+        ] {
+            let (_, items) = listed(&mut s, uri, body);
+            for label in ["m", "K"] {
+                if let Some(f) = filter(&items, label) {
+                    assert_eq!(f, serde_json::Value::Null, "{body}: {label}");
+                }
+            }
+        }
+    }
+
+    /// A redefinition names the features the enclosing element
+    /// inherits, and a succession the features in scope there — those
+    /// the library base of its kind contributes too (`start` and `done`
+    /// of every action) — ahead of every other name.
+    #[test]
+    fn inherited_features_come_first() {
+        let mut s = base_library_server();
+        // A workspace attribute that sorts ahead but is not inherited.
+        let garage = "part def Garage { attribute maintenanceCost; }\n        ";
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/a.sysml",
+            &format!(
+                "{garage}part def Car2 :> Vehicle {{\n            attribute :>> m|\n        }}"
+            ),
+        );
+        assert_eq!(shown.first().map(String::as_str), Some("mass"), "{shown:?}");
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/b.sysml",
+            "part def Car2 :> Vehicle {\n            port :>> |\n        }",
+        );
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("fuelIn"),
+            "{shown:?}"
+        );
+        // Through a typing as well as a specialization.
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/c.sysml",
+            &format!(
+                "{garage}part v2 : Vehicle {{\n            attribute redefines m|\n        }}"
+            ),
+        );
+        assert_eq!(shown.first().map(String::as_str), Some("mass"), "{shown:?}");
+
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/d.sysml",
+            "action def A {\n            action a1 : Drive;\n            first st|\n        }",
+        );
+        assert_eq!(
+            shown.first().map(String::as_str),
+            Some("start"),
+            "{shown:?}"
+        );
+        // The action's own succession targets first, then the ones it
+        // inherits, then everything else.
+        let (shown, items) = listed(
+            &mut s,
+            "file:///w/e.sysml",
+            "action def A {\n            action a1 : Drive;\n            then |\n        }",
+        );
+        let names: Vec<&str> = shown.iter().map(String::as_str).take(4).collect();
+        assert_eq!(names, ["a1", "done", "start", "subactions"], "{shown:?}");
+        let start = items.iter().find(|i| i["label"] == "start").expect("start");
+        assert!(
+            start.get("additionalTextEdits").is_none(),
+            "a name in scope needs no import: {start}"
+        );
+    }
+
+    /// A syntax error in another document leaves the inherited members
+    /// on: the completion session salvages around it.
+    #[test]
+    fn inherited_features_survive_a_syntax_error_elsewhere() {
+        let mut s = base_library_server();
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": "file:///w/broken.sysml", "languageId": "sysml",
+                                 "version": 1,
+                                 "text": "package B {\n    part def Broken {\n        attribute x = ;\n"}}}),
+        );
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/a.sysml",
+            "part def Car2 :> Vehicle {\n            attribute :>> m|\n        }",
+        );
+        assert_eq!(shown.first().map(String::as_str), Some("mass"), "{shown:?}");
+    }
+
+    /// An unreadable member elsewhere in the same document — a value
+    /// left out before its `;`, a group left open at the end of a line —
+    /// leaves the inherited members on too: salvage blanks that member
+    /// alone, and the document stays in the model.
+    #[test]
+    fn inherited_features_survive_an_unreadable_member_in_the_document() {
+        let mut s = base_library_server();
+        for (i, broken) in ["part z { attribute = ; }", "attribute q = (1 + ;"]
+            .into_iter()
+            .enumerate()
+        {
+            for (j, (above, below)) in [(broken, ""), ("", broken)].into_iter().enumerate() {
+                let (shown, _) = listed(
+                    &mut s,
+                    &format!("file:///w/r{i}{j}.sysml"),
+                    &format!(
+                        "{above}\n        part def Car2 :> Vehicle {{\n            \
+                         attribute :>> m|\n        }}\n        {below}"
+                    ),
+                );
+                assert_eq!(shown.first().map(String::as_str), Some("mass"), "{broken}");
+                let (shown, _) = listed(
+                    &mut s,
+                    &format!("file:///w/s{i}{j}.sysml"),
+                    &format!(
+                        "{above}\n        action def A {{\n            action a1 : Drive;\n            \
+                         first st|\n        }}\n        {below}"
+                    ),
+                );
+                assert_eq!(shown.first().map(String::as_str), Some("start"), "{broken}");
+            }
+        }
+    }
+
+    /// Moving on to the next statement of the same body builds no
+    /// session: what the enclosing element inherits was named for the
+    /// last one, and the text outside its body has not changed. A
+    /// statement in the body of an element new around it — an anonymous
+    /// metadata usage, whose members are its metadata definition's —
+    /// builds once, and the next statement there builds none.
+    #[test]
+    fn the_next_statement_builds_no_session() {
+        let mut s = base_library_server();
+        let uri = "file:///w/n.sysml";
+        let text = |body: &str| {
+            format!(
+                "package N {{\n    private import VehicleModel::*;\n    \
+                 metadata def Rating {{ attribute critical; attribute level; }}\n    \
+                 part def Car2 :> Vehicle {{\n        {body}\n    }}\n}}\n"
+            )
+        };
+        let builds = || crate::nav::SESSION_BUILDS.with(std::cell::Cell::get);
+        put(&mut s, uri, 1, &text("attribute :>> m"));
+        assert!(is_member(&mut s, uri, 4, 23, "mass"));
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        for (version, body, line, character, label, built) in [
+            (
+                2,
+                "attribute :>> mass;\n        port :>> ",
+                5,
+                17,
+                "fuelIn",
+                0,
+            ),
+            (
+                3,
+                "attribute :>> mass;\n        @Rating { crit }",
+                5,
+                22,
+                "critical",
+                1,
+            ),
+            (
+                4,
+                "attribute :>> mass;\n        @Rating { critical; lev }",
+                5,
+                31,
+                "level",
+                1,
+            ),
+        ] {
+            put(&mut s, uri, version, &text(body));
+            assert!(is_member(&mut s, uri, line, character, label), "{body:?}");
+            assert_eq!(builds(), built, "{body:?}");
+        }
+    }
+
+    /// A metadata usage's body names the features of its metadata
+    /// definition, ahead of every other name: the usage inherits none of
+    /// its own.
+    #[test]
+    fn metadata_bodies_name_their_definitions_features() {
+        for (i, statement) in ["@Rating { crit| }", "metadata Rating { ref crit| }"]
+            .into_iter()
+            .enumerate()
+        {
+            let mut s = base_library_server();
+            let (_, items) = listed(
+                &mut s,
+                &format!("file:///w/m{i}.sysml"),
+                &format!(
+                    "metadata def Rating {{ attribute critical; attribute level; }}\n        \
+                     part x {{\n            {statement}\n        }}"
+                ),
+            );
+            let critical = items
+                .iter()
+                .find(|i| i["label"] == "critical")
+                .unwrap_or_else(|| panic!("critical offered: {statement}"));
+            assert!(
+                critical["sortText"]
+                    .as_str()
+                    .is_some_and(|k| k.starts_with("00")),
+                "{statement}: {critical}"
+            );
+        }
+    }
+
+    /// In a KerML behavior a succession names its steps — its own and
+    /// those it inherits — ahead of every other name.
+    #[test]
+    fn kerml_successions_name_the_behaviors_steps() {
+        for (marked, steps) in [
+            (
+                "package K {\n    behavior B {\n        step s1;\n        step s2;\n        \
+                 succession first s|\n    }\n}\n",
+                &["s1", "s2"][..],
+            ),
+            (
+                "package K {\n    behavior A {\n        step a1;\n    }\n    \
+                 behavior B specializes A {\n        succession first a|\n    }\n}\n",
+                &["a1"],
+            ),
+        ] {
+            let items = complete_in("file:///w/k.kerml", marked);
+            for step in steps {
+                let item = items
+                    .iter()
+                    .find(|i| i["label"] == *step)
+                    .unwrap_or_else(|| panic!("{step} offered: {items:?}"));
+                assert!(
+                    item["sortText"]
+                        .as_str()
+                        .is_some_and(|k| k.starts_with("00")),
+                    "{step}: {item}"
+                );
+            }
+        }
+    }
+
+    /// A completion session that fails to build is not built again for
+    /// the same sources: the next keystroke in the statement tries none.
+    #[test]
+    fn a_failed_completion_session_is_not_rebuilt() {
+        // A library that cannot be read fails every build.
+        let mut s = PushServer::new_with(Some(sysmlv2_transform::Library::dir(
+            "/nonexistent/sysml.library",
+        )));
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+        );
+        let uri = "file:///w/f.sysml";
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": uri, "languageId": "sysml", "version": 1,
+                                 "text": "package F {\n    part def V { attribute m; }\n    \
+                                          part def W :> V {\n        attribute :>> \n    }\n}\n"}}}),
+        );
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        for _ in 0..2 {
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": 3, "character": 22}}}),
+            );
+        }
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 1);
+    }
+
+    /// A member the symbol tables hold too carries their documentation
+    /// and their kind, as the same name offered from them would: an
+    /// attribute shows as the tables' property, not as the field its
+    /// metaclass would make it.
+    #[test]
+    fn members_carry_their_documentation() {
+        let mut s = base_library_server();
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/d.sysml",
+            "part def Base {\n            attribute weight { doc /* How heavy it is. */ }\n        }\n        \
+             part def Car3 :> Base {\n            attribute :>> w|\n        }",
+        );
+        let weight = items
+            .iter()
+            .find(|i| i["label"] == "weight")
+            .expect("weight offered");
+        assert!(
+            weight["sortText"]
+                .as_str()
+                .is_some_and(|k| k.starts_with("00")),
+            "{weight}"
+        );
+        assert!(
+            weight["documentation"]["value"]
+                .as_str()
+                .is_some_and(|d| d.contains("How heavy it is.")),
+            "{weight}"
+        );
+        assert_eq!(
+            weight["kind"],
+            serde_json::json!(lsp_types::CompletionItemKind::PROPERTY),
+            "{weight}"
+        );
+    }
+
+    /// Open or change `uri` to `text` on `s` at `version`.
+    fn put(s: &mut PushServer, uri: &str, version: i32, text: &str) {
+        let msg = if version == 1 {
+            serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                "textDocument": {"uri": uri, "languageId": "sysml", "version": 1, "text": text}}})
+        } else {
+            serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didChange", "params": {
+                "textDocument": {"uri": uri, "version": version},
+                "contentChanges": [{"text": text}]}})
+        };
+        responses(s, &msg);
+    }
+
+    /// The sort text of the item labeled `label` a completion at
+    /// `line`/`character` of `uri` offers, if any.
+    fn sort_key(
+        s: &mut PushServer,
+        uri: &str,
+        line: u32,
+        character: u32,
+        label: &str,
+    ) -> Option<String> {
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": uri},
+                           "position": {"line": line, "character": character}}}),
+        );
+        out[0]["result"]
+            .as_array()
+            .expect("items")
+            .iter()
+            .find(|i| i["label"] == label)
+            .and_then(|i| i["sortText"].as_str())
+            .map(str::to_string)
+    }
+
+    /// Statements inside a redefinition without a name of its own
+    /// (`part :>> engine { … }`) find it in the session built for the
+    /// first of them by the name of the feature it redefines, as the
+    /// model names it: the next builds none, and names the same members.
+    #[test]
+    fn unnamed_redefinitions_are_found_by_what_they_redefine() {
+        let mut s = base_library_server();
+        let uri = "file:///w/e.sysml";
+        let text = |body: &str| {
+            format!(
+                "package E {{\n    part def Engine {{ attribute power; attribute displacement; }}\n    \
+                 part def Car {{ part engine : Engine; }}\n    part def Car4 :> Car {{\n        \
+                 part :>> engine {{\n            {body}\n        }}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, uri, 1, &text("attribute :>> p"));
+        let power = sort_key(&mut s, uri, 5, 27, "power");
+        assert!(
+            power.as_deref().is_some_and(|k| k.starts_with("00")),
+            "{power:?}"
+        );
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        put(
+            &mut s,
+            uri,
+            2,
+            &text("attribute :>> power;\n            attribute :>> d"),
+        );
+        let displacement = sort_key(&mut s, uri, 6, 27, "displacement");
+        assert!(
+            displacement.as_deref().is_some_and(|k| k.starts_with("00")),
+            "{displacement:?}"
+        );
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+    }
+
+    /// A feature inherited through a redefinition without a name of its
+    /// own (`attribute :>> mass = 1500;`) is named as the model names it,
+    /// after the feature it redefines: still an inherited member.
+    #[test]
+    fn members_redefined_without_a_name_stay_members() {
+        let mut s = base_library_server();
+        for (i, body) in [
+            "part def Car3 :> Heavy {\n            attribute :>> m|\n        }",
+            "part c : Heavy {\n            attribute :>> m|\n        }",
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let (_, items) = listed(
+                &mut s,
+                &format!("file:///w/h{i}.sysml"),
+                &format!(
+                    "part def Heavy :> Vehicle {{ attribute :>> mass = 1500; }}\n        {body}"
+                ),
+            );
+            let mass = items
+                .iter()
+                .find(|i| i["label"] == "mass")
+                .unwrap_or_else(|| panic!("mass offered: {body}"));
+            assert!(
+                mass["sortText"]
+                    .as_str()
+                    .is_some_and(|k| k.starts_with("00")),
+                "{body}: {mass}"
+            );
+        }
+    }
+
+    /// A statement no type encloses — at a unit's top level — has no
+    /// enclosing element's members to name: no session is built for it.
+    #[test]
+    fn top_level_statements_build_no_session() {
+        let mut s = base_library_server();
+        let uri = "file:///w/t.sysml";
+        put(
+            &mut s,
+            uri,
+            1,
+            "part def V { attribute m; }\nattribute :>> ",
+        );
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        sort_key(&mut s, uri, 1, 14, "m");
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+    }
+
+    /// Is `label` offered at `line`/`character` of `uri` as an enclosing
+    /// element's member, ahead of every other name?
+    fn is_member(s: &mut PushServer, uri: &str, line: u32, character: u32, label: &str) -> bool {
+        sort_key(s, uri, line, character, label).is_some_and(|k| k.starts_with("00"))
+    }
+
+    /// The members named for an enclosing element are what the text
+    /// outside its body makes of it: a change there — a supertype
+    /// gaining a feature in another document, the element's own
+    /// specialization — names the new ones. Its body is read as the text
+    /// has it: a feature an earlier statement redefines is no longer a
+    /// member, and one declared since is.
+    #[test]
+    fn members_follow_the_text_around_the_body() {
+        let mut s = base_library_server();
+        let (a, b, c) = (
+            "file:///w/a.sysml",
+            "file:///w/b.sysml",
+            "file:///w/c.sysml",
+        );
+        let bases = |extra: &str| {
+            format!(
+                "package A {{\n    part def Base {{ attribute a1; {extra}}}\n    \
+                 part def Base2 {{ attribute b1; }}\n}}\n"
+            )
+        };
+        let d = |header: &str, body: &str| {
+            format!(
+                "package B {{\n    private import A::*;\n    part def D :> {header} {{\n        \
+                 {body}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, a, 1, &bases(""));
+        put(&mut s, b, 1, &d("Base", "attribute :>> "));
+        assert!(is_member(&mut s, b, 3, 22, "a1"));
+        // Another document: the supertype gains a feature.
+        put(&mut s, a, 2, &bases("attribute a2; "));
+        assert!(is_member(&mut s, b, 3, 22, "a2"));
+        // The element's own specialization.
+        put(&mut s, b, 2, &d("Base2", "attribute :>> "));
+        assert!(is_member(&mut s, b, 3, 22, "b1"));
+        assert!(!is_member(&mut s, b, 3, 22, "a1"));
+        // Its body: a feature redefined in an earlier statement.
+        put(
+            &mut s,
+            b,
+            3,
+            &d("Base2", "attribute :>> b1;\n        attribute :>> "),
+        );
+        assert!(!is_member(&mut s, b, 4, 22, "b1"));
+
+        // A feature declared since, where a succession names its own.
+        let act = |body: &str| {
+            format!(
+                "package C {{\n    action def Act {{\n        action a1;\n        {body}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, c, 1, &act("then "));
+        assert!(is_member(&mut s, c, 3, 13, "a1"));
+        put(&mut s, c, 2, &act("action a3;\n        then "));
+        assert!(is_member(&mut s, c, 4, 13, "a3"));
+        assert!(is_member(&mut s, c, 4, 13, "a1"));
+    }
+
+    /// A feature the body redefined — explicitly, or by declaring its name
+    /// — when the members were first read is a member again once no
+    /// statement redefines it: what the element inherits is kept apart
+    /// from its body.
+    #[test]
+    fn members_come_back_when_their_redefinition_goes() {
+        let mut s = base_library_server();
+        let uri = "file:///w/r.sysml";
+        let d = |body: &str| {
+            format!(
+                "package R {{\n    part def Base {{ attribute a1; attribute a2; }}\n    \
+                 part def D :> Base {{\n        {body}\n    }}\n}}\n"
+            )
+        };
+        put(
+            &mut s,
+            uri,
+            1,
+            &d("attribute :>> a1 = 5;\n        attribute :>> "),
+        );
+        assert!(!is_member(&mut s, uri, 4, 22, "a1"));
+        assert!(is_member(&mut s, uri, 4, 22, "a2"));
+        put(&mut s, uri, 2, &d("attribute :>> "));
+        assert!(is_member(&mut s, uri, 3, 22, "a1"));
+        put(&mut s, uri, 3, &d("attribute a1;\n        attribute :>> "));
+        assert!(!is_member(&mut s, uri, 4, 22, "a1"));
+        put(&mut s, uri, 4, &d("attribute :>> "));
+        assert!(is_member(&mut s, uri, 3, 22, "a1"));
+    }
+
+    /// A parameter a body redefines by name stays a member when the
+    /// statement redefining it is the one typed, whichever of the body's
+    /// statements was completed first: cutting that statement out moves
+    /// the parameters after it, which then redefine the one before by
+    /// position.
+    #[test]
+    fn a_parameter_stays_a_member_in_either_order() {
+        let power = "package A {\n    action def ProvidePower { in item pwrCmd; out torque; }\n    \
+                     action providePower : ProvidePower {\n        \
+                     in item fuelCmd redefines pwrCmd;\n        \
+                     out wheelTorque redefines torque;\n    }\n}\n";
+        let mut answers = Vec::new();
+        for torque_first in [false, true] {
+            let mut s = base_library_server();
+            let uri = "file:///w/a.sysml";
+            put(&mut s, uri, 1, power);
+            if torque_first {
+                // Inside `torque`, after `redefines t`.
+                let _ = sort_key(&mut s, uri, 4, 35, "torque");
+            }
+            // Inside `pwrCmd`, after `redefines p`.
+            answers.push(is_member(&mut s, uri, 3, 35, "pwrCmd"));
+        }
+        assert_eq!(answers, [true, true], "pwrCmd first, torque first");
+    }
+
+    /// A `subject` redefines the library's `subj` every case and
+    /// requirement has, and a `return` parameter the `result` every
+    /// calculation has: once the body declares one, neither is a member,
+    /// whichever of its statements was completed first.
+    #[test]
+    fn what_a_subject_or_return_redefines_is_no_member() {
+        let rate = "package K {\n    calc def Rate {\n        in d :> ISQ::length;\n        \
+                    return v :> ISQ::speed;\n    }\n}\n";
+        let mut answers = Vec::new();
+        for return_first in [false, true] {
+            let mut s = standard_library_server();
+            let uri = "file:///w/k.sysml";
+            put(&mut s, uri, 1, rate);
+            if return_first {
+                // After `return v :> I`.
+                let _ = sort_key(&mut s, uri, 3, 21, "ISQ");
+            }
+            // After `in d :> I`: the library's `result`.
+            let key = sort_key(&mut s, uri, 2, 17, "result");
+            answers.push(key.is_some_and(|k| k.starts_with('0')));
+        }
+        assert_eq!(answers, [false, false], "in first, return first");
+        let checked = "package Q {\n    requirement def R {\n        subject v;\n        \
+                       :>> s;\n    }\n}\n";
+        let mut s = standard_library_server();
+        let uri = "file:///w/q.sysml";
+        put(&mut s, uri, 1, checked);
+        // After `:>> s`: the library's `subj`.
+        let key = sort_key(&mut s, uri, 3, 13, "subj");
+        assert!(
+            !key.as_deref().is_some_and(|k| k.starts_with('0')),
+            "{key:?}"
+        );
+    }
+
+    /// What comes back of what a body redefines is only what the
+    /// heritage leaves: not a feature private to the definition, nor one
+    /// the library redefines — an occurrence's `startShot`, which a part
+    /// of no written type reaches through the library bases it
+    /// specializes implicitly, and which none of them has.
+    #[test]
+    fn members_are_only_what_the_heritage_leaves() {
+        let car = "package G {\n    part def V { private attribute secret; attribute mass; }\n    \
+                   part def Car :> V {\n        attribute :>> mass = 1;\n        :>> s;\n    }\n    \
+                   part def Bare {\n        attribute a = 1;\n        :>> s;\n    }\n}\n";
+        let mut s = standard_library_server();
+        let uri = "file:///w/g.sysml";
+        put(&mut s, uri, 1, car);
+        // After `:>> s`, in `Car` and in `Bare`.
+        for (line, name) in [(4, "secret"), (8, "startShot")] {
+            let key = sort_key(&mut s, uri, line, 13, name);
+            assert!(
+                !key.as_deref().is_some_and(|k| k.starts_with('0')),
+                "{name}: {key:?}"
+            );
+            let key = sort_key(&mut s, uri, line, 13, "self");
+            assert!(
+                key.as_deref().is_some_and(|k| k.starts_with('0')),
+                "self: {key:?}"
+            );
+        }
+    }
+
+    /// The members named in the body of an unnamed redefinition typed by
+    /// a library type (`attribute :>> transformation :
+    /// TranslationRotationSequence { … }`) do not depend on which of its
+    /// statements was completed first: its second statement is offered
+    /// the `elements` it inherits either way.
+    #[test]
+    fn members_of_an_unnamed_redefinition_do_not_depend_on_order() {
+        let unnamed = "package G {\n    private import MeasurementReferences::*;\n    \
+                       attribute cf : CoordinateFrame {\n        \
+                       attribute :>> transformation : TranslationRotationSequence {\n            \
+                       attribute :>> source = x;\n            attribute :>> elements = y;\n        \
+                       }\n    }\n}\n";
+        for source_first in [false, true] {
+            let mut s = standard_library_server();
+            let uri = "file:///w/g.sysml";
+            put(&mut s, uri, 1, unnamed);
+            if source_first {
+                // Inside `source`, after `attribute :>> so`.
+                let _ = sort_key(&mut s, uri, 4, 28, "source");
+            }
+            // Inside `elements`, after `attribute :>> el`.
+            // A member the library declares: group 0, from the library.
+            let key = sort_key(&mut s, uri, 5, 28, "elements");
+            assert!(
+                key.as_deref().is_some_and(|k| k.starts_with('0')),
+                "source first: {source_first}: {key:?}"
+            );
+        }
+    }
+
+    /// A feature a body redefines without inheriting it (`part :>>
+    /// part2;` in an untyped part) is no member of that body, whichever
+    /// of its statements was completed first.
+    #[test]
+    fn redefined_but_not_inherited_is_no_member_in_either_order() {
+        let variant = "package V {\n    part part2;\n    part part3;\n    part s2 {\n        \
+                       part :>> part2;\n        part :>> part3;\n    }\n}\n";
+        let mut answers = Vec::new();
+        for part3_first in [false, true] {
+            let mut s = base_library_server();
+            let uri = "file:///w/v.sysml";
+            put(&mut s, uri, 1, variant);
+            if part3_first {
+                // Inside `part3`, after `part :>> p`.
+                let _ = sort_key(&mut s, uri, 5, 18, "part3");
+            }
+            // Inside `part2`, after `part :>> p`.
+            answers.push(is_member(&mut s, uri, 4, 18, "part2"));
+        }
+        assert_eq!(answers, [false, false], "part2 first, part3 first");
+    }
+
+    /// A `ref` names no kind: redefining in an action's body, it is
+    /// offered the members of every kind, whichever of the body's
+    /// statements was completed first (`ref :>> st` takes the `start`
+    /// action every action has).
+    #[test]
+    fn a_ref_redefines_members_of_any_kind() {
+        let go = "package R {\n    action def Go {\n        ref :>> st;\n        \
+                  ref :>> do;\n    }\n}\n";
+        for done_first in [false, true] {
+            let mut s = base_library_server();
+            let uri = "file:///w/r.sysml";
+            put(&mut s, uri, 1, go);
+            if done_first {
+                // Inside `done`, after `ref :>> do`.
+                let _ = sort_key(&mut s, uri, 3, 18, "done");
+            }
+            // Inside `start`, after `ref :>> st`. A member the library
+            // declares: group 0, from the library.
+            let key = sort_key(&mut s, uri, 2, 18, "start");
+            assert!(
+                key.as_deref().is_some_and(|k| k.starts_with('0')),
+                "done first: {done_first}: {key:?}"
+            );
+        }
+    }
+
+    /// A kind keyword names the members of its own kind and of every
+    /// kind specializing it: a part usage is an item usage, so an
+    /// individual item redefining in an individual definition is offered
+    /// the part its definition inherits, after the item — and no
+    /// attribute, which is no item.
+    #[test]
+    fn a_redefinition_names_members_of_the_kinds_under_its_own() {
+        let text = "package N {\n    item def I {\n        part i : I;\n        \
+                    item j;\n        attribute a;\n    }\n    \
+                    individual item def II2 :> I {\n        individual item :>> ;\n    \
+                    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/n.sysml";
+        put(&mut s, uri, 1, text);
+        // After `individual item :>> `: both members, the item first.
+        let i = sort_key(&mut s, uri, 7, 28, "i").expect("i");
+        let j = sort_key(&mut s, uri, 7, 28, "j").expect("j");
+        assert!(
+            j.starts_with("00") && i.starts_with('0') && j < i,
+            "{j} {i}"
+        );
+        assert!(!is_member(&mut s, uri, 7, 28, "a"));
+    }
+
+    /// At a feature position the kind the statement declares comes
+    /// first and the kinds specializing it after, among the enclosing
+    /// element's members and among every other name alike — an item
+    /// subsetting names the items in scope before the parts, then the
+    /// workspace's other items before its other parts — and every
+    /// occurrence alike after an individual, a snapshot or a time slice
+    /// naming no kind of its own.
+    #[test]
+    fn a_feature_position_names_its_own_kind_first() {
+        let text = "package T {\n    part hub;\n    item cap;\n    item def Box {\n        \
+                    part rim;\n        item lid;\n        occurrence tic;\n    }\n    \
+                    item def Crate :> Box {\n        item :> ;\n        snapshot s :> ;\n    \
+                    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/t.sysml";
+        put(&mut s, uri, 1, text);
+        // After `item :> `.
+        let keys: Vec<String> = ["lid", "rim", "cap", "hub"]
+            .iter()
+            .map(|label| sort_key(&mut s, uri, 9, 16, label).expect(label))
+            .collect();
+        assert!(keys.windows(2).all(|w| w[0] < w[1]), "{keys:?}");
+        // After `snapshot s :> `.
+        let tic = sort_key(&mut s, uri, 10, 22, "tic");
+        let rim = sort_key(&mut s, uri, 10, 22, "rim");
+        assert!(tic.is_some() && tic == rim, "{tic:?} {rim:?}");
+    }
+
+    /// A compound keyword declares the more specific kind it spells: a
+    /// `perform action` redefining names the actions performed ahead of
+    /// the plain ones, which it may still redefine.
+    #[test]
+    fn a_performed_action_redefines_the_performed_ones_first() {
+        let text = "package F {\n    part def Base {\n        action pick;\n        \
+                    perform action push;\n    }\n    part def Kid :> Base {\n        \
+                    perform action :>> ;\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/f.sysml";
+        put(&mut s, uri, 1, text);
+        // After `perform action :>> `: both members, the performed first.
+        let push = sort_key(&mut s, uri, 6, 27, "push").expect("push");
+        let pick = sort_key(&mut s, uri, 6, 27, "pick").expect("pick");
+        assert!(
+            push.starts_with('0') && pick.starts_with('0') && push < pick,
+            "{push} {pick}"
+        );
+    }
+
+    /// A subsetting ranks its kind word's own kind first, more general
+    /// than a compound keyword declares: an included use case subsets a
+    /// plain one ahead of the included ones, which it redefines first.
+    #[test]
+    fn an_included_use_case_subsets_the_plain_ones_first() {
+        let text = "package U {\n    use case def Ride {\n        use case board;\n        \
+                    include use case alight_a;\n        include use case board_a :> ;\n        \
+                    include use case :>> ;\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/u.sysml";
+        put(&mut s, uri, 1, text);
+        // After `include use case board_a :> `.
+        let board = sort_key(&mut s, uri, 4, 36, "board").expect("board");
+        let alight = sort_key(&mut s, uri, 4, 36, "alight_a").expect("alight_a");
+        assert!(board < alight, "{board} {alight}");
+        // After `include use case :>> `.
+        let board = sort_key(&mut s, uri, 5, 29, "board").expect("board");
+        let alight = sort_key(&mut s, uri, 5, 29, "alight_a").expect("alight_a");
+        assert!(alight < board, "{alight} {board}");
+    }
+
+    /// A declaration inside an expression's body (`forAll { … attribute t
+    /// : T { … } … }` in a constraint) encloses its own statements: they
+    /// are offered its members, not those of the element holding the
+    /// expression.
+    #[test]
+    fn a_declaration_in_an_expression_body_names_its_members() {
+        let text = "package G {\n    part def T { attribute src; attribute dst; }\n    \
+                    part def W {\n        attribute n = 2;\n        assert constraint {\n            \
+                    (1..n)->forAll {\n                in i;\n                attribute t : T {\n                    \
+                    :>> src = 1;\n                    :>> d;\n                }\n                \
+                    true\n            }\n        }\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/g.sysml";
+        put(&mut s, uri, 1, text);
+        // After `:>> d`: `dst`, which `t` inherits from `T`.
+        assert!(is_member(&mut s, uri, 9, 25, "dst"));
+    }
+
+    /// An element with no name of its own inherits through all it is
+    /// declared with — the feature it subsets as well as the type it is
+    /// typed by: `part :> slot : Q { … }` offers `slot`'s `p1` with `Q`'s
+    /// `q1`.
+    #[test]
+    fn an_anonymous_element_inherits_through_its_subsetting_too() {
+        let text = "package A {\n    part def P { attribute p1; }\n    part def Q { attribute q1; }\n    \
+                    part def H { part slot : P; }\n    part h : H {\n        \
+                    part :> slot : Q {\n            attribute :>> q1 = 1;\n            \
+                    attribute :>> p;\n        }\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/a.sysml";
+        put(&mut s, uri, 1, text);
+        // After `attribute :>> p`.
+        assert!(is_member(&mut s, uri, 7, 27, "p1"));
+    }
+
+    /// A transition's target after the `}` of its `do` action names the
+    /// state's members first, though the statement its tokens end there
+    /// leaves the transition short of one when cut out alone.
+    #[test]
+    fn a_transition_target_after_its_effect_names_the_members() {
+        let text = "package T {\n    item def Sig;\n    state def SD { action go; }\n    \
+                    state s : SD {\n        state idle;\n        accept Sig\n            \
+                    do action { }\n            then idle;\n    }\n}\n";
+        let mut s = base_library_server();
+        let uri = "file:///w/t.sysml";
+        put(&mut s, uri, 1, text);
+        // Inside `idle`, after `then i`: `go`, which `s` inherits.
+        assert!(is_member(&mut s, uri, 7, 18, "go"));
+    }
+
+    /// The members kept for an element are its own, whichever position
+    /// read them first: a statement in an expression's body inside the
+    /// element's value (`?{in p :> m; …}`) sits in the element as the
+    /// live text reads it, so reading members there first must not keep
+    /// those of the redefinition holding that expression for the
+    /// element's other statements.
+    #[test]
+    fn members_read_inside_an_expression_body_are_the_elements() {
+        let text = "package M {\n    attribute def Q { attribute num; attribute unit; }\n    \
+                    part def T { attribute weight : Q; attribute total : Q; }\n    \
+                    part f : T {\n        attribute cap :> weight;\n        \
+                    attribute redefines total = total.?{in p :> weight; p};\n    }\n}\n";
+        let mut answers = Vec::new();
+        for select_first in [false, true] {
+            let mut s = base_library_server();
+            let uri = "file:///w/m.sysml";
+            put(&mut s, uri, 1, text);
+            if select_first {
+                // Inside `weight`, after `in p :> w`.
+                let _ = sort_key(&mut s, uri, 5, 53, "weight");
+            }
+            // Inside `weight`, after `attribute cap :> w`.
+            answers.push((
+                is_member(&mut s, uri, 4, 26, "weight"),
+                is_member(&mut s, uri, 4, 26, "num"),
+            ));
+        }
+        assert_eq!(
+            answers,
+            [(true, false), (true, false)],
+            "(weight, num) as members: the select first or not"
+        );
+    }
+
+    /// While the document stays out of the model either way — a
+    /// transition's target after the `}` of its effect, a member
+    /// elsewhere that does not parse — the sessions built for the
+    /// statement are built once: the next keystrokes there build none.
+    #[test]
+    fn a_statement_left_out_of_the_model_builds_once() {
+        let text = |target: &str| {
+            format!(
+                "package T {{\n    item def Sig;\n    part z {{ attribute = ; }}\n    \
+                 state def SD {{ action go; }}\n    state s : SD {{\n        state idle;\n        \
+                 accept Sig\n            do action {{ }}\n            then {target};\n    }}\n}}\n"
+            )
+        };
+        let mut s = base_library_server();
+        let uri = "file:///w/t.sysml";
+        put(&mut s, uri, 1, &text("i"));
+        // After `then i`.
+        let _ = sort_key(&mut s, uri, 8, 18, "idle");
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        for (version, target) in [(2, "id"), (3, "idl")] {
+            put(&mut s, uri, version, &text(target));
+            let after = 17 + u32::try_from(target.len()).expect("short");
+            let _ = sort_key(&mut s, uri, 8, after, "idle");
+        }
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+    }
+
+    /// Which statement of a body was completed first does not change
+    /// the members named for it: a calculation usage whose body redefines
+    /// its definition's `x` and `result` offers `result` in the return's
+    /// redefinition whether `in :>> x` was completed before or not — the
+    /// body the model was built from, which redefines `result` too, does
+    /// not hide what the live body still offers.
+    #[test]
+    fn members_do_not_depend_on_the_statement_completed_first() {
+        let text = "package Q {\n    calc def C { in x; return result; }\n    calc c : C {\n        \
+                    in :>> x = 1;\n        return :>> result = 2;\n    }\n}\n";
+        for x_first in [false, true] {
+            let mut s = base_library_server();
+            let uri = "file:///w/q.sysml";
+            put(&mut s, uri, 1, text);
+            if x_first {
+                // Right after `in :>> x`.
+                assert!(is_member(&mut s, uri, 3, 16, "x"));
+            }
+            // Inside `result`, after `return :>> res`.
+            assert!(
+                is_member(&mut s, uri, 4, 22, "result"),
+                "x first: {x_first}"
+            );
+        }
+    }
+
+    /// A redefinition without a name of its own is one of the body's own
+    /// features, under the name of the feature it redefines and ranked
+    /// as that one: after `ref :>> start { … }` an action's succession
+    /// still names `start` first.
+    #[test]
+    fn unnamed_redefinitions_are_own_features() {
+        let mut s = base_library_server();
+        let (_, items) = listed(
+            &mut s,
+            "file:///w/u.sysml",
+            "action def Go {\n            ref :>> start { }\n            first st|\n        }",
+        );
+        let start = items
+            .iter()
+            .find(|i| i["label"] == "start")
+            .expect("start offered");
+        assert!(
+            start["sortText"]
+                .as_str()
+                .is_some_and(|k| k.starts_with("00")),
+            "{start}"
+        );
+    }
+
+    /// After `all`, `new`, and `as` a type is named more often than a
+    /// feature, but a feature stands there too (`all engineChoice`, `new
+    /// testVehicle(…)`, `vehicles as vehicle`): usages stay offered, after
+    /// the definitions.
+    #[test]
+    fn usages_follow_all_new_and_as() {
+        let mut s = base_library_server();
+        for (i, statement) in [
+            "attribute a = all fu|",
+            "attribute b = new fu|",
+            "attribute c = (x as fu|",
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let (shown, _) = listed(
+                &mut s,
+                &format!("file:///w/o{i}.sysml"),
+                &format!("part fuelTank;\n        {statement}"),
+            );
+            assert!(
+                shown.contains(&"fuelTank".to_string()),
+                "{statement}: {shown:?}"
+            );
+            let (tank, fuel) = (
+                shown.iter().position(|l| l == "fuelTank"),
+                shown.iter().position(|l| l == "Fuel"),
+            );
+            assert!(tank > fuel, "the definition first: {statement}: {shown:?}");
+        }
+    }
+
+    /// A position that takes keywords alone — an action body's
+    /// statement start — builds no symbol table: nothing it offers is a
+    /// name.
+    #[test]
+    fn keyword_positions_build_no_symbol_table() {
+        let mut s = base_library_server();
+        let uri = "file:///w/k.sysml";
+        put(
+            &mut s,
+            uri,
+            1,
+            "package K {\n    action def A {\n        fo\n    }\n}\n",
+        );
+        crate::nav::WORK.with(|w| w.set([0; 3]));
+        assert!(sort_key(&mut s, uri, 2, 10, "fork").is_some());
+        assert_eq!(crate::nav::WORK.with(std::cell::Cell::get)[0], 0);
+    }
+
+    /// A re-seed that changes only the open documents' seeded copies —
+    /// the host's analysis seeds every unit after each pause in typing —
+    /// keeps the members named for an element; one that changes a unit
+    /// not open names them again.
+    #[test]
+    fn members_survive_a_reseed_of_open_documents_only() {
+        let mut s = base_library_server();
+        let (uri, base) = ("file:///w/d.sysml", "file:///w/base.sysml");
+        let d = |body: &str| {
+            format!(
+                "package D {{\n    private import A::*;\n    part def D :> Base {{\n        {body}\n    }}\n}}\n"
+            )
+        };
+        let a = |extra: &str| {
+            format!("package A {{\n    part def Base {{ attribute a1; {extra}}}\n}}\n")
+        };
+        s.set_workspace_sources(vec![(base.to_string(), a("")), (uri.to_string(), d(""))]);
+        put(&mut s, uri, 1, &d("attribute :>> "));
+        assert!(is_member(&mut s, uri, 3, 22, "a1"));
+        // The host seeds the open document's new text.
+        let typed = d("attribute :>> a1;\n        attribute :>> ");
+        put(&mut s, uri, 2, &typed);
+        s.set_workspace_sources(vec![
+            (base.to_string(), a("")),
+            (uri.to_string(), typed.clone()),
+        ]);
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        crate::nav::MEMBER_READS.with(|n| n.set(0));
+        assert!(!is_member(&mut s, uri, 4, 22, "a1"));
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        assert_eq!(crate::nav::MEMBER_READS.with(std::cell::Cell::get), 0);
+        // A unit not open changes: the members are named again.
+        s.set_workspace_sources(vec![
+            (base.to_string(), a("attribute a2; ")),
+            (uri.to_string(), typed),
+        ]);
+        assert!(is_member(&mut s, uri, 4, 22, "a2"));
+    }
+
+    /// The labels a completion at `line`/`character` of `uri` offers.
+    fn labels_at(s: &mut PushServer, uri: &str, line: u32, character: u32) -> Vec<String> {
+        let out = responses(
+            s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                "params": {"textDocument": {"uri": uri},
+                           "position": {"line": line, "character": character}}}),
+        );
+        completion_items(&out[0]["result"])
+            .iter()
+            .filter_map(|i| i["label"].as_str().map(str::to_string))
+            .collect()
+    }
+
+    /// A re-seed that leaves every text as it was — the host seeds each
+    /// open document after a pause in typing — keeps the completion
+    /// session: the next request in the statement builds none. One that
+    /// changes a unit not open builds again, and answers from the new
+    /// text.
+    #[test]
+    fn a_reseed_of_unchanged_texts_keeps_the_completion_session() {
+        let mut s = base_library_server();
+        let (uri, base) = ("file:///w/r.sysml", "file:///w/base.sysml");
+        let text =
+            "package R {\n    private import B::*;\n    part v : V;\n    attribute a = v.\n}\n";
+        let seed = |extra: &str| {
+            vec![
+                (
+                    "file:///w/vehicles.sysml".to_string(),
+                    VEHICLE_MODEL.to_string(),
+                ),
+                (
+                    base.to_string(),
+                    format!("package B {{ part def V {{ attribute m; {extra}}} }}\n"),
+                ),
+                (uri.to_string(), text.to_string()),
+            ]
+        };
+        s.set_workspace_sources(seed(""));
+        put(&mut s, uri, 1, text);
+        assert!(labels_at(&mut s, uri, 3, 20).contains(&"m".to_string()));
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        s.set_workspace_sources(seed(""));
+        assert!(labels_at(&mut s, uri, 3, 20).contains(&"m".to_string()));
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        s.set_workspace_sources(seed("attribute n; "));
+        assert!(labels_at(&mut s, uri, 3, 20).contains(&"n".to_string()));
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 1);
+    }
+
+    /// The line and character right after the first `needle` in `text`.
+    fn after(text: &str, needle: &str) -> (u32, u32) {
+        let end = text.find(needle).expect("needle") + needle.len();
+        let line = text[..end].matches('\n').count();
+        let character = end - text[..end].rfind('\n').map_or(0, |i| i + 1);
+        (
+            u32::try_from(line).expect("short"),
+            u32::try_from(character).expect("short"),
+        )
+    }
+
+    /// The labels a completion right after the first `needle` in `text`,
+    /// put as `uri`'s text at `version`, offers.
+    fn labels_after(
+        s: &mut PushServer,
+        uri: &str,
+        version: i32,
+        text: &str,
+        needle: &str,
+    ) -> Vec<String> {
+        put(s, uri, version, text);
+        let (line, character) = after(text, needle);
+        labels_at(s, uri, line, character)
+    }
+
+    /// The member access of the next statement of a body reads the
+    /// session built for the last one where nothing it reads changed:
+    /// the statement typed since, a re-seed of the open documents, and a
+    /// document it does not read changing build nothing.
+    #[test]
+    fn the_next_member_access_builds_no_session() {
+        let mut s = base_library_server();
+        let (uri, other) = ("file:///w/w.sysml", "file:///w/o.sysml");
+        let body = |statements: &str| {
+            format!(
+                "package W {{\n    private import VehicleModel::*;\n    part def Car2 :> Vehicle {{\n        \
+                 part v : Vehicle;\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        // The host seeds every open document, in one order, before typing
+        // and after each pause.
+        let seed = |s: &mut PushServer, text: String, other_text: String| {
+            s.set_workspace_sources(vec![
+                (
+                    "file:///w/vehicles.sysml".to_string(),
+                    VEHICLE_MODEL.to_string(),
+                ),
+                (uri.to_string(), text),
+                (other.to_string(), other_text),
+            ]);
+        };
+        let first = "package O { part def P; }\n";
+        seed(&mut s, body(""), first.to_string());
+        put(&mut s, other, 1, first);
+        let mut version = 1;
+        let text = body("attribute a0 = v.");
+        let labels = labels_after(&mut s, uri, version, &text, "a0 = v.");
+        assert!(labels.contains(&"fuelIn".to_string()), "{labels:?}");
+        let builds = || crate::nav::SESSION_BUILDS.with(std::cell::Cell::get);
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        let mut written = String::new();
+        for k in 0..3 {
+            written.push_str(&format!("attribute a{k} = v.mass;\n        "));
+            version += 1;
+            put(&mut s, uri, version, &body(written.trim_end()));
+            seed(
+                &mut s,
+                body(written.trim_end()),
+                format!("package O {{ part def P{k}; }}\n"),
+            );
+            put(
+                &mut s,
+                other,
+                k + 2,
+                &format!("package O {{ part def P{k}; }}\n"),
+            );
+            version += 1;
+            let next = k + 1;
+            let text = body(&format!("{written}attribute a{next} = v."));
+            let labels = labels_after(&mut s, uri, version, &text, &format!("a{next} = v."));
+            assert!(
+                labels.contains(&"mass".to_string()) && labels.contains(&"fuelIn".to_string()),
+                "{k}: {labels:?}"
+            );
+        }
+        assert_eq!(builds(), 0);
+    }
+
+    /// A member access read off a session built for another statement
+    /// answers as a new build would: a supertype gaining, renaming, or
+    /// losing a feature in another document or statement, the receiver
+    /// retyped or taken away, a declaration of the receiver's name
+    /// nearer the statement, each is read from the text as it is.
+    #[test]
+    fn member_access_follows_what_it_reads() {
+        let mut s = base_library_server();
+        let (a, b) = ("file:///w/a.sysml", "file:///w/b.sysml");
+        let base =
+            |features: &str| format!("package A {{\n    part def Base {{ {features} }}\n}}\n");
+        let d = |statements: &str| {
+            format!(
+                "package B {{\n    private import A::*;\n    part def Base2 {{ attribute b1; }}\n    \
+                 part y : Base2;\n    part def D {{\n        part x : Base;\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, a, 1, &base("attribute a1;"));
+        let mut version = 0;
+        let mut ask = |s: &mut PushServer, statements: &str, receiver: &str| {
+            version += 1;
+            let text = d(&format!("{statements}attribute q = {receiver}."));
+            members(labels_after(
+                s,
+                b,
+                version,
+                &text,
+                &format!("q = {receiver}."),
+            ))
+        };
+        assert_eq!(ask(&mut s, "", "x"), ["a1"]);
+        // The supertype, in another document: gains, renames, loses.
+        put(&mut s, a, 2, &base("attribute a1; attribute a2;"));
+        assert_eq!(ask(&mut s, "attribute p0;\n        ", "x"), ["a1", "a2"]);
+        put(&mut s, a, 3, &base("attribute a1x; attribute a2;"));
+        assert_eq!(ask(&mut s, "attribute p1;\n        ", "x"), ["a1x", "a2"]);
+        put(&mut s, a, 4, &base("attribute a2;"));
+        assert_eq!(ask(&mut s, "attribute p2;\n        ", "x"), ["a2"]);
+        // The receiver retyped, then taken away.
+        let retyped = "attribute p3;\n        ";
+        let text =
+            d(&format!("{retyped}attribute q = x.")).replace("part x : Base;", "part x : Base2;");
+        version += 10;
+        let listed = |s: &mut PushServer, version: i32, text: &str, needle: &str| {
+            members(labels_after(s, b, version, text, needle))
+        };
+        assert_eq!(listed(&mut s, version, &text, "q = x."), ["b1"]);
+        let text = d("attribute q = x.").replace("part x : Base;", "");
+        version += 1;
+        assert_eq!(
+            listed(&mut s, version, &text, "q = x."),
+            Vec::<String>::new()
+        );
+        // A declaration of the receiver's name nearer the statement: `y`
+        // was the package's, typed `Base2`.
+        version += 1;
+        let text = d("attribute q = y.");
+        assert_eq!(listed(&mut s, version, &text, "q = y."), ["b1"]);
+        version += 1;
+        let text = d("part y : Base;\n        attribute q = y.");
+        assert_eq!(listed(&mut s, version, &text, "q = y."), ["a2"]);
+        // The supertype's own body, in the document typed in.
+        version += 1;
+        let text = d("attribute q = y.").replace("attribute b1;", "attribute b1; attribute b2;");
+        assert_eq!(listed(&mut s, version, &text, "q = y."), ["b1", "b2"]);
+    }
+
+    /// The members a member access lists, sorted, without the `metadata`
+    /// keyword a receiver named by a reference also takes.
+    fn members(mut labels: Vec<String>) -> Vec<String> {
+        labels.retain(|l| l != "metadata");
+        labels.sort();
+        labels
+    }
+
+    /// The labels a member access at `needle` in `uri` offers once the
+    /// documents `changed` take their new texts, on a server that read the
+    /// same access for an earlier statement (`first`, with `documents` as
+    /// they were) and on one built for the new texts alone: what the
+    /// statement reads must agree.
+    fn read_and_built(
+        documents: &[(&str, &str)],
+        first: (&str, &str, &str),
+        changed: &[(&str, &str)],
+        second: (&str, &str, &str),
+    ) -> (Vec<String>, Vec<String>) {
+        let mut s = base_library_server();
+        for (uri, text) in documents {
+            put(&mut s, uri, 1, text);
+        }
+        let (uri, text, needle) = first;
+        labels_after(&mut s, uri, 1, text, needle);
+        for (uri, text) in changed {
+            put(&mut s, uri, 2, text);
+        }
+        let (uri, text, needle) = second;
+        let read = labels_after(&mut s, uri, 2, text, needle);
+        let mut fresh = base_library_server();
+        for (doc, text) in documents {
+            let text = changed
+                .iter()
+                .find(|(u, _)| u == doc)
+                .map_or(*text, |(_, t)| *t);
+            put(&mut fresh, doc, 1, text);
+        }
+        let (uri, text, needle) = second;
+        let built = labels_after(&mut fresh, uri, 1, text, needle);
+        (read, built)
+    }
+
+    /// A recursive import (`::**`) sees into the namespaces nested in its
+    /// target, and into what the types there inherit: a declaration, an
+    /// alias, or a re-export added there, a type added there that
+    /// inherits the name looked up, or a general type of one there gaining
+    /// such a base, has the next member access answer as a session built
+    /// for its own text would — directly or through a package re-exporting
+    /// the recursive import.
+    #[test]
+    fn member_access_after_what_a_recursive_import_sees() {
+        let (lib, other, uri) = (
+            "file:///w/lib.sysml",
+            "file:///w/o.sysml",
+            "file:///w/w.sysml",
+        );
+        let library = |extra: &str| {
+            format!(
+                "package Lib {{\n    package Inner {{\n        part def V1 {{ attribute a1; }}\n        \
+                 part veh : V1;\n    }}\n    {extra}\n}}\n"
+            )
+        };
+        let others = |general: &str| {
+            format!(
+                "package O {{\n    part def V9 {{ attribute z9; }}\n    part veh : V9;\n    \
+                 part def Base9 {{ part veh : V9; }}\n    part def G{general};\n}}\n"
+            )
+        };
+        let work = |import: &str, statements: &str| {
+            format!(
+                "package F {{ public import Lib::**; }}\npackage W {{\n    private import {import};\n    \
+                 part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        for import in ["Lib::**", "F::*"] {
+            for (added, general) in [
+                (
+                    "package Inner2 { part def V2 { attribute b2; } part veh : V2; }",
+                    "",
+                ),
+                ("package Inner2 { alias veh for O::veh; }", ""),
+                ("package Inner2 { public import O::*; }", ""),
+                ("part def Holder :> O::Base9 { }", ""),
+                ("part def Holder2 :> O::Base9;", ""),
+                ("part def Holder :> O::G { }", " :> Base9"),
+            ] {
+                let first = work(import, "attribute q0 = veh.");
+                let second = work(
+                    import,
+                    "attribute q0 = veh.a1;\n        attribute q1 = veh.",
+                );
+                let (lib_before, other_before) = (library(""), others(""));
+                let (lib_after, other_after) = if general.is_empty() {
+                    (library(added), others(""))
+                } else {
+                    // The general type of a type already there gains a base.
+                    (library(added), others(general))
+                };
+                let documents = [
+                    (other, other_before.as_str()),
+                    (
+                        lib,
+                        if general.is_empty() {
+                            lib_before.as_str()
+                        } else {
+                            lib_after.as_str()
+                        },
+                    ),
+                ];
+                let (read, built) = read_and_built(
+                    &documents,
+                    (uri, &first, "q0 = veh."),
+                    &[(lib, &lib_after), (other, &other_after)],
+                    (uri, &second, "q1 = veh."),
+                );
+                assert_eq!(read, built, "{import}: {added} {general}");
+            }
+        }
+        // The type of a usage, and the callable invoked, found through it.
+        let library = |extra: &str| {
+            format!(
+                "package Lib {{\n    package Inner {{\n        part def V1 {{ attribute a1; }}\n        \
+                 calc def F {{ in a; in b; }}\n    }}\n    {extra}\n}}\n"
+            )
+        };
+        let work = |statements: &str| {
+            format!(
+                "package W {{\n    private import Lib::**;\n    part veh : V1;\n    \
+                 part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let (lib_before, lib_after) = (
+            library(""),
+            library("package Inner2 { part def V1 { attribute b1; } calc def F { in c; } }"),
+        );
+        let first = work("attribute q0 = veh.");
+        let second = work("attribute q0 = veh.a1;\n        attribute q1 = veh.");
+        let (read, built) = read_and_built(
+            &[(lib, &lib_before)],
+            (uri, &first, "q0 = veh."),
+            &[(lib, &lib_after)],
+            (uri, &second, "q1 = veh."),
+        );
+        assert_eq!(read, built, "a type found through the recursive import");
+        let signature = |s: &mut PushServer, version: i32, text: &str, needle: &str| {
+            put(s, uri, version, text);
+            let (line, character) = after(text, needle);
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": line, "character": character}}}),
+            )[0]["result"]
+                .clone()
+        };
+        let mut s = base_library_server();
+        put(&mut s, lib, 1, &lib_before);
+        signature(&mut s, 1, &work("attribute s0 = F("), "s0 = F(");
+        put(&mut s, lib, 2, &lib_after);
+        let text = work("attribute s0 = F(1, 2);\n        attribute s1 = F(");
+        let read = signature(&mut s, 2, &text, "s1 = F(");
+        let mut fresh = base_library_server();
+        put(&mut fresh, lib, 1, &lib_after);
+        assert_eq!(
+            read,
+            signature(&mut fresh, 1, &text, "s1 = F("),
+            "a callable found through the recursive import"
+        );
+    }
+
+    /// What an import statement names resolves where the statement
+    /// stands and in each namespace its path passes through: a namespace
+    /// declared there under one of its names changes what the import
+    /// brings in, and the next member access answers as a session built
+    /// for its own text would.
+    #[test]
+    fn member_access_after_an_import_path_is_shadowed() {
+        let (lib, uri) = ("file:///w/lib.sysml", "file:///w/w.sysml");
+        let library = |extra: &str| {
+            format!(
+                "package Lib {{\n    package Inner {{\n        part def V1 {{ attribute a1; }}\n        \
+                 part veh : V1;\n    }}\n    {extra}\n}}\n"
+            )
+        };
+        let shadow = "package Inner { part def V5 { attribute z5; } part veh : V5; }";
+        for (import, in_work) in [("Lib::Inner::*", true), ("Lib::Inner::*", false)] {
+            let work = |extra: &str| {
+                format!(
+                    "package W {{\n    private import {import};\n    {extra}\n    part def D {{\n        \
+                     attribute q0 = veh.\n    }}\n}}\n"
+                )
+            };
+            let (work_before, lib_before) = (work(""), library(""));
+            let (work_after, lib_after) = if in_work {
+                (work(&shadow.replace("Inner", "Lib")), library(""))
+            } else {
+                (work(""), library(shadow))
+            };
+            let (read, built) = read_and_built(
+                &[(lib, &lib_before), (uri, &work_before)],
+                (uri, &work_before, "q0 = veh."),
+                &[(lib, &lib_after), (uri, &work_after)],
+                (uri, &work_after, "q0 = veh."),
+            );
+            assert_eq!(
+                read,
+                built,
+                "{import}: shadowed in the {}",
+                if in_work {
+                    "importing package"
+                } else {
+                    "namespace looked into"
+                }
+            );
+        }
+        // The same for a name a declaration a recursive import sees into
+        // names its type by: `holder : Defs::Defs::H0` looks into the type
+        // `Defs`, where an `H0` of its own hides the one it inherits.
+        let defs = "file:///w/d.sysml";
+        let library = "package Lib {\n    part holder : Defs::Defs::H0;\n}\n";
+        let definitions = |own: &str| {
+            format!(
+                "package Defs {{\n    part def V1 {{ attribute a1; }}\n    part def V9 {{ attribute z9; }}\n    \
+                 part def DefsBase {{ part def H0 {{ part veh : V9; }} }}\n    \
+                 part def Defs :> DefsBase {{ {own} }}\n}}\n"
+            )
+        };
+        let work = |statements: &str| {
+            format!(
+                "package W {{\n    private import Lib::**;\n    part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let (defs_before, defs_after) = (
+            definitions(""),
+            definitions("part def H0 { part veh : V1; }"),
+        );
+        let first = work("attribute q0 = veh.");
+        let second = work("attribute q0 = 1;\n        attribute q1 = veh.");
+        let (read, built) = read_and_built(
+            &[(lib, library), (defs, &defs_before)],
+            (uri, &first, "q0 = veh."),
+            &[(defs, &defs_after)],
+            (uri, &second, "q1 = veh."),
+        );
+        assert_eq!(members(built.clone()), ["a1"], "the new type's");
+        assert_eq!(
+            read, built,
+            "shadowed in a namespace a type's path looks into"
+        );
+    }
+
+    /// A filtered import brings in what its condition admits, which reads
+    /// the metadata of each member it is asked of: a member's annotation
+    /// type losing the general type the condition names changes what the
+    /// import brings in — a condition of the import, or a filter member
+    /// of the namespace importing — and the next member access answers as
+    /// a session built for its own text would.
+    #[test]
+    fn member_access_after_what_a_filter_reads_changes() {
+        let (lib, uri) = ("file:///w/lib.sysml", "file:///w/w.sysml");
+        let library = |general: &str| {
+            format!(
+                "package Lib {{\n    metadata def Safety;\n    metadata def Rated{general};\n    \
+                 part def V1 {{ attribute a1; }}\n    part veh : V1 {{ @Rated; }}\n}}\n"
+            )
+        };
+        for import in [
+            "Lib::*[@Safety]",
+            "Lib::**[@Safety]",
+            "Lib::*;\n    filter @Safety",
+        ] {
+            let work = |statements: &str| {
+                format!(
+                    "package W {{\n    private import {import};\n    \
+                     part def D {{\n        {statements}\n    }}\n}}\n"
+                )
+            };
+            let (lib_before, lib_after) = (library(" :> Safety"), library(""));
+            let first = work("attribute q0 = veh.");
+            let second = work("attribute q0 = 1;\n        attribute q1 = veh.");
+            let (read, built) = read_and_built(
+                &[(lib, &lib_before)],
+                (uri, &first, "q0 = veh."),
+                &[(lib, &lib_after)],
+                (uri, &second, "q1 = veh."),
+            );
+            assert_eq!(read, built, "{import}");
+        }
+    }
+
+    /// A namespace import of a type (`import P::*`) brings in what the
+    /// type inherits too: a general type of it gaining another base
+    /// changes what the import brings in, and the next member access
+    /// answers as a session built for its own text would.
+    #[test]
+    fn member_access_after_an_imported_type_changes() {
+        let (a, uri) = ("file:///w/a.sysml", "file:///w/w.sysml");
+        let types = |base: &str| {
+            format!(
+                "package A {{\n    part def X1 {{ attribute a1; }}\n    part def X3 {{ attribute a3; }}\n    \
+                 part def H {{ part x : X1; }}\n    part def H3 {{ part x : X3; }}\n    \
+                 part def G :> {base};\n    part def P :> G;\n}}\n"
+            )
+        };
+        let work = |statements: &str| {
+            format!(
+                "package W {{\n    private import A::P::*;\n    part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let (before, after) = (types("H"), types("H3"));
+        let first = work("attribute q0 = x.");
+        let second = work("attribute q0 = 1;\n        attribute q1 = x.");
+        let (read, built) = read_and_built(
+            &[(a, &before)],
+            (uri, &first, "q0 = x."),
+            &[(a, &after)],
+            (uri, &second, "q1 = x."),
+        );
+        assert_eq!(members(built.clone()), ["a3"]);
+        assert_eq!(read, built);
+    }
+
+    /// A type a qualified name passes through (`P::x`, `: P::Q`) has its
+    /// members from its general types: one of those gaining another base
+    /// changes what the name finds, and the next member access answers as
+    /// a session built for its own text would.
+    #[test]
+    fn member_access_after_a_type_a_name_passes_through_changes() {
+        let (a, uri) = ("file:///w/a.sysml", "file:///w/w.sysml");
+        let types = |base: &str| {
+            format!(
+                "package A {{\n    part def X1 {{ attribute a1; }}\n    part def X3 {{ attribute a3; }}\n    \
+                 part def H {{ part x : X1; part def Q {{ attribute q1; }} }}\n    \
+                 part def H3 {{ part x : X3; part def Q {{ attribute q3; }} }}\n    \
+                 part def G :> {base};\n    part def P :> G;\n    part y : P::Q;\n}}\n"
+            )
+        };
+        for (import, receiver) in [("A::*", "P::x"), ("A::*", "y")] {
+            let work = |statements: &str| {
+                format!(
+                    "package W {{\n    private import {import};\n    part def D {{\n        {statements}\n    }}\n}}\n"
+                )
+            };
+            let first = work(&format!("attribute q0 = {receiver}."));
+            let second = work(&format!(
+                "attribute q0 = 1;\n        attribute q1 = {receiver}."
+            ));
+            let (before, after) = (types("H"), types("H3"));
+            let (read, built) = read_and_built(
+                &[(a, before.as_str())],
+                (uri, &first, &format!("q0 = {receiver}.")),
+                &[(a, &after)],
+                (uri, &second, &format!("q1 = {receiver}.")),
+            );
+            assert_eq!(read, built, "{import}: {receiver}");
+        }
+    }
+
+    /// A general type re-exporting what it imports (`public import O::*`
+    /// in its body) passes the imported namespace's members on: a member
+    /// added there is listed by the next member access.
+    #[test]
+    fn member_access_after_a_re_exported_namespace_changes() {
+        let (lib, other, uri) = (
+            "file:///w/lib.sysml",
+            "file:///w/o.sysml",
+            "file:///w/w.sysml",
+        );
+        let library = "package Lib {\n    part def V1 { public import O::*; attribute a1; }\n    \
+                       part veh : V1;\n}\n";
+        let o = |extra: &str| format!("package O {{\n    attribute oo;\n    {extra}\n}}\n");
+        let work = |statements: &str| {
+            format!(
+                "package W {{\n    private import Lib::*;\n    part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let (before, after) = (o(""), o("attribute oo2;"));
+        let first = work("attribute q0 = veh.");
+        let second = work("attribute q0 = veh.a1;\n        attribute q1 = veh.");
+        let (read, built) = read_and_built(
+            &[(lib, library), (other, &before)],
+            (uri, &first, "q0 = veh."),
+            &[(other, &after)],
+            (uri, &second, "q1 = veh."),
+        );
+        assert_eq!(members(read.clone()), ["a1", "oo", "oo2"]);
+        assert_eq!(read, built);
+    }
+
+    /// A usage typed by the type it is named as (`part T2 : T2;`) has the
+    /// type found around it, not recorded among its targets: while that
+    /// type has no members there is no inherited member to tell where they
+    /// come from, and only the target the model did not report keeps the
+    /// next member access from reading a session built before the type
+    /// gained one.
+    #[test]
+    fn member_access_after_an_unreported_type_gains_a_member() {
+        let (a, uri) = ("file:///w/a.sysml", "file:///w/w.sysml");
+        let types = |members: &str| format!("package A {{\n    part def T2 {{ {members} }}\n}}\n");
+        let work = |statements: &str| {
+            format!(
+                "package W {{\n    private import A::*;\n    part T2 : T2;\n    part x : T2;\n    \
+                 part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let (before, after) = (types(""), types("attribute t2;"));
+        let first = work("attribute q0 = x.");
+        let second = work("attribute q0 = 1;\n        attribute q1 = x.");
+        let (read, built) = read_and_built(
+            &[(a, &before)],
+            (uri, &first, "q0 = x."),
+            &[(a, &after)],
+            (uri, &second, "q1 = x."),
+        );
+        assert_eq!(read, built);
+    }
+
+    /// A statement that changes what a name finds without spelling the
+    /// name — an import, a parameter or a result redefining the
+    /// definition's by position, a subject — has the next member access
+    /// answer as a session built for its own text would.
+    #[test]
+    fn member_access_after_what_changes_a_name_unspelled() {
+        let head = "package A {\n    part def T1 { attribute t1; }\n    part x : T1;\n}\n\
+                    package B {\n    part def T2 { attribute t2; }\n    part x : T2;\n}\n";
+        let uri = "file:///w/c.sysml";
+        for (open, before, receiver) in [
+            (
+                "package W {\n    private import A::*;\n    part def D {\n        ",
+                "private import B::*;",
+                "x",
+            ),
+            (
+                "package W {\n    action def Act { in p : A::T1; }\n    action a : Act {\n        ",
+                "in z : B::T2;",
+                "p",
+            ),
+            (
+                "package W {\n    calc def C { return r : A::T1; }\n    calc c : C {\n        ",
+                "return s : B::T2;",
+                "result",
+            ),
+            (
+                "package W {\n    requirement def R { subject v : A::T1; }\n    \
+                 requirement r : R {\n        ",
+                "subject w : B::T2;",
+                "subj",
+            ),
+        ] {
+            let tail = "\n    }\n}\n";
+            let first = format!("{head}{open}attribute q0 = {receiver}.{tail}");
+            let second = format!("{head}{open}{before}\n        attribute q1 = {receiver}.{tail}");
+            let q1 = format!("q1 = {receiver}.");
+            let mut s = base_library_server();
+            labels_after(&mut s, uri, 1, &first, &format!("q0 = {receiver}."));
+            let answered = members(labels_after(&mut s, uri, 2, &second, &q1));
+            let mut fresh = base_library_server();
+            let expected = members(labels_after(&mut fresh, uri, 1, &second, &q1));
+            assert_eq!(answered, expected, "{before}");
+        }
+    }
+
+    /// A unit bracket read off a session built for another statement
+    /// lists the units the workspace declares now: one declared since —
+    /// in another document or in a statement of this one — renamed, or
+    /// taken away is listed as it is, while statements declaring no unit
+    /// build nothing.
+    #[test]
+    fn unit_brackets_follow_the_workspace_units() {
+        let mut s = two_package_server();
+        let (uri, other) = ("file:///w/u.sysml", "file:///w/v.sysml");
+        let unit = |name: &str| {
+            format!("attribute {name} : MeasurementReferences::TensorMeasurementReference;")
+        };
+        let other_doc = |names: &[&str]| {
+            let units: Vec<String> = names.iter().map(|n| unit(n)).collect();
+            format!("package V {{ {} }}\n", units.join(" "))
+        };
+        let doc = |statements: &str| {
+            format!("package U {{\n    part def P {{\n        {statements}\n    }}\n}}\n")
+        };
+        put(&mut s, other, 1, &other_doc(&["vOne"]));
+        let mut version = 1;
+        let mut written = String::new();
+        let mut bracket = |s: &mut PushServer, k: usize, before: &str| {
+            written.push_str(before);
+            let text = doc(&format!("{written}attribute x{k} = 5 ["));
+            let labels = labels_after(s, uri, version, &text, &format!("x{k} = 5 ["));
+            version += 1;
+            written.push_str(&format!("attribute x{k} = 5;\n        "));
+            labels
+        };
+        assert!(bracket(&mut s, 0, "").contains(&"vOne".to_string()));
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        let labels = bracket(&mut s, 1, "attribute y = 3;\n        ");
+        assert!(labels.contains(&"vOne".to_string()), "{labels:?}");
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        for (k, (names, listed, unlisted)) in [
+            (&["vOne", "vTwo"][..], "vTwo", "vThree"),
+            (&["vOne", "vThree"], "vThree", "vTwo"),
+            (&["vOne"], "vOne", "vThree"),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            put(
+                &mut s,
+                other,
+                i32::try_from(k).expect("short") + 2,
+                &other_doc(names),
+            );
+            let labels = bracket(&mut s, k + 2, "");
+            assert!(
+                labels.contains(&listed.to_string()),
+                "{names:?}: {labels:?}"
+            );
+            assert!(
+                !labels.contains(&unlisted.to_string()),
+                "{names:?}: {labels:?}"
+            );
+        }
+        // Declared in a statement of the document typed in.
+        let labels = bracket(&mut s, 9, &format!("{}\n        ", unit("uNine")));
+        assert!(labels.contains(&"uNine".to_string()), "{labels:?}");
+    }
+
+    /// A unit is listed by its qualified name, which another declaration
+    /// of its name beside it makes resolve elsewhere: one declared or
+    /// taken away there has the next bracket list the units as a session
+    /// built for its own text would.
+    #[test]
+    fn unit_brackets_follow_a_name_declared_twice() {
+        let (uri, other) = ("file:///w/u.sysml", "file:///w/v.sysml");
+        let other_doc = |twice: bool| {
+            format!(
+                "package V {{\n    attribute vOne : MeasurementReferences::TensorMeasurementReference;\n    {}\n}}\n",
+                if twice { "attribute vOne;" } else { "" }
+            )
+        };
+        let doc = |statements: &str| {
+            format!("package U {{\n    part def P {{\n        {statements}\n    }}\n}}\n")
+        };
+        for (before, after) in [(true, false), (false, true)] {
+            let mut s = two_package_server();
+            put(&mut s, other, 1, &other_doc(before));
+            labels_after(&mut s, uri, 1, &doc("attribute x0 = 5 ["), "x0 = 5 [");
+            put(&mut s, other, 2, &other_doc(after));
+            let text = doc("attribute x0 = 5;\n        attribute x1 = 5 [");
+            let read = labels_after(&mut s, uri, 2, &text, "x1 = 5 [");
+            let mut fresh = two_package_server();
+            put(&mut fresh, other, 1, &other_doc(after));
+            let built = labels_after(&mut fresh, uri, 1, &text, "x1 = 5 [");
+            assert_eq!(read, built, "declared twice before: {before}");
+            if !after {
+                assert!(read.contains(&"vOne".to_string()), "{read:?}");
+            }
+        }
+    }
+
+    /// The units a bracket puts first where its value is an operand are
+    /// those of the quantity the other operand measures as the model has
+    /// it now: the operand retyped in another document takes the other
+    /// type's units.
+    #[test]
+    fn unit_brackets_follow_the_operand_compared_with() {
+        let mut s = two_package_server();
+        let (uri, money) = ("file:///w/p.sysml", "file:///w/m.sysml");
+        let quantity = |kind: &str| {
+            format!(
+                "package M {{\n    attribute def Cash :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute def Coin :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute usd : Cash;\n    attribute penny : Coin;\n    \
+                 attribute def Money {{ attribute mRef : Cash; }}\n    \
+                 attribute def Change {{ attribute mRef : Coin; }}\n    attribute price : {kind};\n}}\n"
+            )
+        };
+        let doc = |statements: &str| {
+            format!(
+                "package P {{\n    private import M::*;\n    part def Q {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let first = |labels: &[String]| labels.first().cloned().unwrap_or_default();
+        put(&mut s, money, 1, &quantity("Money"));
+        let text = doc("attribute a = price <= 5 [");
+        assert_eq!(first(&labels_after(&mut s, uri, 1, &text, "5 [")), "usd");
+        put(&mut s, money, 2, &quantity("Change"));
+        let text = doc("attribute a = price <= 5 [usd];\n        attribute b = price <= 5 [");
+        assert_eq!(
+            first(&labels_after(&mut s, uri, 2, &text, "b = price <= 5 [")),
+            "penny"
+        );
+    }
+
+    /// The units a bracket puts first are those of the quantity declared
+    /// as the model has it now: a quantity type whose measurement
+    /// reference changes in another document takes the other's units.
+    #[test]
+    fn unit_brackets_follow_the_declared_quantity() {
+        let mut s = two_package_server();
+        let (uri, money) = ("file:///w/p.sysml", "file:///w/m.sysml");
+        let quantity = |unit: &str| {
+            format!(
+                "package M {{\n    attribute def Cash :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute def Coin :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute usd : Cash;\n    attribute penny : Coin;\n    \
+                 attribute def Money {{ attribute mRef : {unit}; }}\n}}\n"
+            )
+        };
+        let doc = |statements: &str| {
+            format!(
+                "package P {{\n    private import M::*;\n    part def Q {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let first = |labels: &[String]| labels.first().cloned().unwrap_or_default();
+        put(&mut s, money, 1, &quantity("Cash"));
+        let text = doc("attribute a : Money = 5 [");
+        assert_eq!(first(&labels_after(&mut s, uri, 1, &text, "5 [")), "usd");
+        put(&mut s, money, 2, &quantity("Coin"));
+        let text = doc("attribute a : Money = 5 [usd];\n        attribute b : Money = 5 [");
+        assert_eq!(
+            first(&labels_after(&mut s, uri, 2, &text, "b : Money = 5 [")),
+            "penny"
+        );
+    }
+
+    /// The units a bracket puts first where its value is an argument are
+    /// those of the quantity the parameter it binds measures as the model
+    /// has it now — the callable's own parameter or one it inherits: the
+    /// parameter's type specializing another quantity in another document
+    /// takes that one's units.
+    #[test]
+    fn unit_brackets_follow_the_parameter_an_argument_binds() {
+        let (uri, money) = ("file:///w/p.sysml", "file:///w/m.sysml");
+        let quantity = |kind: &str| {
+            format!(
+                "package M {{\n    attribute def Cash :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute def Coin :> MeasurementReferences::TensorMeasurementReference;\n    \
+                 attribute usd : Cash;\n    attribute penny : Coin;\n    \
+                 attribute def Money {{ attribute mRef : Cash; }}\n    \
+                 attribute def Change {{ attribute mRef : Coin; }}\n    attribute def Amount :> {kind};\n}}\n"
+            )
+        };
+        let doc = |statements: &str| {
+            format!(
+                "package P {{\n    private import M::*;\n    calc def Pay {{ in amount : Amount; }}\n    \
+                 calc def Repay :> Pay;\n    part def Q {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let first = |labels: &[String]| labels.first().cloned().unwrap_or_default();
+        for callee in ["Pay", "Repay"] {
+            let mut s = two_package_server();
+            put(&mut s, money, 1, &quantity("Money"));
+            let text = doc(&format!("attribute a = {callee}(5 ["));
+            assert_eq!(
+                first(&labels_after(&mut s, uri, 1, &text, "(5 [")),
+                "usd",
+                "{callee}"
+            );
+            put(&mut s, money, 2, &quantity("Change"));
+            let text = doc(&format!(
+                "attribute a = {callee}(5 [usd]);\n        attribute b = {callee}(5 ["
+            ));
+            let needle = format!("b = {callee}(5 [");
+            assert_eq!(
+                first(&labels_after(&mut s, uri, 2, &text, &needle)),
+                "penny",
+                "{callee}"
+            );
+        }
+    }
+
+    /// A library callable's parameter and result types are spelled the
+    /// shortest way that resolves where the signature is read — those of
+    /// a parameter or a result inherited, or of a parameter redefined
+    /// without a type, too: a declaration of the type's name there since
+    /// has the next statement's signature help spell it in full, as a
+    /// session built for its own text would.
+    #[test]
+    fn signature_help_spells_types_where_it_is_read() {
+        let server = || {
+            let mut s = PushServer::with_library_sources(
+                vec![(
+                    "Calcs.sysml".to_string(),
+                    "standard library package ScalarValues { attribute def Real; attribute def Integer; }\n\
+                     standard library package Calcs {\n\
+                     calc def Twice { in x : ScalarValues::Real; return : ScalarValues::Integer; }\n\
+                     }\n"
+                        .to_string(),
+                )],
+                None,
+            );
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                    "params": {"capabilities": {"general": {"positionEncodings": ["utf-8"]}}}}),
+            );
+            s
+        };
+        let uri = "file:///w/s.sysml";
+        let doc = |own: &str, statements: &str| {
+            format!(
+                "package S {{\n    private import Calcs::*;\n    private import ScalarValues::*;\n    \
+                 {own}\n    calc def Thrice :> Twice;\n    calc def Again :> Twice {{ in :>> x; }}\n    \
+                 part def U {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let signature = |s: &mut PushServer, version: i32, text: &str, needle: &str| {
+            put(s, uri, version, text);
+            let (line, character) = after(text, needle);
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": line, "character": character}}}),
+            )[0]["result"]["signatures"][0]["label"]
+                .clone()
+        };
+        for callee in ["Twice", "Thrice", "Again"] {
+            for (own, spelled) in [
+                ("attribute def Real;", "(x: ScalarValues::Real) → Integer"),
+                (
+                    "attribute def Integer;",
+                    "(x: Real) → ScalarValues::Integer",
+                ),
+            ] {
+                let mut s = server();
+                let call = format!("{callee}(");
+                let text = doc("", &format!("attribute a0 = {call}"));
+                assert_eq!(
+                    signature(&mut s, 1, &text, &call),
+                    format!("{callee}(x: Real) → Integer")
+                );
+                let text = doc(own, &format!("attribute a0 = {call}"));
+                let read = signature(&mut s, 2, &text, &call);
+                let mut fresh = server();
+                assert_eq!(read, signature(&mut fresh, 1, &text, &call), "{callee}");
+                assert_eq!(read, format!("{callee}{spelled}"));
+            }
+        }
+    }
+
+    /// The signature help of the next statement reads the session built
+    /// for the last one where the callable is as it was — nothing is
+    /// built for it — and shows a parameter it gained since.
+    #[test]
+    fn signature_help_follows_the_callable() {
+        let mut s = base_library_server();
+        let (uri, calcs) = ("file:///w/s.sysml", "file:///w/c.sysml");
+        let calc = |params: &str| format!("package C {{\n    calc def Twice {{ {params} }}\n}}\n");
+        let doc = |statements: &str| {
+            format!(
+                "package S {{\n    private import C::*;\n    part def U {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let signature = |s: &mut PushServer, version: i32, text: &str, needle: &str| {
+            put(s, uri, version, text);
+            let (line, character) = after(text, needle);
+            let out = responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/signatureHelp",
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": line, "character": character}}}),
+            );
+            out[0]["result"]["signatures"][0]["label"].clone()
+        };
+        put(&mut s, calcs, 1, &calc("in f; in x;"));
+        let text = doc("attribute a0 = Twice(");
+        assert_eq!(signature(&mut s, 1, &text, "Twice("), "Twice(f, x)");
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        let text = doc("attribute a0 = Twice(1, 2);\n        attribute a1 = Twice(");
+        assert_eq!(signature(&mut s, 2, &text, "a1 = Twice("), "Twice(f, x)");
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        put(&mut s, calcs, 2, &calc("in f; in x; in y;"));
+        let text = doc(
+            "attribute a0 = Twice(1, 2);\n        attribute a1 = Twice(1, 2);\n        attribute a2 = Twice(",
+        );
+        assert_eq!(signature(&mut s, 3, &text, "a2 = Twice("), "Twice(f, x, y)");
+    }
+
+    /// A usage named as the type it is typed by (`part T2 : T2;`) has its
+    /// typing found around it, not recorded as a target: the members
+    /// reached through it follow that type's body all the same.
+    #[test]
+    fn member_access_follows_a_type_named_as_its_usage() {
+        let mut s = base_library_server();
+        let (a, b) = ("file:///w/a.sysml", "file:///w/b.sysml");
+        let types = |t2: &str| {
+            format!(
+                "package A {{\n    part def T1 {{ attribute t1; }}\n    part def T2 :> T1 {{ {t2} }}\n}}\n"
+            )
+        };
+        let doc = |statements: &str| {
+            format!(
+                "package B {{\n    private import A::*;\n    part x : T2;\n    part T2 : T2;\n    \
+                 part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, a, 1, &types("attribute t2;"));
+        let text = doc("attribute q0 = x.");
+        assert_eq!(
+            members(labels_after(&mut s, b, 1, &text, "q0 = x.")),
+            ["t1", "t2"]
+        );
+        put(&mut s, a, 2, &types("attribute w;"));
+        let text = doc("attribute q0 = x.t1;\n        attribute q1 = x.");
+        assert_eq!(
+            members(labels_after(&mut s, b, 2, &text, "q1 = x.")),
+            ["t1", "w"]
+        );
+    }
+
+    /// Over random edits — features gained, lost and retyped, supertypes
+    /// swapped, imports, aliases, parameters, annotations and units
+    /// declared, statements that do not parse, declarations at a unit's
+    /// top level — with re-seeds and navigation rebuilds between them, a
+    /// server reading answers off sessions built for other texts answers
+    /// each member access, unit bracket, and signature help as a server
+    /// building one for it does.
+    #[test]
+    fn answers_read_off_other_texts_match_new_builds() {
+        struct Rng(u64);
+        impl Rng {
+            fn below(&mut self, n: usize) -> usize {
+                self.0 ^= self.0 << 13;
+                self.0 ^= self.0 >> 7;
+                self.0 ^= self.0 << 17;
+                usize::try_from(self.0 % n as u64).expect("small")
+            }
+            fn pick<'a>(&mut self, xs: &[&'a str]) -> &'a str {
+                xs[self.below(xs.len())]
+            }
+        }
+        let names = ["t1", "t2", "x", "y", "z", "w", "p", "T1", "T2", "u1", "C"];
+        let types = ["T1", "T2", "Q", "U1", "C::C0"];
+        let (a_uri, b_uri, c_uri) = (
+            "file:///w/a.sysml",
+            "file:///w/b.sysml",
+            "file:///w/c.sysml",
+        );
+        let answer = |s: &mut PushServer, text: &str, offset: usize, signature: bool| {
+            let line = text[..offset].matches('\n').count();
+            let character = offset - text[..offset].rfind('\n').map_or(0, |i| i + 1);
+            let method = if signature {
+                "textDocument/signatureHelp"
+            } else {
+                "textDocument/completion"
+            };
+            let out = responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": method,
+                    "params": {"textDocument": {"uri": b_uri},
+                               "position": {"line": line, "character": character}}}),
+            );
+            out.iter()
+                .find(|m| m["id"] == 3)
+                .map(|m| m["result"].to_string())
+                .unwrap_or_default()
+        };
+        crate::nav::REUSED_ANSWERS.with(|n| n.set(0));
+        for seed in 1..=4u64 {
+            let mut rng = Rng(seed.wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1);
+            let (mut t1, mut t2) = (
+                vec!["attribute t1;".to_string()],
+                vec!["attribute t2;".to_string()],
+            );
+            let mut a_rest = vec![
+                "part x : T1;".to_string(),
+                "attribute def U1 :> MeasurementReferences::TensorMeasurementReference;"
+                    .to_string(),
+                "attribute u1 : U1;".to_string(),
+                "attribute def Q { attribute mRef : U1; }".to_string(),
+                "calc def F { in a; in b; }".to_string(),
+            ];
+            let (mut general, mut body, mut outer) =
+                ("T1", vec!["part y : T2;".to_string()], Vec::new());
+            let mut package: Vec<String> = Vec::new();
+            let mut c = vec!["part def C0 { attribute c0; }".to_string()];
+            let mut long = two_package_server();
+            let mut versions = [0; 3];
+            for step in 0..40 {
+                let (n, m, ty) = (rng.pick(&names), rng.pick(&names), rng.pick(&types));
+                match rng.below(16) {
+                    0 => t1.push(format!("attribute {n};")),
+                    1 => drop(t1.pop()),
+                    2 => t2.push(format!("part {n} : {ty};")),
+                    3 => a_rest.push(format!("part {n} : {ty};")),
+                    4 => general = rng.pick(&["T1", "T2", "Q", "C::C0"]),
+                    5 => body.push(format!("part {n} : {ty};")),
+                    6 => body.push(format!("attribute {n} = {m};")),
+                    7 => body.push(
+                        rng.pick(&[
+                            "private import C::*;",
+                            "alias w for x;",
+                            "in p : T2;",
+                            "@Q;",
+                            "attribute :>> t1;",
+                            "part :>> y : T1;",
+                            "attribute bad = ;",
+                            "doc /* d */",
+                        ])
+                        .to_string(),
+                    ),
+                    8 => drop(body.pop()),
+                    9 => outer.push(format!("part {n} : {ty};")),
+                    10 => a_rest.push(format!("attribute {n} : U1;")),
+                    11 => a_rest.push(format!("calc def F {{ in {n}; in {m}; }}")),
+                    12 => c.push(format!("part def {n} {{ attribute {m}; }}")),
+                    13 => a_rest.push(format!("attribute def Q {{ attribute mRef : {ty}; }}")),
+                    14 => package.push(format!("part {n} : {ty};")),
+                    _ => t2.push(format!("attribute {n};")),
+                }
+                let a = format!(
+                    "package A {{\n    part def T1 {{ {} }}\n    part def T2 :> T1 {{ {} }}\n    {}\n}}\n",
+                    t1.join(" "),
+                    t2.join(" "),
+                    a_rest.join("\n    ")
+                );
+                let c_text = format!("package C {{ {} }}\n{}\n", c.join(" "), outer.join("\n"));
+                let receiver = rng.pick(&[
+                    "x", "y", "z", "w", "t1", "p", "u1", "C::C0", "F(1, 2)", "y.t1",
+                ]);
+                let (statement, signature) = match rng.below(5) {
+                    0 | 1 => (format!("attribute q{step} = {receiver}."), false),
+                    2 => (format!("attribute b{step} = 5 ["), false),
+                    3 => (format!("attribute b{step} : Q = 5 ["), false),
+                    _ => (format!("attribute s{step} = F("), true),
+                };
+                let before = format!(
+                    "package B {{\n    private import A::*;\n    {}\n    part def D :> {general} {{\n        {}\n        ",
+                    package.join("\n    "),
+                    body.join("\n        ")
+                );
+                let b = format!("{before}{statement}\n    }}\n}}\n");
+                let offset = before.len() + statement.len();
+                let texts = [
+                    (a_uri, a.as_str()),
+                    (c_uri, c_text.as_str()),
+                    (b_uri, b.as_str()),
+                ];
+                if step == 0 || rng.below(3) == 0 {
+                    long.set_workspace_sources(
+                        texts
+                            .iter()
+                            .map(|(u, t)| (u.to_string(), t.to_string()))
+                            .collect(),
+                    );
+                }
+                for (i, (uri, text)) in texts.iter().enumerate() {
+                    versions[i] += 1;
+                    put(&mut long, uri, versions[i], text);
+                }
+                if rng.below(4) == 0 {
+                    // A navigation session over the statements finished.
+                    versions[2] += 1;
+                    put(
+                        &mut long,
+                        b_uri,
+                        versions[2],
+                        &format!("{before}\n    }}\n}}\n"),
+                    );
+                    responses(
+                        &mut long,
+                        &serde_json::json!({"jsonrpc": "2.0", "id": 4, "method": "textDocument/inlayHint",
+                            "params": {"textDocument": {"uri": b_uri},
+                                       "range": {"start": {"line": 0, "character": 0},
+                                                 "end": {"line": 99, "character": 0}}}}),
+                    );
+                    versions[2] += 1;
+                    put(&mut long, b_uri, versions[2], &b);
+                }
+                let read = answer(&mut long, &b, offset, signature);
+                let mut fresh = two_package_server();
+                for (uri, text) in texts {
+                    put(&mut fresh, uri, 1, text);
+                }
+                let built = answer(&mut fresh, &b, offset, signature);
+                assert_eq!(read, built, "seed {seed}, step {step}:\n{a}\n{c_text}\n{b}");
+            }
+        }
+        assert!(crate::nav::REUSED_ANSWERS.with(std::cell::Cell::get) > 20);
+    }
+
+    /// While a unit does not parse, read-only navigation's tolerant
+    /// session — the units that do not parse salvaged — answers the next
+    /// member access as any session built does, nothing built for it;
+    /// what plans over every reference still answers nothing, and a
+    /// hover past the statement being typed still reads the document as
+    /// written.
+    #[test]
+    fn the_tolerant_session_answers_completion_alone() {
+        let mut s = base_library_server();
+        let (uri, broken) = ("file:///w/a.sysml", "file:///w/b.sysml");
+        let doc = |statements: &str| {
+            format!(
+                "package A {{\n    part def V {{ attribute m; }}\n    part v : V;\n    part def D {{\n        \
+                 {statements}\n    }}\n    part w : V;\n}}\n"
+            )
+        };
+        put(
+            &mut s,
+            broken,
+            1,
+            "package B {\n    part def X { attribute = ; }\n}\n",
+        );
+        let text = doc("attribute q0 = 1;");
+        put(&mut s, uri, 1, &text);
+        let ask = |s: &mut PushServer, method: &str, text: &str, needle: &str| {
+            let (line, character) = after(text, needle);
+            responses(
+                s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 5, "method": method,
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": line, "character": character},
+                               "context": {"includeDeclaration": true}}}),
+            )[0]["result"]
+                .clone()
+        };
+        // A hover builds the tolerant session: the strict one cannot.
+        assert!(!ask(&mut s, "textDocument/hover", &text, "m; }\n    part ").is_null());
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        crate::nav::REUSED_ANSWERS.with(|n| n.set(0));
+        let text = doc("attribute q0 = 1;\n        attribute q1 = v.");
+        let labels = labels_after(&mut s, uri, 2, &text, "q1 = v.");
+        assert_eq!(members(labels), ["m"]);
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        assert_eq!(crate::nav::REUSED_ANSWERS.with(std::cell::Cell::get), 1);
+        // References plan over every reference: none off a salvaged model.
+        assert!(ask(&mut s, "textDocument/references", &text, "part def ").is_null());
+        // A hover past the statement reads the document as written.
+        let hover = ask(&mut s, "textDocument/hover", &text, "    }\n    part ");
+        let (line, _) = after(&text, "    }\n    part ");
+        assert_eq!(hover["range"]["start"]["line"], line, "{hover}");
+    }
+
+    /// The members an element inherits are named off a model whose body
+    /// may redefine them all — navigation's, built while the statement
+    /// being edited was finished — and still come back, as when the body
+    /// redefines only some: the statement being edited redefines nothing
+    /// yet.
+    #[test]
+    fn members_come_back_when_the_model_redefines_them_all() {
+        let (a, b) = ("file:///w/a.sysml", "file:///w/b.sysml");
+        let doc = |statement: &str| {
+            format!(
+                "package B {{\n    private import A::*;\n    part def D :> T1 {{\n        {statement}\n    }}\n}}\n"
+            )
+        };
+        let mut s = base_library_server();
+        put(
+            &mut s,
+            a,
+            1,
+            "package A {\n    part def T1 { attribute x; }\n}\n",
+        );
+        put(&mut s, b, 1, &doc("attribute :>> x;"));
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/inlayHint",
+                "params": {"textDocument": {"uri": b},
+                           "range": {"start": {"line": 0, "character": 0},
+                                     "end": {"line": 6, "character": 0}}}}),
+        );
+        let text = doc("attribute :>> x");
+        put(&mut s, b, 2, &text);
+        let (line, character) = after(&text, "attribute :>> x");
+        assert!(is_member(&mut s, b, line, character, "x"));
+    }
+
+    /// The members an element inherits are not named off read-only
+    /// navigation's tolerant session, which salvages the statement being
+    /// typed into the body as the declaration it reads as: a type with
+    /// two features of one name loses neither where that statement
+    /// redefines one, as a session built for the statement has it.
+    #[test]
+    fn members_are_not_named_off_a_statement_salvaged_into_the_body() {
+        let (a, b, broken) = (
+            "file:///w/a.sysml",
+            "file:///w/b.sysml",
+            "file:///w/t.sysml",
+        );
+        let text = "package B {\n    private import A::*;\n    part def E :> T1 {\n        part z;\n        \
+                    attribute :>> x\n    }\n}\n";
+        let mut s = base_library_server();
+        put(
+            &mut s,
+            a,
+            1,
+            "package A {\n    part def T1 { attribute x; part x; }\n}\n",
+        );
+        put(&mut s, broken, 1, "part def f {\n");
+        put(&mut s, b, 1, text);
+        // A hover builds the tolerant session: a unit does not parse.
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/hover",
+                "params": {"textDocument": {"uri": a},
+                           "position": {"line": 1, "character": 15}}}),
+        );
+        let (line, character) = after(text, "attribute :>> x");
+        assert!(is_member(&mut s, b, line, character, "x"));
+    }
+
+    /// A navigation session built since the last statement — inlay
+    /// hints ask for one whenever the documents parse — answers the next
+    /// member access: nothing is built for it.
+    #[test]
+    fn member_access_reads_a_navigation_session() {
+        let mut s = base_library_server();
+        let uri = "file:///w/n.sysml";
+        let body = |statements: &str| {
+            format!(
+                "package N {{\n    private import VehicleModel::*;\n    part v : Vehicle;\n    \
+                 part def D {{\n        {statements}\n    }}\n}}\n"
+            )
+        };
+        let labels = labels_after(&mut s, uri, 1, &body("attribute q = v."), "q = v.");
+        assert!(labels.contains(&"mass".to_string()), "{labels:?}");
+        put(&mut s, uri, 2, &body("attribute q = v.mass;"));
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/inlayHint",
+                "params": {"textDocument": {"uri": uri},
+                           "range": {"start": {"line": 0, "character": 0},
+                                     "end": {"line": 9, "character": 0}}}}),
+        );
+        crate::nav::SESSION_BUILDS.with(|n| n.set(0));
+        crate::nav::REUSED_ANSWERS.with(|n| n.set(0));
+        let text = body("attribute q = v.mass;\n        attribute r = v.");
+        let labels = labels_after(&mut s, uri, 3, &text, "r = v.");
+        assert!(labels.contains(&"mass".to_string()), "{labels:?}");
+        assert_eq!(crate::nav::SESSION_BUILDS.with(std::cell::Cell::get), 0);
+        assert_eq!(crate::nav::REUSED_ANSWERS.with(std::cell::Cell::get), 1);
+    }
+
+    /// A navigation session rebuilt between statements — inlay hints
+    /// ask for one whenever the document parses — reads no members
+    /// again: those named for an element stand while the text outside
+    /// its body does.
+    #[test]
+    fn a_navigation_rebuild_reads_no_members_again() {
+        let mut s = base_library_server();
+        let uri = "file:///w/n.sysml";
+        let text = |body: &str| {
+            format!(
+                "package N {{\n    private import VehicleModel::*;\n    \
+                 part def Car2 :> Vehicle {{\n        {body}\n    }}\n}}\n"
+            )
+        };
+        put(&mut s, uri, 1, &text("attribute :>> "));
+        assert!(is_member(&mut s, uri, 3, 22, "mass"));
+        put(&mut s, uri, 2, &text("attribute :>> mass;"));
+        responses(
+            &mut s,
+            &serde_json::json!({"jsonrpc": "2.0", "id": 3, "method": "textDocument/inlayHint",
+                "params": {"textDocument": {"uri": uri},
+                           "range": {"start": {"line": 0, "character": 0},
+                                     "end": {"line": 6, "character": 0}}}}),
+        );
+        crate::nav::MEMBER_READS.with(|n| n.set(0));
+        put(
+            &mut s,
+            uri,
+            3,
+            &text("attribute :>> mass;\n        port :>> "),
+        );
+        assert!(is_member(&mut s, uri, 4, 17, "fuelIn"));
+        assert_eq!(crate::nav::MEMBER_READS.with(std::cell::Cell::get), 0);
+    }
+
+    /// The library's renderings complete after `render`. This pins what
+    /// the position rules gave once they classified `render`, before the
+    /// enclosing element's members were named: nothing here depends on
+    /// those.
+    #[test]
+    fn render_offers_the_library_renderings() {
+        let mut s = base_library_server();
+        let (shown, _) = listed(
+            &mut s,
+            "file:///w/a.sysml",
+            "}\n    view def V {\n        render as|",
+        );
+        assert_eq!(shown, ["asTreeDiagram", "asElementTable"]);
+    }
+
+    /// A document is offered its own dialect's keywords only: a KerML
+    /// document no `part`, a SysML document no `const`.
+    #[test]
+    fn documents_get_their_dialects_keywords() {
+        for (uri, has, lacks) in [
+            (
+                "file:///w/k.kerml",
+                &["class", "datatype", "feature"],
+                &["part", "parallel", "calc"],
+            ),
+            (
+                "file:///w/s.sysml",
+                &["part", "calc", "constant"],
+                &["const", "datatype", "featuring"],
+            ),
+        ] {
+            let mut s = two_package_server();
+            responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "method": "textDocument/didOpen", "params": {
+                    "textDocument": {"uri": uri, "languageId": "sysml",
+                                     "version": 1, "text": "package K {\n    \n}\n"}}}),
+            );
+            let out = responses(
+                &mut s,
+                &serde_json::json!({"jsonrpc": "2.0", "id": 2, "method": "textDocument/completion",
+                    "params": {"textDocument": {"uri": uri},
+                               "position": {"line": 1, "character": 4}}}),
+            );
+            let items = out[0]["result"].as_array().expect("completion items");
+            let labels = completion_labels(items);
+            for word in has {
+                assert!(labels.contains(word), "{uri}: {word}");
+            }
+            for word in lacks {
+                assert!(!labels.contains(word), "{uri}: {word}");
+            }
+        }
+    }
+
     /// A workspace re-seed on a running server invalidates inlay hints
     /// and code lenses the client already pulled — refresh requests go
     /// out, but only to clients that declared support, and never
diff --git a/crates/sysmlv2-lsp/src/receiver.rs b/crates/sysmlv2-lsp/src/receiver.rs
new file mode 100644
index 0000000..0d877d1
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/receiver.rs
@@ -0,0 +1,401 @@
+//! Member access in the completion tier (`tank.|`, `wheels#(1).|`,
+//! `f(x).|`): the receiver written before the dot, and the element it
+//! reaches in the completion session's model — the one whose members
+//! the next step can name — and what an invocation of a callee binds:
+//! its parameters and its result.
+
+use sysmlv2_parser::ast::{Dialect, Expr, ExprKind, Name, QualifiedName, TargetRef};
+use sysmlv2_parser::json::{ElementRef, ResolvedModel};
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+
+/// A name chain (`a.b.|` → `a`, `b`) as the receiver expression it
+/// spells. Built rather than parsed: the names are the document's own,
+/// which in KerML may be words the SysML expression grammar reserves.
+pub(crate) fn chain_expr(chain: &[String]) -> Expr {
+    let name = |value: &String| QualifiedName {
+        is_global: false,
+        segments: vec![Name {
+            value: value.clone(),
+            span: Span::new(0, 0),
+        }],
+        span: Span::new(0, 0),
+    };
+    let mut links = chain.iter().map(name);
+    let head = Expr {
+        kind: links.next().map_or(ExprKind::Null, ExprKind::Ref),
+        span: Span::new(0, 0),
+    };
+    links.fold(head, |target, member| Expr {
+        kind: ExprKind::ChainStep {
+            target: Box::new(target),
+            member: TargetRef::Name(member),
+        },
+        span: Span::new(0, 0),
+    })
+}
+
+/// The receiver's span when `partial_start` (the start of the word being
+/// completed) follows a member-access dot: one that ends an index or an
+/// invocation (`wheels#(1).|`, `f(x).liq|`), or whose chain starts with a
+/// qualified name (`P::part.|`) — where a scan for a plain name chain
+/// stops at the `)` or the `::`. Read backward over the tokens of the
+/// statement starting at `stmt_start`: names joined by `.` or `::`, the
+/// first possibly rooted at the global namespace (`$::`), index and
+/// argument groups, a parenthesized head. `None` anywhere
+/// else: after a number's decimal point, or a dot inside a comment or
+/// note that starts within the statement (one that starts before
+/// `stmt_start` is out of this scan's sight).
+pub(crate) fn postfix_receiver(text: &str, stmt_start: u32, partial_start: u32) -> Option<Span> {
+    use TokenKind as K;
+    let prefix = text.get(stmt_start as usize..partial_start as usize)?;
+    let tokens: Vec<Token> = sysmlv2_parser::lexer::tokenize(prefix)
+        .0
+        .into_iter()
+        .filter(|t| !matches!(t.kind, K::Whitespace | K::Eof))
+        .collect();
+    let (dot, tokens) = tokens.split_last()?;
+    if dot.kind != K::Dot {
+        return None;
+    }
+    let i = receiver_start(tokens)?;
+    Some(Span::new(
+        stmt_start + tokens[i].span.start,
+        stmt_start + dot.span.start,
+    ))
+}
+
+/// The index of the first token of the receiver `tokens` end in, read
+/// backward (see [`postfix_receiver`]); `None` when they end in
+/// something else, or run out before its head.
+pub(crate) fn receiver_start(tokens: &[Token]) -> Option<usize> {
+    use TokenKind as K;
+    let is_name = |k: Option<K>| matches!(k, Some(K::Ident | K::UnrestrictedName));
+    let mut i = tokens.len();
+    loop {
+        // One operand, ending at `tokens[i - 1]`.
+        match tokens[..i].last()?.kind {
+            K::Ident | K::UnrestrictedName => i -= 1,
+            K::RParen => {
+                i = matching_open(&tokens[..i])?;
+                let before = tokens[..i].last().map(|t| t.kind);
+                if before == Some(K::Hash) {
+                    // `x#(i)`: the operand indexed comes next.
+                    i -= 1;
+                    continue;
+                }
+                if !is_name(before) {
+                    // `(expr)`: a parenthesized head.
+                    break;
+                }
+                // `f(args)`: the name invoked.
+                i -= 1;
+            }
+            _ => return None,
+        }
+        match tokens[..i].last().map(|t| t.kind) {
+            // `$::a…`: the global namespace heads the name.
+            Some(K::ColonColon) if i >= 2 && tokens[i - 2].kind == K::Dollar => {
+                i -= 2;
+                break;
+            }
+            Some(K::Dot | K::ColonColon) => i -= 1,
+            _ => break,
+        }
+    }
+    Some(i)
+}
+
+/// The receiver expression `text` spells in `dialect`. The expression
+/// grammar reserves the SysML words; in KerML, where most of them are
+/// ordinary names (`part`, `port`), those are quoted first.
+pub(crate) fn parse_receiver(text: &str, dialect: Dialect) -> Option<Expr> {
+    use sysmlv2_parser::parser::is_reserved;
+    if dialect == Dialect::Sysml {
+        return sysmlv2_parser::parser::parse_expression(text).expr;
+    }
+    let mut spelled = String::with_capacity(text.len());
+    let mut at = 0;
+    for t in sysmlv2_parser::lexer::tokenize(text).0 {
+        let (start, end) = (t.span.start as usize, t.span.end as usize);
+        let word = &text[start..end];
+        if t.kind == TokenKind::Ident
+            && is_reserved(Dialect::Sysml, word)
+            && !is_reserved(Dialect::Kerml, word)
+        {
+            spelled.push_str(&text[at..start]);
+            spelled.push('\'');
+            spelled.push_str(word);
+            spelled.push('\'');
+            at = end;
+        }
+    }
+    spelled.push_str(&text[at..]);
+    sysmlv2_parser::parser::parse_expression(&spelled).expr
+}
+
+/// The index of the `(` matching the `)` that ends `tokens`; `None` when
+/// the groups do not balance.
+fn matching_open(tokens: &[Token]) -> Option<usize> {
+    use TokenKind as K;
+    let mut depth = 0usize;
+    for (i, t) in tokens.iter().enumerate().rev() {
+        match t.kind {
+            K::RParen | K::RBracket | K::RBrace => depth += 1,
+            K::LParen | K::LBracket | K::LBrace => {
+                depth = depth.checked_sub(1)?;
+                if depth == 0 {
+                    return (t.kind == K::LParen).then_some(i);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// The user declarations in `unit` whose extent holds offset `at`,
+/// innermost first: the scopes a name written there resolves from.
+pub(crate) fn enclosing_declarations(
+    resolved: &ResolvedModel,
+    unit: usize,
+    at: u32,
+) -> Vec<ElementRef> {
+    let mut enclosing: Vec<(ElementRef, u32)> = resolved
+        .user_elements()
+        .filter_map(|e| {
+            let (u, span) = resolved.member_extent(e)?;
+            (u == unit && span.start <= at && at <= span.end).then(|| (e, span.len()))
+        })
+        .collect();
+    enclosing.sort_by_key(|&(_, len)| len);
+    enclosing.into_iter().map(|(e, _)| e).collect()
+}
+
+/// The element `receiver` reaches, resolved the way the evaluator
+/// resolves it: a head name from the innermost of the `enclosing`
+/// declarations outward, each chain step as a member of the element
+/// before it, an indexed feature as itself (its elements have its
+/// types), an invocation as its callee's result parameter. `None` for
+/// what does not resolve and for any other expression.
+pub(crate) fn receiver_element(
+    resolved: &mut ResolvedModel,
+    enclosing: &[ElementRef],
+    receiver: &Expr,
+) -> Option<ElementRef> {
+    receiver_reached(resolved, enclosing, receiver, &mut Vec::new())
+}
+
+/// [`receiver_element`], recording in `reached` every element the
+/// resolution reaches on the way — the head's, each step's, an
+/// invocation's callee — and the one it returns: the declarations whose
+/// text decides the answer.
+pub(crate) fn receiver_reached(
+    resolved: &mut ResolvedModel,
+    enclosing: &[ElementRef],
+    receiver: &Expr,
+    reached: &mut Vec<ElementRef>,
+) -> Option<ElementRef> {
+    let hit = match &receiver.kind {
+        ExprKind::Ref(name) => resolve_head(resolved, enclosing, name, reached),
+        ExprKind::ChainStep { target, member } => {
+            let target = receiver_reached(resolved, enclosing, target, reached)?;
+            members_along(resolved, target, target_links(member), reached)
+        }
+        ExprKind::Index { target, .. } => receiver_reached(resolved, enclosing, target, reached),
+        ExprKind::Invocation { ty, .. } => {
+            let (head, rest) = target_links(ty).split_first()?;
+            let callee = resolve_head(resolved, enclosing, head, reached)?;
+            reached.push(callee);
+            let callee = members_along(resolved, callee, rest, reached)?;
+            result_parameter(resolved, callee)
+        }
+        _ => None,
+    }?;
+    reached.push(hit);
+    Some(hit)
+}
+
+/// A reference's links: one qualified name, or a chain's.
+fn target_links(target: &TargetRef) -> &[QualifiedName] {
+    match target {
+        TargetRef::Name(name) => std::slice::from_ref(name),
+        TargetRef::Chain(links) => links,
+    }
+}
+
+/// A head name, resolved from the innermost enclosing declaration
+/// outward, the root namespace last — or, spelled from the global
+/// namespace (`$::a`), from the root alone. Each namespace a qualified
+/// name passes through on the way (`P` of `P::x`) is recorded in
+/// `reached`.
+fn resolve_head(
+    resolved: &mut ResolvedModel,
+    enclosing: &[ElementRef],
+    name: &QualifiedName,
+    reached: &mut Vec<ElementRef>,
+) -> Option<ElementRef> {
+    let root = resolved.root_scope();
+    let mut resolve = |name: &QualifiedName| {
+        if name.is_global {
+            return resolved.resolve_in(root, name);
+        }
+        enclosing
+            .iter()
+            .find_map(|&e| resolved.member_of(e, name).map(|(hit, _)| hit))
+            .or_else(|| resolved.resolve_in(root, name))
+    };
+    for len in 1..name.segments.len() {
+        let path = QualifiedName {
+            segments: name.segments[..len].to_vec(),
+            ..name.clone()
+        };
+        reached.extend(resolve(&path));
+    }
+    resolve(name)
+}
+
+/// `from.l1.l2…`: each link resolved as a member of the element before
+/// it, the way the evaluator steps a chain, each recorded in `reached`.
+fn members_along(
+    resolved: &mut ResolvedModel,
+    from: ElementRef,
+    links: &[QualifiedName],
+    reached: &mut Vec<ElementRef>,
+) -> Option<ElementRef> {
+    links.iter().try_fold(from, |cur, link| {
+        let hit = resolved.member_of(cur, link).map(|(hit, _)| hit)?;
+        reached.push(hit);
+        Some(hit)
+    })
+}
+
+/// A callee's result parameter: its own `return`, else the nearest one
+/// its written specializations declare (a calculation usage typed by
+/// its definition, a definition specializing another).
+pub(crate) fn result_parameter(
+    resolved: &mut ResolvedModel,
+    callee: ElementRef,
+) -> Option<ElementRef> {
+    nearest_in_heritage(resolved, callee, |resolved, e| {
+        resolved.calc_return_param(e)
+    })
+}
+
+/// The first answer `find` gives over `from` and its written heritage,
+/// nearest first: what it is typed by or specializes, then theirs.
+pub(crate) fn nearest_in_heritage<T>(
+    resolved: &mut ResolvedModel,
+    from: ElementRef,
+    mut find: impl FnMut(&mut ResolvedModel, ElementRef) -> Option<T>,
+) -> Option<T> {
+    let mut visited = std::collections::HashSet::new();
+    let mut frontier = std::collections::VecDeque::from([from]);
+    while let Some(e) = frontier.pop_front() {
+        if !visited.insert(e) {
+            continue;
+        }
+        if let Some(found) = find(resolved, e) {
+            return Some(found);
+        }
+        frontier.extend(resolved.explicit_supertypes(e));
+    }
+    None
+}
+
+/// The parameters an invocation of `callee` binds its arguments to, in
+/// order, each with its name: the model's own reading of the callee's
+/// written heritage (see `ResolvedModel::callable_parameters`), so
+/// signature help lists exactly what an evaluation binds — the directed
+/// features, the result aside, it owns, then each general's in the order
+/// written, but for those its own redefine. An own parameter takes over
+/// each general's at its place even when it also redefines one
+/// explicitly: `calc def D :> Diff { in :>> b; }` has the one parameter
+/// `b`. A callee whose heritage the model cannot read (a specialization
+/// cycle) lists the parameters it owns.
+pub(crate) fn parameters(
+    resolved: &mut ResolvedModel,
+    callee: ElementRef,
+) -> Vec<(ElementRef, Option<String>)> {
+    if let Some(parameters) = resolved.callable_parameters(callee) {
+        return parameters
+            .into_iter()
+            .map(|p| (p.element, (!p.name.is_empty()).then_some(p.name)))
+            .collect();
+    }
+    resolved
+        .owned_features(callee)
+        .into_iter()
+        .filter(|&p| {
+            resolved.declared_direction(p).is_some()
+                && resolved.owning_membership_type(p) != Some("ReturnParameterMembership")
+        })
+        .map(|p| (p, feature_name(resolved, p)))
+        .collect()
+}
+
+/// Whether an argument binds parameter `p`: an input, `in` or `inout`.
+/// An invocation's arguments take the callee's inputs in order, so an
+/// output holds no argument position (`f(x, y)` for `f { out o; in x;
+/// in y; }`), as evaluation binds them.
+pub(crate) fn binds_argument(resolved: &ResolvedModel, p: ElementRef) -> bool {
+    resolved.declared_direction(p) != Some("out")
+}
+
+/// A feature's name — a parameter's, a callable's: the one declared,
+/// else that of what it redefines as written (`in :>> m` is `m`, `calc
+/// :>> ke` is `ke`).
+pub(crate) fn feature_name(resolved: &ResolvedModel, e: ElementRef) -> Option<String> {
+    resolved
+        .element_name(e)
+        .map(str::to_string)
+        .or_else(|| resolved.element_lookup_name(e))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::postfix_receiver;
+    use crate::position::offset32;
+
+    /// The receiver `postfix_receiver` reads before the end of `text`.
+    fn receiver(text: &str) -> Option<&str> {
+        let span = postfix_receiver(text, 0, offset32(text.len()))?;
+        Some(&text[span.start as usize..span.end as usize])
+    }
+
+    #[test]
+    fn index_and_invocation_receivers() {
+        for (text, expected) in [
+            ("attribute d = vehicle1.wheels#(1).", "vehicle1.wheels#(1)"),
+            (
+                "attribute e = KineticEnergy(1 [kg], 2 [m/s]).",
+                "KineticEnergy(1 [kg], 2 [m/s])",
+            ),
+            ("attribute e = Calcs::f(x).", "Calcs::f(x)"),
+            ("attribute e = a.f(x).g.", "a.f(x).g"),
+            ("attribute e = xs#(1)#(2).", "xs#(1)#(2)"),
+            ("attribute e = 2 * (a + b).", "(a + b)"),
+            ("attribute e = 'my part'.", "'my part'"),
+        ] {
+            assert_eq!(receiver(text), Some(expected), "{text:?}");
+        }
+    }
+
+    #[test]
+    fn no_receiver_without_a_member_dot() {
+        for text in [
+            // a decimal point, a range, no dot at all
+            "attribute x = 5.",
+            "part w : Wheel [0..",
+            "attribute e = f(x)",
+            // a dot in a note or a string
+            "attribute e = a. // see f(x).",
+            "attribute s = \"f(x).",
+            // groups that do not balance
+            "attribute e = f(x)).",
+            "attribute e = [x).",
+        ] {
+            assert_eq!(receiver(text), None, "{text:?}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/reuse.rs b/crates/sysmlv2-lsp/src/reuse.rs
new file mode 100644
index 0000000..5bf4d63
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/reuse.rs
@@ -0,0 +1,1440 @@
+//! Answering the statement being typed off a model built from other
+//! texts. What a member access reaches, the units a bracket takes, the
+//! signature of the callable invoked: each such answer reads a few
+//! declarations and looks up a few names, so a session already built —
+//! for an earlier statement, or for navigation — answers as a new one
+//! would wherever the texts it was built from differ from those a build
+//! for the statement would read only where the answer does not look.
+//!
+//! [`Changes`] is where the two sets of texts differ, statement by
+//! statement; [`Needs`] is what an answer read in the built model, which
+//! [`Reach`] follows to the declarations whose text decides it and the
+//! names their headers look up; [`Imports`] is what the session's imports
+//! make every answer depend on; [`Changes::allow`] tells whether the
+//! changes leave all that alone. Both err towards a build: a change the
+//! check cannot place — one opening or closing a body, a unit that parses
+//! in one set only, an import, a parameter that redefines by position, a
+//! change where a recursive import sees — takes one.
+
+use std::collections::HashSet;
+use sysmlv2_parser::ast::{Dialect, Expr, ExprKind, Name, QualifiedName, TargetRef};
+use sysmlv2_parser::json::{ElementRef, ResolvedModel};
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+use sysmlv2_transform::Session;
+
+/// What an answer read in the model it was read off.
+#[derive(Default)]
+pub(crate) struct Needs {
+    /// The names it looked up.
+    names: HashSet<String>,
+    /// The declarations it read whole, and — through them — their
+    /// general types.
+    reads: Vec<ElementRef>,
+    /// The declarations a name resolved from: their headers, and their
+    /// general types whole.
+    scopes: Vec<ElementRef>,
+    /// Whether it listed the workspace's measurement units.
+    units: bool,
+}
+
+impl Needs {
+    /// A name the answer looked up.
+    pub(crate) fn name(&mut self, name: &str) {
+        self.names.insert(name.to_string());
+    }
+
+    /// Every segment of a name the answer looked up.
+    pub(crate) fn qualified(&mut self, qn: &QualifiedName) {
+        for segment in &qn.segments {
+            self.name(&segment.value);
+        }
+    }
+
+    /// Every name `expr` spells as a reference or a member step — the
+    /// names resolving a receiver looks up.
+    pub(crate) fn expr(&mut self, expr: &Expr) {
+        match &expr.kind {
+            ExprKind::Ref(qn) => self.qualified(qn),
+            ExprKind::ChainStep { target, member } => {
+                self.expr(target);
+                self.target(member);
+            }
+            ExprKind::Index { target, .. } => self.expr(target),
+            ExprKind::Invocation { ty, .. } => self.target(ty),
+            _ => {}
+        }
+    }
+
+    fn target(&mut self, target: &TargetRef) {
+        match target {
+            TargetRef::Name(qn) => self.qualified(qn),
+            TargetRef::Chain(links) => links.iter().for_each(|qn| self.qualified(qn)),
+        }
+    }
+
+    /// A declaration the answer read whole.
+    pub(crate) fn read(&mut self, e: ElementRef) {
+        self.reads.push(e);
+    }
+
+    /// The declarations a name was resolved from, innermost first.
+    pub(crate) fn scopes(&mut self, enclosing: &[ElementRef]) {
+        self.scopes.extend_from_slice(enclosing);
+    }
+
+    /// The answer listed the workspace's measurement units.
+    pub(crate) fn units(&mut self) {
+        self.units = true;
+    }
+
+    /// What reading a unit bracket's context — the operand its value is
+    /// compared with or added to, or the callable it is an argument of
+    /// (see [`crate::units::Context`]) — looks up: the names the operand
+    /// or the callable's name spells, and the elements they resolve to,
+    /// the unit an operand carries included, and the callable's
+    /// parameters, its own and those it inherits, one of which the
+    /// argument binds.
+    pub(crate) fn context(
+        &mut self,
+        resolved: &mut ResolvedModel,
+        enclosing: &[ElementRef],
+        text: &str,
+        context: &crate::units::Context,
+        dialect: Dialect,
+    ) {
+        let span = match context {
+            crate::units::Context::Operand(span) => span,
+            crate::units::Context::Argument { callee, .. } => callee,
+        };
+        let Some(expr) = text
+            .get(span.start as usize..span.end as usize)
+            .and_then(|spelled| crate::receiver::parse_receiver(spelled, dialect))
+        else {
+            return;
+        };
+        let read = match &expr.kind {
+            ExprKind::Bracket { arg, .. } => arg,
+            _ => &expr,
+        };
+        self.expr(read);
+        let reached = crate::receiver::receiver_reached(resolved, enclosing, read, &mut self.reads);
+        if let (crate::units::Context::Argument { .. }, Some(callee)) = (context, reached) {
+            let parameters = crate::receiver::parameters(resolved, callee);
+            self.reads.extend(parameters.into_iter().map(|(p, _)| p));
+        }
+    }
+
+    /// What reading the declaration `header` — a statement's text ahead
+    /// of its value, declared in the innermost of `enclosing` — looks
+    /// up: every name it spells, and the elements its types and the
+    /// features it specializes or redefines resolve to, with the feature
+    /// of its own name the innermost declaration has.
+    pub(crate) fn declaration(
+        &mut self,
+        resolved: &mut ResolvedModel,
+        enclosing: &[ElementRef],
+        header: &str,
+        dialect: Dialect,
+    ) {
+        for t in significant(header) {
+            if let Some(name) = name_of(&t, header, dialect) {
+                self.names.insert(name);
+            }
+        }
+        let source = format!("{header};");
+        let parse = match dialect {
+            Dialect::Kerml => sysmlv2_parser::parser::parse_kerml_source(&source),
+            Dialect::Sysml => sysmlv2_parser::parser::parse_source(&source),
+        };
+        let Some(usage) = parse.unit.members.last().and_then(|m| match &m.kind {
+            sysmlv2_parser::ast::MemberKind::Usage(u)
+            | sysmlv2_parser::ast::MemberKind::Return(u) => Some(u),
+            _ => None,
+        }) else {
+            return;
+        };
+        let scope = enclosing
+            .first()
+            .and_then(|&e| resolved.element_scope(e))
+            .unwrap_or_else(|| resolved.root_scope());
+        for spec in &usage.declaration.specializations {
+            use sysmlv2_parser::ast::FeatureSpecialization as F;
+            let targets: Vec<&TargetRef> = match spec {
+                F::TypedBy(types) => types.iter().map(|t| &t.target).collect(),
+                F::Redefines(targets) | F::Subsets(targets) => targets.iter().collect(),
+                _ => Vec::new(),
+            };
+            for target in targets {
+                if let TargetRef::Name(qn) = target {
+                    if let Some(e) = resolved.resolve_in(scope, qn) {
+                        self.reads.push(e);
+                    }
+                }
+            }
+        }
+        if let (Some(&owner), Some(name)) = (enclosing.first(), &usage.declaration.id.name) {
+            let own = QualifiedName {
+                is_global: false,
+                segments: vec![name.clone()],
+                span: Span::new(0, 0),
+            };
+            if let Some((e, _)) = resolved.member_of(owner, &own) {
+                self.reads.push(e);
+            }
+        }
+    }
+}
+
+/// Where the texts a session was built from differ from those a build
+/// for the statement would read, and where the statement starts in the
+/// built text of its unit.
+pub(crate) struct Changes {
+    /// The statement's start in the session's text of its unit.
+    pub(crate) at: u32,
+    units: Vec<Changed>,
+}
+
+/// One unit's changed statements.
+struct Changed {
+    name: String,
+    /// Where they are in the built text: the bytes they span, or, where
+    /// statements were only added, the gap between the tokens around
+    /// them. A declaration overlapping it holds a change.
+    lo: u32,
+    hi: u32,
+    /// Only added in the new text: `lo..hi` is a gap, not a span.
+    insertion: bool,
+    /// They sit at the unit's top level, among the root namespace's
+    /// members.
+    top: bool,
+    /// Every name the headers of the changed statements, either text's,
+    /// may declare or name them after.
+    declared: HashSet<String>,
+    /// A header holds what changes the names a namespace makes visible
+    /// without spelling them (see [`OPAQUE`]).
+    opaque: bool,
+    /// The types and features the changed declarations, at any depth,
+    /// are typed by, specialize, subset, or redefine: a unit declared or
+    /// taken away is one typed by a measurement reference.
+    targets: Vec<Target>,
+}
+
+impl Changed {
+    /// Nothing changed yet in the unit `name`.
+    fn new(name: String) -> Changed {
+        Changed {
+            name,
+            lo: 0,
+            hi: 0,
+            insertion: false,
+            top: false,
+            declared: HashSet::new(),
+            opaque: false,
+            targets: Vec::new(),
+        }
+    }
+}
+
+/// A name a changed declaration's header refers to.
+struct Target {
+    name: QualifiedName,
+    /// A redefinition's or a reference subsetting's target, resolved
+    /// among the general types' features rather than from the
+    /// declaration's scope.
+    inherited: bool,
+}
+
+/// Words whose statements change what a namespace makes visible, or name
+/// a feature after one they redefine without spelling it: imports and
+/// what filters them, aliases, parameters and the memberships that
+/// redefine by position or by kind, annotations, and the relationships a
+/// KerML statement adds to elements declared elsewhere.
+const OPAQUE: &[&str] = &[
+    "actor",
+    "alias",
+    "assume",
+    "conjugate",
+    "conjugation",
+    "disjoining",
+    "disjoint",
+    "do",
+    "end",
+    "entry",
+    "exit",
+    "expose",
+    "featuring",
+    "filter",
+    "frame",
+    "import",
+    "in",
+    "inout",
+    "inverse",
+    "member",
+    "multiplicity",
+    "objective",
+    "out",
+    "redefinition",
+    "render",
+    "require",
+    "return",
+    "specialization",
+    "stakeholder",
+    "subclassifier",
+    "subject",
+    "subset",
+    "subtype",
+    "typing",
+    "verify",
+];
+
+/// A text's significant tokens: all but whitespace and notes.
+fn significant(text: &str) -> Vec<Token> {
+    sysmlv2_parser::lexer::tokenize(text)
+        .0
+        .into_iter()
+        .filter(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof)
+        .collect()
+}
+
+/// Whether a token ends a statement or opens or closes a body.
+fn separates(t: &Token) -> bool {
+    matches!(
+        t.kind,
+        TokenKind::Semi | TokenKind::LBrace | TokenKind::RBrace
+    )
+}
+
+/// Whether `tokens` open and close their bodies alike, none closing one
+/// opened before them.
+fn balanced(tokens: &[Token]) -> bool {
+    let mut depth = 0usize;
+    for t in tokens {
+        match t.kind {
+            TokenKind::LBrace => depth += 1,
+            TokenKind::RBrace => match depth.checked_sub(1) {
+                Some(d) => depth = d,
+                None => return false,
+            },
+            _ => {}
+        }
+    }
+    depth == 0
+}
+
+/// A name token's name: an identifier that is no reserved word, or an
+/// unrestricted name, unquoted.
+fn name_of(t: &Token, text: &str, dialect: Dialect) -> Option<String> {
+    let word = t.text(text);
+    match t.kind {
+        TokenKind::Ident if !sysmlv2_parser::parser::is_reserved(dialect, word) => {
+            Some(word.to_string())
+        }
+        TokenKind::UnrestrictedName => Some(sysmlv2_parser::lexer::unescape(word)),
+        _ => None,
+    }
+}
+
+fn dialect(unit: &str) -> Dialect {
+    if crate::is_kerml(unit) {
+        Dialect::Kerml
+    } else {
+        Dialect::Sysml
+    }
+}
+
+impl Changes {
+    /// How `built` — the units a session was built from, by name, in
+    /// its order — differs from `fresh`, the units a build for the
+    /// statement starting at `at` in `unit` would read, and where the
+    /// statement starts in the built text. `None` where the check cannot
+    /// place a change: the units are not the same, a change opens or
+    /// closes a body or holds a token in error, or the statement touches
+    /// one.
+    pub(crate) fn between<'a>(
+        built: impl Iterator<Item = (&'a str, &'a str)>,
+        fresh: &[(String, String)],
+        unit: &str,
+        at: u32,
+    ) -> Option<Changes> {
+        let built: Vec<(&str, &str)> = built.collect();
+        if built.len() != fresh.len() {
+            return None;
+        }
+        let mut units = Vec::new();
+        let mut mapped = None;
+        for ((name, old), (fresh_name, new)) in built.iter().zip(fresh) {
+            if name != fresh_name {
+                return None;
+            }
+            let here = *name == unit;
+            if old == new {
+                if here {
+                    mapped = Some(at);
+                }
+                continue;
+            }
+            let diff = Diff::of(old, new)?;
+            if here {
+                mapped = Some(diff.map(old, at)?);
+            }
+            if let Some(changed) = diff.changed(name, old, new) {
+                units.push(changed);
+            }
+        }
+        Some(Changes { at: mapped?, units })
+    }
+
+    /// Whether an answer that read `needs` in `session` — the one these
+    /// changes were taken against — is the answer a session built from
+    /// the new texts would give: no changed statement holds an import or
+    /// the like, declares a name at the top level or one the answer's
+    /// names resolve through, declares, where the session's imports look,
+    /// a name they look up, or lies in a declaration the answer read (see
+    /// [`Reach`]) or one the imports bring members in from (see
+    /// [`Imports`]).
+    pub(crate) fn allow(&self, session: &mut Session, needs: &Needs, imports: &Imports) -> bool {
+        if self.units.is_empty() {
+            return true;
+        }
+        if self
+            .units
+            .iter()
+            .any(|c| c.opaque || (c.top && !c.declared.is_empty()))
+        {
+            return false;
+        }
+        // The model's index of each changed unit.
+        let Some(indices) = self
+            .units
+            .iter()
+            .map(|c| {
+                session
+                    .units()
+                    .find(|(_, n, _)| *n == c.name)
+                    .map(|(i, _, _)| i)
+            })
+            .collect::<Option<Vec<usize>>>()
+        else {
+            return false;
+        };
+        if needs.units && !self.units_unchanged(session.resolved(), &indices) {
+            return false;
+        }
+        let mut reach = Reach::default();
+        reach.walk(session, &needs.scopes, &needs.reads, true);
+        let named = |d: &String| needs.names.contains(d) || reach.names.contains(d);
+        let read = |unit: usize, c: &Changed| {
+            reach
+                .spans
+                .iter()
+                .chain(&imports.reach.spans)
+                .any(|&(u, s)| u == unit && s.start < c.hi && c.lo < s.end)
+        };
+        let resolved = session.resolved();
+        self.units.iter().zip(&indices).all(|(c, &unit)| {
+            // What the changed statements declare is a member of the
+            // declaration around them, which the lookups behind the
+            // imports' names see or not.
+            let imported = || {
+                around(resolved, unit, c).is_none_or(|a| imports.scopes.contains(&a))
+                    && c.declared.iter().any(|d| imports.reach.names.contains(d))
+            };
+            !c.declared.iter().any(named) && !read(unit, c) && !imported()
+        })
+    }
+
+    /// Whether the changed declarations leave the workspace's units as
+    /// they are: none, at any depth, typed by, specializing, or
+    /// redefining a measurement reference or a unit, as the built model
+    /// resolves their targets from where they are declared, and none
+    /// named as another member of the namespace around it. A target
+    /// that does not resolve there, or whose first name the changes
+    /// declare, cannot be told apart from one that does.
+    fn units_unchanged(&self, resolved: &mut ResolvedModel, indices: &[usize]) -> bool {
+        let Some(reference) =
+            resolved.resolve_qualified("MeasurementReferences::TensorMeasurementReference")
+        else {
+            // No measurement reference: nothing is a unit.
+            return true;
+        };
+        for (c, &unit) in self.units.iter().zip(indices) {
+            let holder = around(resolved, unit, c);
+            // A unit is listed by its qualified name, which another
+            // declaration of its name beside it makes resolve elsewhere.
+            if let Some(holder) = holder {
+                let apart = |s: Span| s.end <= c.lo || c.hi <= s.start;
+                let twice = resolved.owned_members(holder).into_iter().any(|m| {
+                    [
+                        resolved.element_name(m),
+                        resolved.element_declared_short_name(m),
+                    ]
+                    .into_iter()
+                    .flatten()
+                    .any(|n| c.declared.contains(n))
+                        && resolved
+                            .member_extent(m)
+                            .is_none_or(|(u, s)| u != unit || apart(s))
+                });
+                if twice {
+                    return false;
+                }
+            }
+            if c.targets.is_empty() {
+                continue;
+            }
+            let scope = holder
+                .and_then(|e| resolved.element_scope(e))
+                .unwrap_or_else(|| resolved.root_scope());
+            for target in &c.targets {
+                let captured = !target.inherited
+                    && target
+                        .name
+                        .segments
+                        .first()
+                        .is_some_and(|s| c.declared.contains(&s.value));
+                let Some(t) = resolved
+                    .resolve_in(scope, &target.name)
+                    .filter(|_| !captured)
+                else {
+                    return false;
+                };
+                if resolved.conforms(t, reference)
+                    || resolved
+                        .typings(t)
+                        .into_iter()
+                        .any(|d| resolved.conforms(d, reference))
+                {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}
+
+/// The innermost user declaration around the changed statements `c` of
+/// `unit`: its body holds them.
+fn around(resolved: &ResolvedModel, unit: usize, c: &Changed) -> Option<ElementRef> {
+    resolved
+        .user_elements()
+        .filter_map(|e| {
+            let (u, s) = resolved.member_extent(e)?;
+            let holds = if c.insertion {
+                s.start < c.hi && c.lo < s.end
+            } else {
+                s.start < c.lo && c.hi < s.end
+            };
+            (u == unit && holds).then(|| (e, s.len()))
+        })
+        .min_by_key(|&(_, len)| len)
+        .map(|(e, _)| e)
+}
+
+/// The text an answer, or what a session's imports bring in, depends on
+/// (see [`Reach::walk`]): the declarations whose text decides it, and the
+/// names their headers look up — declaring one of those changes what the
+/// header resolves to.
+#[derive(Default)]
+pub(crate) struct Reach {
+    spans: Vec<(usize, Span)>,
+    names: HashSet<String>,
+    /// The namespaces the headers read resolve from.
+    origins: HashSet<ElementRef>,
+    /// The namespaces their qualified names look into (`P` of `P::T`).
+    inside: HashSet<ElementRef>,
+}
+
+impl Reach {
+    /// Takes in what `headers` and `whole` depend on. Of a declaration in
+    /// `headers` — one a name resolved from or looked into, a namespace an
+    /// import brings in the members of — its header: the names it spells;
+    /// whole, the types and features its targets resolve to and the
+    /// general types the model reports, which its members come from; as a
+    /// header, each namespace a target's path looks into (`P` and `P::Q`
+    /// of `P::Q::T`). Of one in `whole` — one an answer read — its whole
+    /// text as well, and, with `members`, every namespace a member it
+    /// inherits is declared in: a general type re-exporting what it
+    /// imports, or one the inheritance walk reaches where the targets do
+    /// not resolve as written. An element without a declaration of its
+    /// own — the conjugate of a port definition — stands for the
+    /// declaration that owns it. Library elements are left out: no
+    /// workspace text changes them.
+    pub(crate) fn walk(
+        &mut self,
+        session: &mut Session,
+        headers: &[ElementRef],
+        whole: &[ElementRef],
+        members: bool,
+    ) {
+        let mut seen = HashSet::new();
+        let mut walk: Vec<(ElementRef, bool)> = headers
+            .iter()
+            .map(|&e| (e, false))
+            .chain(whole.iter().map(|&e| (e, true)))
+            .collect();
+        while let Some((e, entire)) = walk.pop() {
+            if !seen.insert((e, entire)) {
+                continue;
+            }
+            let resolved = session.resolved();
+            if resolved.is_library_element(e) {
+                continue;
+            }
+            let Some((unit, span)) = resolved.member_extent(e) else {
+                walk.extend(resolved.owner(e).map(|owner| (owner, entire)));
+                continue;
+            };
+            if entire {
+                self.spans.push((unit, span));
+            }
+            walk.extend(
+                resolved
+                    .explicit_supertypes(e)
+                    .into_iter()
+                    .map(|t| (t, true)),
+            );
+            if members && entire {
+                for m in resolved.inherited_memberships(e, false) {
+                    walk.extend(resolved.owner(m).map(|owner| (owner, true)));
+                }
+            }
+            // The header resolves from the namespace around it.
+            let owner = resolved.owner(e);
+            self.origins.extend(owner);
+            let scope = owner
+                .and_then(|owner| resolved.element_scope(owner))
+                .unwrap_or_else(|| resolved.root_scope());
+            let Some(header) = Header::of(session, unit, span) else {
+                continue;
+            };
+            self.names.extend(header.names);
+            let resolved = session.resolved();
+            for target in &header.targets {
+                let last = target.segments.len();
+                for len in 1..=last {
+                    let path = QualifiedName {
+                        is_global: target.is_global,
+                        segments: target.segments[..len].to_vec(),
+                        span: Span::new(0, 0),
+                    };
+                    let Some(t) = resolved.resolve_in_excluding(scope, &path, Some(e)) else {
+                        // Nothing further resolves: what the rest names is
+                        // among the header's names.
+                        break;
+                    };
+                    // A namespace on the way is looked into: its header, and
+                    // its general types whole; the target, whole.
+                    if len < last {
+                        self.inside.insert(t);
+                    }
+                    walk.push((t, len == last));
+                }
+            }
+        }
+    }
+}
+
+/// A declaration's header — through its body's `{`, all of it without a
+/// body — as resolving it reads it.
+struct Header {
+    /// Every name it spells.
+    names: Vec<String>,
+    /// What it is typed by, specializes, subsets, or redefines.
+    targets: Vec<QualifiedName>,
+}
+
+impl Header {
+    /// The header of the declaration spanning `span` of the session's
+    /// unit `unit`; `None` for a unit the session holds no text of.
+    fn of(session: &Session, unit: usize, span: Span) -> Option<Header> {
+        let (_, name, text) = session.units().find(|(i, _, _)| *i == unit)?;
+        let member = text.get(span.start as usize..span.end as usize)?;
+        // A header ends early in a member's text: read that far first.
+        let end = |tokens: &[Token]| {
+            let mut depth = 0usize;
+            tokens.iter().position(|t| {
+                match t.kind {
+                    TokenKind::LParen | TokenKind::LBracket => depth += 1,
+                    TokenKind::RParen | TokenKind::RBracket => depth = depth.saturating_sub(1),
+                    _ => {}
+                }
+                depth == 0 && t.kind == TokenKind::LBrace
+            })
+        };
+        let near = member
+            .char_indices()
+            .nth(HEADER_BYTES)
+            .map_or(member, |(i, _)| &member[..i]);
+        let mut tokens = significant(near);
+        let stop = match end(&tokens) {
+            Some(stop) => stop,
+            None if near.len() < member.len() => {
+                tokens = significant(member);
+                end(&tokens).unwrap_or(tokens.len())
+            }
+            None => tokens.len(),
+        };
+        let header = &tokens[..stop];
+        let dialect = dialect(name);
+        let mut scanned = Changed::new(String::new());
+        scan(member, header, dialect, &mut scanned);
+        Some(Header {
+            names: header
+                .iter()
+                .filter_map(|t| name_of(t, member, dialect))
+                .collect(),
+            targets: scanned.targets.into_iter().map(|t| t.name).collect(),
+        })
+    }
+}
+
+/// How much of a member's text [`Header::of`] reads first.
+const HEADER_BYTES: usize = 4096;
+
+/// An import, alias, expose, or filter statement (see [`Imports::of`]).
+struct Site {
+    /// Its model unit, and where it starts there.
+    unit: usize,
+    at: u32,
+    /// The qualified names it spells, in order: an import's target first.
+    paths: Vec<QualifiedName>,
+    /// It is a filter member, which filters its namespace's imports.
+    filter: bool,
+    /// A condition filters what it brings in.
+    filtered: bool,
+}
+
+/// What a session's import, alias, expose, and filter statements make an
+/// answer depend on: the names they spell — declaring one where they
+/// look changes what they bring in — and what their targets' members
+/// come from: a recursive import's target whole, as everything in it (a
+/// recursive import sees into its nested namespaces, and into what the
+/// types there inherit), and as a header each namespace an import
+/// brings in the members of and each one their names look into (see
+/// [`Reach::walk`]). Worked out once per session.
+pub(crate) struct Imports {
+    reach: Reach,
+    /// The namespaces whose own members the lookups behind those names
+    /// see: each that a lookup starts from, or passes on the way out, and
+    /// each a namespace import brings the members of. Only a change
+    /// declaring members of one of them can change what those names find.
+    scopes: HashSet<ElementRef>,
+}
+
+impl Imports {
+    pub(crate) fn of(session: &mut Session) -> Imports {
+        let mut reach = Reach::default();
+        // Where each such statement stands, by model unit, the qualified
+        // names it spells, and whether a condition filters what it brings
+        // in.
+        let mut sites: Vec<Site> = Vec::new();
+        // The names a filter's condition spells: what it evaluates reads
+        // the metadata those name, their default values above all.
+        let mut conditions: HashSet<String> = HashSet::new();
+        for (unit, name, text) in session.units() {
+            let dialect = dialect(name);
+            let (mut statement, mut condition) = (false, 0usize);
+            let mut path: Vec<Name> = Vec::new();
+            for t in significant(text) {
+                if t.kind == TokenKind::Ident
+                    && matches!(t.text(text), "import" | "alias" | "expose" | "filter")
+                {
+                    statement = true;
+                    let filter = t.text(text) == "filter";
+                    condition = usize::from(filter);
+                    sites.push(Site {
+                        unit,
+                        at: t.span.start,
+                        paths: Vec::new(),
+                        filter,
+                        filtered: filter,
+                    });
+                    continue;
+                }
+                if !statement {
+                    continue;
+                }
+                match t.kind {
+                    TokenKind::LBracket => {
+                        condition += 1;
+                        if let Some(site) = sites.last_mut() {
+                            site.filtered = true;
+                        }
+                    }
+                    TokenKind::RBracket => condition = condition.saturating_sub(1),
+                    _ => {}
+                }
+                let name = name_of(&t, text, dialect);
+                if condition > 0 {
+                    conditions.extend(name.clone());
+                }
+                if t.kind != TokenKind::ColonColon && name.is_none() && !path.is_empty() {
+                    let segments = std::mem::take(&mut path);
+                    if let Some(site) = sites.last_mut() {
+                        site.paths.push(QualifiedName {
+                            is_global: false,
+                            segments,
+                            span: Span::new(0, 0),
+                        });
+                    }
+                }
+                if separates(&t) {
+                    statement = false;
+                } else if let Some(name) = name {
+                    reach.names.insert(name.clone());
+                    path.push(Name {
+                        value: name,
+                        span: Span::new(0, 0),
+                    });
+                }
+            }
+        }
+        let resolved = session.resolved();
+        let elements: Vec<ElementRef> = resolved.user_elements().collect();
+        let extent_of: Vec<(ElementRef, usize, Span)> = elements
+            .iter()
+            .filter_map(|&e| resolved.member_extent(e).map(|(u, s)| (e, u, s)))
+            .collect();
+        // A statement resolves its names from the declaration around it,
+        // looking into each namespace they name. What a condition admits
+        // depends on the metadata of each member it is asked of, as a
+        // recursive import's target depends on all it holds: a filtered
+        // import's target — each that a filter member's namespace imports —
+        // is read the same way.
+        let (mut origins, mut namespaces, mut recursive) = (Vec::new(), Vec::new(), Vec::new());
+        for site in &sites {
+            let origin = extent_of
+                .iter()
+                .filter(|&&(_, u, s)| u == site.unit && s.start < site.at && site.at < s.end)
+                .min_by_key(|&&(_, _, s)| s.len())
+                .map(|&(e, _, _)| e);
+            origins.extend(origin);
+            let scope = origin
+                .and_then(|o| resolved.element_scope(o))
+                .unwrap_or_else(|| resolved.root_scope());
+            for (i, path) in site.paths.iter().enumerate() {
+                for len in 1..=path.segments.len() {
+                    let prefix = QualifiedName {
+                        segments: path.segments[..len].to_vec(),
+                        ..path.clone()
+                    };
+                    let Some(t) = resolved.resolve_in(scope, &prefix) else {
+                        break;
+                    };
+                    if resolved.is_library_element(t) {
+                        continue;
+                    }
+                    reach.inside.insert(t);
+                    namespaces.push(t);
+                    if site.filtered && !site.filter && i == 0 && len == path.segments.len() {
+                        recursive.push(t);
+                    }
+                }
+            }
+            if let Some(origin) = origin.filter(|_| site.filter) {
+                recursive.extend(
+                    resolved
+                        .import_details(origin)
+                        .into_iter()
+                        .map(|(t, ..)| t)
+                        .filter(|&t| !resolved.is_library_element(t)),
+                );
+            }
+        }
+        for &e in &elements {
+            for (target, namespace, deep, _) in resolved.import_details(e) {
+                if resolved.is_library_element(target) {
+                    continue;
+                }
+                if deep {
+                    recursive.push(target);
+                } else if namespace {
+                    namespaces.push(target);
+                }
+            }
+        }
+        let extents: Vec<(usize, Span)> = recursive
+            .iter()
+            .filter_map(|&t| resolved.member_extent(t))
+            .collect();
+        let mut scopes: HashSet<ElementRef> =
+            namespaces.iter().chain(&recursive).copied().collect();
+        let mut whole = recursive;
+        if !conditions.is_empty() {
+            whole.extend(elements.iter().copied().filter(|&e| {
+                resolved
+                    .element_name(e)
+                    .is_some_and(|n| conditions.contains(n))
+            }));
+        }
+        if !extents.is_empty() {
+            whole.extend(extent_of.iter().filter_map(|&(e, u, s)| {
+                extents
+                    .iter()
+                    .any(|&(eu, es)| eu == u && es.start <= s.start && s.end <= es.end)
+                    .then_some(e)
+            }));
+        }
+        reach.walk(session, &namespaces, &whole, false);
+        // Each namespace a lookup starts from, and those around it; each
+        // one looked into.
+        origins.extend(reach.origins.iter().copied());
+        scopes.extend(reach.inside.iter().copied());
+        let resolved = session.resolved();
+        let mut climbed = HashSet::new();
+        for origin in origins {
+            let mut at = Some(origin);
+            while let Some(e) = at.filter(|&e| climbed.insert(e)) {
+                scopes.insert(e);
+                at = resolved.owner(e);
+            }
+        }
+        // What a recursive import's target holds is read with it.
+        reach
+            .spans
+            .sort_by_key(|&(u, s)| (u, s.start, std::cmp::Reverse(s.end)));
+        let mut kept: Vec<(usize, Span)> = Vec::new();
+        for (u, s) in std::mem::take(&mut reach.spans) {
+            if !kept
+                .last()
+                .is_some_and(|&(ku, k)| ku == u && k.start <= s.start && s.end <= k.end)
+            {
+                kept.push((u, s));
+            }
+        }
+        reach.spans = kept;
+        Imports { reach, scopes }
+    }
+}
+
+/// A unit's significant tokens in the two texts, and how much of either
+/// end the two share: `prefix` tokens from the start, `suffix` from the
+/// end — widened to whole statements.
+struct Diff {
+    old: Vec<Token>,
+    new: Vec<Token>,
+    prefix: usize,
+    suffix: usize,
+}
+
+impl Diff {
+    /// `None` when the texts differ where the check cannot place it: in
+    /// statements that open or close a body they do not close or open,
+    /// or in a token in error.
+    fn of(old_text: &str, new_text: &str) -> Option<Diff> {
+        let (old, new) = (significant(old_text), significant(new_text));
+        let same = |a: &Token, b: &Token| a.kind == b.kind && a.text(old_text) == b.text(new_text);
+        let mut prefix = old.iter().zip(&new).take_while(|(a, b)| same(a, b)).count();
+        let mut suffix = old[prefix..]
+            .iter()
+            .rev()
+            .zip(new[prefix..].iter().rev())
+            .take_while(|(a, b)| same(a, b))
+            .count();
+        if prefix == old.len() && prefix == new.len() {
+            // Only whitespace and notes differ.
+            return Some(Diff {
+                old,
+                new,
+                prefix,
+                suffix: 0,
+            });
+        }
+        // Whole statements: the changed tokens start after a statement's
+        // end or a brace, and end with one, in both texts.
+        while prefix > 0 && !separates(&old[prefix - 1]) {
+            prefix -= 1;
+        }
+        let ends = |tokens: &[Token], suffix: usize| {
+            let end = tokens.len() - suffix;
+            end == prefix || separates(&tokens[end - 1])
+        };
+        while suffix > 0 && !(ends(&old, suffix) && ends(&new, suffix)) {
+            suffix -= 1;
+        }
+        let diff = Diff {
+            old,
+            new,
+            prefix,
+            suffix,
+        };
+        let (a, b) = (diff.old_changed(), diff.new_changed());
+        let clean = |tokens: &[Token]| {
+            balanced(tokens) && tokens.iter().all(|t| t.kind != TokenKind::Error)
+        };
+        (clean(a) && clean(b)).then_some(diff)
+    }
+
+    fn old_changed(&self) -> &[Token] {
+        &self.old[self.prefix..self.old.len() - self.suffix]
+    }
+
+    fn new_changed(&self) -> &[Token] {
+        &self.new[self.prefix..self.new.len() - self.suffix]
+    }
+
+    /// The position in the old text that the declarations around it
+    /// hold as those around `at` hold it in the new one: the same gap
+    /// between tokens, touching the same neighbors. `None` where no
+    /// position does: inside a token, among the changed statements or
+    /// against one, or between tokens the old text leaves no room
+    /// between.
+    fn map(&self, old_text: &str, at: u32) -> Option<u32> {
+        let (old, new) = (&self.old, &self.new);
+        // `at` is in the gap before `new[next]`, touching the tokens on
+        // either side or not.
+        let next = new.partition_point(|t| t.span.start < at);
+        if next > 0 && new[next - 1].span.end > at {
+            return None;
+        }
+        let touch_prev = next > 0 && new[next - 1].span.end == at;
+        let touch_next = next < new.len() && new[next].span.start == at;
+        let (first, last) = (self.prefix, new.len() - self.suffix);
+        let old_last = old.len() - self.suffix;
+        let changed = first < last || first < old_last;
+        // The same gap in the old text, by the index of the token after it.
+        let gap = if first < next && next < last {
+            return None;
+        } else if next < first || (next == first && !touch_next) {
+            next
+        } else if next > last || (next == last && !touch_prev) {
+            old_last + (next - last)
+        } else if changed {
+            // Against a changed statement, or — none added here — against
+            // both sides of those taken away.
+            return None;
+        } else {
+            next
+        };
+        let prev_end = gap.checked_sub(1).map(|i| old[i].span.end);
+        let next_start = old.get(gap).map(|t| t.span.start);
+        match (touch_prev, touch_next) {
+            (true, true) => prev_end.filter(|&p| next_start == Some(p)),
+            (true, false) => prev_end.filter(|&p| next_start != Some(p)),
+            (false, true) => next_start.filter(|&p| prev_end != Some(p)),
+            (false, false) => {
+                let lo = prev_end.map_or(0, |end| end + 1);
+                let hi = next_start.map_or_else(
+                    || crate::position::offset32(old_text.len()),
+                    |start| start.saturating_sub(1),
+                );
+                (next_start.is_none_or(|start| start > 0) && lo <= hi).then_some(lo)
+            }
+        }
+    }
+
+    /// The changed statements of unit `name`, `None` where only
+    /// whitespace and notes changed.
+    fn changed(&self, name: &str, old_text: &str, new_text: &str) -> Option<Changed> {
+        let (a, b) = (self.old_changed(), self.new_changed());
+        if a.is_empty() && b.is_empty() {
+            return None;
+        }
+        let (lo, hi, insertion) = match (a.first(), a.last()) {
+            (Some(first), Some(last)) => (first.span.start, last.span.end, false),
+            _ => {
+                let lo = self
+                    .prefix
+                    .checked_sub(1)
+                    .map_or(0, |i| self.old[i].span.end);
+                let hi = self.old.get(self.prefix).map_or_else(
+                    || crate::position::offset32(old_text.len()),
+                    |t| t.span.start,
+                );
+                (lo, hi, true)
+            }
+        };
+        let depth = self.old[..self.prefix]
+            .iter()
+            .fold(0isize, |d, t| match t.kind {
+                TokenKind::LBrace => d + 1,
+                TokenKind::RBrace => d - 1,
+                _ => d,
+            });
+        let mut changed = Changed {
+            lo,
+            hi,
+            insertion,
+            top: depth <= 0,
+            ..Changed::new(name.to_string())
+        };
+        let dialect = dialect(name);
+        scan(old_text, a, dialect, &mut changed);
+        scan(new_text, b, dialect, &mut changed);
+        Some(changed)
+    }
+}
+
+/// Reads the statements `tokens` of `text` (whole ones, at one level)
+/// into `into`: what their headers may declare and whether one is
+/// opaque (see [`OPAQUE`]), and what the headers at every depth refer
+/// to.
+fn scan(text: &str, tokens: &[Token], dialect: Dialect, into: &mut Changed) {
+    let mut i = 0;
+    while i < tokens.len() {
+        i = statement(text, tokens, i, dialect, 0, into).max(i + 1);
+    }
+}
+
+/// Reads the statement starting at `tokens[start]`, `depth` bodies below
+/// the changed statements' level, into `into` (see [`scan`]); returns
+/// where the next one starts — at the `}` closing the body around it,
+/// when that ends it.
+fn statement(
+    text: &str,
+    tokens: &[Token],
+    start: usize,
+    dialect: Dialect,
+    depth: usize,
+    into: &mut Changed,
+) -> usize {
+    use TokenKind as K;
+    // What the header's names are: declared, or a list of targets.
+    #[derive(PartialEq)]
+    enum Mode {
+        Names,
+        Targets { inherited: bool },
+    }
+    let mut mode = Mode::Names;
+    let mut path: Vec<Name> = Vec::new();
+    let mut global = false;
+    let finish = |path: &mut Vec<Name>, global: &mut bool, mode: &Mode, into: &mut Changed| {
+        if let (false, Mode::Targets { inherited }) = (path.is_empty(), mode) {
+            into.targets.push(Target {
+                name: QualifiedName {
+                    is_global: *global,
+                    segments: std::mem::take(path),
+                    span: Span::new(0, 0),
+                },
+                inherited: *inherited,
+            });
+        }
+        path.clear();
+        *global = false;
+    };
+    let mut i = start;
+    let mut header = true;
+    while i < tokens.len() {
+        let t = &tokens[i];
+        match t.kind {
+            K::Semi => {
+                finish(&mut path, &mut global, &mode, into);
+                return i + 1;
+            }
+            K::LBrace => {
+                finish(&mut path, &mut global, &mode, into);
+                // The body: its statements are the member's own.
+                i += 1;
+                while i < tokens.len() && tokens[i].kind != K::RBrace {
+                    i = statement(text, tokens, i, dialect, depth + 1, into).max(i + 1);
+                }
+                return i + 1;
+            }
+            K::RBrace => {
+                finish(&mut path, &mut global, &mode, into);
+                return i;
+            }
+            _ if !header => {}
+            K::LParen | K::LBracket => {
+                finish(&mut path, &mut global, &mode, into);
+                mode = Mode::Names;
+                // A multiplicity's bounds, a filter, or a connection's
+                // ends: none is a target, and names inside are looked up.
+                let close = if t.kind == K::LParen {
+                    K::RParen
+                } else {
+                    K::RBracket
+                };
+                let mut nested = 0usize;
+                while i < tokens.len() {
+                    let k = tokens[i].kind;
+                    if k == t.kind {
+                        nested += 1;
+                    } else if k == close {
+                        nested -= 1;
+                        if nested == 0 {
+                            break;
+                        }
+                    } else if k == K::LBrace || k == K::Semi {
+                        // A body expression or a statement's end: read on
+                        // from there.
+                        i -= 1;
+                        break;
+                    } else if depth == 0 {
+                        if let Some(name) = name_of(&tokens[i], text, dialect) {
+                            into.declared.insert(name);
+                        }
+                    }
+                    i += 1;
+                }
+            }
+            K::Eq | K::ColonEq => {
+                finish(&mut path, &mut global, &mode, into);
+                // The value: no declaration of the statement's own.
+                header = false;
+            }
+            K::Colon | K::ColonGt | K::Tilde => {
+                finish(&mut path, &mut global, &mode, into);
+                mode = Mode::Targets { inherited: false };
+            }
+            K::ColonGtGt | K::ColonColonGt | K::FatArrow => {
+                finish(&mut path, &mut global, &mode, into);
+                mode = Mode::Targets { inherited: true };
+            }
+            K::Comma => finish(&mut path, &mut global, &mode, into),
+            K::Dollar if matches!(mode, Mode::Targets { .. }) => global = true,
+            K::ColonColon | K::Dot => {}
+            K::At if depth == 0 => into.opaque = true,
+            K::Ident | K::UnrestrictedName => {
+                let word = t.text(text);
+                // A metadata usage annotates the element around it, as `@`
+                // does; a metadata definition declares a name like any other.
+                let annotation =
+                    word == "metadata" && tokens.get(i + 1).is_none_or(|t| t.text(text) != "def");
+                if t.kind == K::Ident && depth == 0 && (OPAQUE.contains(&word) || annotation) {
+                    into.opaque = true;
+                }
+                // The words that start or go on with a list of targets are
+                // keywords wherever they stand, reserved or not.
+                let switch = t.kind == K::Ident
+                    && matches!(
+                        word,
+                        "typed"
+                            | "defined"
+                            | "by"
+                            | "specializes"
+                            | "subsets"
+                            | "conjugates"
+                            | "redefines"
+                            | "references"
+                            | "crosses"
+                            | "default"
+                    );
+                let name = name_of(t, text, dialect);
+                // Such a word that is no reserved one may name a feature,
+                // too.
+                if let Some(name) = name.as_ref().filter(|_| switch && depth == 0) {
+                    into.declared.insert(name.clone());
+                }
+                match name.filter(|_| !switch) {
+                    Some(name) => {
+                        if matches!(mode, Mode::Names | Mode::Targets { inherited: true })
+                            && depth == 0
+                        {
+                            into.declared.insert(name.clone());
+                        }
+                        if matches!(mode, Mode::Targets { .. }) {
+                            path.push(Name {
+                                value: name,
+                                span: Span::new(0, 0),
+                            });
+                        }
+                    }
+                    None => {
+                        finish(&mut path, &mut global, &mode, into);
+                        mode = match word {
+                            "typed" | "defined" | "specializes" | "subsets" | "conjugates" => {
+                                Mode::Targets { inherited: false }
+                            }
+                            "redefines" | "references" | "crosses" => {
+                                Mode::Targets { inherited: true }
+                            }
+                            // `by` goes on with the targets `typed` or
+                            // `defined` started.
+                            "by" if matches!(mode, Mode::Targets { .. }) => mode,
+                            "default" => {
+                                header = false;
+                                Mode::Names
+                            }
+                            _ => Mode::Names,
+                        };
+                    }
+                }
+            }
+            _ => {
+                finish(&mut path, &mut global, &mode, into);
+                mode = Mode::Names;
+            }
+        }
+        i += 1;
+    }
+    tokens.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Changed, Changes};
+
+    /// The changes from `old` to `new`, where `|` marks the statement's
+    /// start (and is no part of the text), for one unit.
+    fn between(old: &str, new: &str) -> Option<Changes> {
+        let at = new.find('|').expect("statement marker");
+        let new = new.replacen('|', "", 1);
+        Changes::between(
+            std::iter::once(("u.sysml", old)),
+            &[("u.sysml".to_string(), new)],
+            "u.sysml",
+            u32::try_from(at).expect("short"),
+        )
+    }
+
+    /// The one changed unit of `old` → `new` (see [`between`]).
+    fn changed(old: &str, new: &str) -> Changed {
+        between(old, new)
+            .expect("placed")
+            .units
+            .pop()
+            .expect("a change")
+    }
+
+    fn declared(c: &Changed) -> Vec<&str> {
+        let mut names: Vec<&str> = c.declared.iter().map(String::as_str).collect();
+        names.sort_unstable();
+        names
+    }
+
+    fn targets(c: &Changed) -> Vec<(String, bool)> {
+        c.targets
+            .iter()
+            .map(|t| {
+                let path: Vec<&str> = t.name.segments.iter().map(|s| s.value.as_str()).collect();
+                (path.join("::"), t.inherited)
+            })
+            .collect()
+    }
+
+    const OLD: &str = "package P {\n    part def D {\n        \n    }\n}\n";
+
+    #[test]
+    fn a_statement_added_before_the_one_typed() {
+        let new =
+            "package P {\n    part def D {\n        attribute a = v.m;\n        |\n    }\n}\n";
+        let changes = between(OLD, new).expect("placed");
+        // Inside `D`'s body in the old text, touching neither brace.
+        let open = OLD.find("D {").expect("body") + 3;
+        let close = OLD.rfind("    }").expect("close") + 4;
+        assert!(open < changes.at as usize && (changes.at as usize) < close);
+        let c = &changes.units[0];
+        assert!(c.insertion && !c.top && !c.opaque);
+        assert_eq!(declared(c), ["a"]);
+    }
+
+    #[test]
+    fn notes_and_whitespace_change_nothing() {
+        let new = "package P {\n    // a note\n    part def D {\n\n        |\n    }\n}\n";
+        let changes = between(OLD, new).expect("placed");
+        assert!(changes.units.is_empty());
+        assert_eq!(OLD.as_bytes()[changes.at as usize - 2], b'{');
+    }
+
+    #[test]
+    fn what_opens_or_closes_a_body_is_not_placed() {
+        for new in [
+            "package P {\n    part def D {\n        part def E {\n        |\n    }\n}\n",
+            "package P {\n    part def D {\n        }\n        |\n    }\n}\n",
+            // A renamed body keeps its braces outside the change.
+            "package Q {\n    part def D {\n        |\n    }\n}\n",
+        ] {
+            assert!(between(OLD, new).is_none(), "{new:?}");
+        }
+    }
+
+    #[test]
+    fn a_statement_against_a_change_is_not_placed() {
+        let new = "package P {\n    part def D {\n        attribute a = 1;|\n    }\n}\n";
+        assert!(between(OLD, new).is_none());
+    }
+
+    #[test]
+    fn a_statement_taken_away() {
+        let old =
+            "package P {\n    part def D {\n        part a;\n        part b;\n        \n    }\n}\n";
+        let new = "package P {\n    part def D {\n        part a;\n        |\n    }\n}\n";
+        let changes = between(old, new).expect("placed");
+        let c = &changes.units[0];
+        assert!(!c.insertion);
+        assert_eq!(declared(c), ["b"]);
+        // Outside what was taken away.
+        let taken = old.find("part b;").expect("b");
+        let at = changes.at as usize;
+        assert!(at < taken || at > taken + "part b;".len(), "{at}");
+    }
+
+    #[test]
+    fn opaque_statements() {
+        for (statement, opaque) in [
+            ("private import Q::*;", true),
+            ("in x : T;", true),
+            ("return r : R;", true),
+            ("@Safety;", true),
+            ("metadata Safety;", true),
+            ("alias A for B;", true),
+            ("entry action a;", true),
+            ("end e : E;", true),
+            ("metadata def M;", false),
+            ("part p : P;", false),
+            ("attribute :>> mass = 1;", false),
+            ("part q { in x; import R::*; }", false),
+            ("attribute x = s->select { in p; p > 0 };", false),
+        ] {
+            let new = OLD.replace("        \n", &format!("        {statement}\n        |\n"));
+            assert_eq!(changed(OLD, &new).opaque, opaque, "{statement}");
+        }
+    }
+
+    #[test]
+    fn declared_names_and_targets() {
+        for (statement, names, refs) in [
+            (
+                "attribute m : MassValue = 5 [kg];",
+                &["m"][..],
+                &[("MassValue", false)][..],
+            ),
+            (
+                "attribute :>> mass = 1500 [kg];",
+                &["mass"],
+                &[("mass", true)],
+            ),
+            (
+                "part def Car :> Vehicle { part e : Engine; }",
+                &["Car"],
+                &[("Vehicle", false), ("Engine", false)],
+            ),
+            ("port p : ~FuelPort;", &["p"], &[("FuelPort", false)]),
+            ("attribute x : ISQ::T;", &["x"], &[("ISQ::T", false)]),
+            ("perform providePower;", &["providePower"], &[]),
+            // A bound is looked up, not declared; it counts all the same.
+            (
+                "part <s> 'short one' : S [0..n];",
+                &["n", "s", "short one"],
+                &[("S", false)],
+            ),
+            (
+                "ref :>> a.b : T;",
+                &["a", "b"],
+                &[("a::b", true), ("T", false)],
+            ),
+        ] {
+            let new = OLD.replace("        \n", &format!("        {statement}\n        |\n"));
+            let c = changed(OLD, &new);
+            assert_eq!(declared(&c), names, "{statement}");
+            let expected: Vec<(String, bool)> =
+                refs.iter().map(|&(n, i)| (n.to_string(), i)).collect();
+            assert_eq!(targets(&c), expected, "{statement}");
+        }
+    }
+
+    #[test]
+    fn top_level_statements() {
+        let old = "part def A;\n\n";
+        let c = changed(old, "part def A;\npart def B;\n|\n");
+        assert!(c.top);
+        assert_eq!(declared(&c), ["B"]);
+        let c = changed(
+            OLD,
+            &OLD.replace("        \n", "        part b;\n        |\n"),
+        );
+        assert!(!c.top);
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/salvage.rs b/crates/sysmlv2-lsp/src/salvage.rs
new file mode 100644
index 0000000..e6e1530
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/salvage.rs
@@ -0,0 +1,1337 @@
+//! Salvage: texts that parse, made from the ones being edited, for the
+//! completion tier's session. A session refuses every unit with a
+//! syntax error, and a workspace being edited nearly always holds one:
+//! the statement being typed, and — further up, in another file — a
+//! statement half typed or a body not closed yet, any of which would
+//! leave member and unit completions with no model at all. The
+//! statement being typed is cut out ([`typed_statement_cut`]); in what
+//! remains, a declaration missing only its `;` gets it written behind
+//! its last token, the other member declarations the parser reports
+//! errors in are blanked out, and the braces they leave unbalanced are
+//! closed ([`salvage`], per workspace [`SalvageCache::salvage_all`]):
+//! every other declaration keeps its meaning, and every byte before the
+//! end of the text keeps its offset, so positions into the live
+//! document still address the salvaged one.
+
+use crate::position::offset32;
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use sysmlv2_parser::ast::Member;
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+use sysmlv2_parser::visit::{Visit, walk_member};
+
+/// What the completion session leaves out of the document being edited:
+/// the statement being typed (it starts at `stmt_start`, the cursor is
+/// at `cursor`), which rarely parses mid-edit — through the cursor's
+/// line, ending early after a `;` that ends it and before a closer it
+/// did not open (in `assert constraint { v.| }` the `}` closes the body
+/// around the statement; cut with it, the rest of the unit would not
+/// balance). A body the statement opens after the cursor goes with it,
+/// through its `}` on whichever line that sits.
+pub(crate) fn typed_statement_cut(text: &str, stmt_start: u32, cursor: u32) -> Span {
+    let start = (stmt_start as usize).min(text.len());
+    let cursor = (cursor as usize).clamp(start, text.len());
+    let line_end = text[cursor..].find('\n').map_or(text.len(), |i| cursor + i);
+    let end = statement_end(text, start, cursor, line_end)
+        .or_else(|| statement_end(text, start, cursor, text.len()))
+        .unwrap_or(text.len());
+    Span::new(offset32(start), offset32(end))
+}
+
+/// Where the statement that starts at byte `start` ends, scanning its
+/// tokens up to `limit` (see [`typed_statement_cut`]): `limit` when
+/// nothing ends it sooner, `None` when a body it opened after `cursor`
+/// is still open there.
+fn statement_end(text: &str, start: usize, cursor: usize, limit: usize) -> Option<usize> {
+    use TokenKind as K;
+    // The groupings open so far, each with whether it opened after the
+    // cursor.
+    let mut open: Vec<(K, bool)> = Vec::new();
+    let body_open = |open: &[(K, bool)]| open.iter().any(|&(k, after)| k == K::LBrace && after);
+    for token in sysmlv2_parser::lexer::tokenize(text.get(start..limit)?).0 {
+        let at = start + token.span.start as usize;
+        let after = at >= cursor;
+        match token.kind {
+            K::LParen | K::LBracket | K::LBrace => open.push((token.kind, after)),
+            K::RParen | K::RBracket => {
+                let opener = if token.kind == K::RParen {
+                    K::LParen
+                } else {
+                    K::LBracket
+                };
+                if open.last().is_some_and(|&(k, _)| k == opener) {
+                    open.pop();
+                }
+            }
+            K::RBrace => match open.last() {
+                Some(&(K::LBrace, opened_after)) => {
+                    open.pop();
+                    // The statement's own body closed: it ends here.
+                    if opened_after && !body_open(&open) {
+                        return Some(at + 1);
+                    }
+                }
+                // A `}` the statement did not open closes the body the
+                // statement sits in.
+                _ if after => return Some(at),
+                _ => {}
+            },
+            K::Semi if after && open.is_empty() => return Some(at + 1),
+            _ => {}
+        }
+    }
+    (!body_open(&open)).then_some(limit)
+}
+
+/// Repair rounds before a text is given up on. Each round writes each
+/// missing `;` the parse reported and blanks every other member it
+/// reported an error in; the next parse can report errors the parser's
+/// recovery hid behind the first ones.
+const ROUNDS: usize = 4;
+
+/// `text` made to parse (borrowed back when it already does), or
+/// `None` when a few rounds of repair do not get it there — or a round
+/// changes nothing, which the next would not either. A missing `;` is
+/// written over one whitespace byte behind the declaration — a line
+/// break when there is no other, and after it at the very end of the
+/// text — whole member declarations with other errors are blanked
+/// (their bytes become spaces, line breaks kept), and missing closing
+/// braces are appended, so offsets into the text stay valid.
+///
+/// Two repairs keep more than the member in error, and give way to
+/// blanking it whole when the rounds do not get there with them: a
+/// string, quoted name, comment or note left open, which the lexer runs
+/// to the end of the text, ends at its own line, leaving what follows
+/// to the next rounds ([`open_literal`]); and a declaration whose
+/// header is in error keeps its body ([`member_around`]).
+pub(crate) fn salvage(text: &str, kerml: bool) -> Option<Cow<'_, str>> {
+    let parsed = Parsed::of(text, kerml);
+    if parsed.errors.is_empty() {
+        return Some(Cow::Borrowed(text));
+    }
+    match rounds(text, kerml, parsed, true) {
+        (Some(repaired), _) => Some(Cow::Owned(repaired)),
+        (None, true) => rounds(text, kerml, Parsed::of(text, kerml), false)
+            .0
+            .map(Cow::Owned),
+        (None, false) => None,
+    }
+}
+
+/// [`salvage`]'s rounds of repair over `original`, which `parsed` read:
+/// the text they make parse, if they do, and whether a repair keeping
+/// more than the member in error (`keep`) took part.
+fn rounds(original: &str, kerml: bool, mut parsed: Parsed, keep: bool) -> (Option<String>, bool) {
+    let mut text = original.to_string();
+    let mut kept = false;
+    // Where the last round took errors for the member before them.
+    let mut retried = Vec::new();
+    for _ in 0..ROUNDS {
+        let round = repair(original, &text, &parsed, &retried, kerml, keep);
+        kept |= round.kept;
+        if round.text == text {
+            return (None, kept);
+        }
+        text = round.text;
+        retried = round.taken_before;
+        parsed = Parsed::of(&text, kerml);
+        if parsed.errors.is_empty() {
+            return (Some(text), kept);
+        }
+    }
+    (None, kept)
+}
+
+/// What [`salvage`] made of a unit.
+enum Salvaged {
+    /// It parses as it is.
+    Parses,
+    /// It parses once repaired: the repaired text.
+    Repaired(String),
+    /// It could not be salvaged and stays out.
+    Left,
+}
+
+/// [`salvage`] over a whole workspace, remembering each unit's outcome
+/// by the hash of its text: between two builds of the completion
+/// session usually only the document being edited changed, and the
+/// rest need neither another parse nor another repair.
+#[derive(Default)]
+pub(crate) struct SalvageCache {
+    units: HashMap<String, (u64, Salvaged)>,
+}
+
+impl SalvageCache {
+    /// `sources` made to parse: each unit as it is, salvaged, or — when
+    /// it cannot be — left out.
+    pub(crate) fn salvage_all(&mut self, sources: Vec<(String, String)>) -> Vec<(String, String)> {
+        let mut previous = std::mem::take(&mut self.units);
+        let mut out = Vec::with_capacity(sources.len());
+        for (name, text) in sources {
+            let hash = {
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                text.hash(&mut hasher);
+                hasher.finish()
+            };
+            let outcome = match previous.remove(&name) {
+                Some((known, outcome)) if known == hash => outcome,
+                _ => match salvage(&text, crate::is_kerml(&name)) {
+                    Some(Cow::Borrowed(_)) => Salvaged::Parses,
+                    Some(Cow::Owned(repaired)) => Salvaged::Repaired(repaired),
+                    None => Salvaged::Left,
+                },
+            };
+            match &outcome {
+                Salvaged::Parses => out.push((name.clone(), text)),
+                Salvaged::Repaired(repaired) => out.push((name.clone(), repaired.clone())),
+                Salvaged::Left => {}
+            }
+            self.units.insert(name, (hash, outcome));
+        }
+        out
+    }
+}
+
+/// What a parse of a text being salvaged reports: where its errors
+/// are, and where the member declarations it kept end — those it read
+/// through, some only once it had repaired them in place.
+struct Parsed {
+    /// Each error's byte offset, in the order they were reported: the
+    /// lexer's first — the parser reports none of its own at a token the
+    /// lexer found in error — then the parser's, in the order it read
+    /// the text in, a member's own errors before the `;` it found missing
+    /// at its end.
+    errors: Vec<usize>,
+    /// Where the parser reported a `;` after a body's result expression:
+    /// the result stands, and the `;` is all that is in error.
+    result_terminators: Vec<usize>,
+    /// Where the parser reported a `;` missing, and which of the errors
+    /// that is: the errors with no width, at the end of a declaration's
+    /// last token where the `;` goes — or at the end of the text, which
+    /// cuts a declaration short the same way.
+    missing: Vec<(usize, usize)>,
+    /// Where each member declaration kept ends, at every depth, sorted.
+    ends: Vec<usize>,
+}
+
+impl Parsed {
+    /// Parse `text`; the members are read only when it has errors.
+    fn of(text: &str, kerml: bool) -> Self {
+        let parse = if kerml {
+            sysmlv2_parser::parser::parse_kerml_source(text)
+        } else {
+            sysmlv2_parser::parser::parse_source(text)
+        };
+        let spans = parse.diagnostics.iter().map(|d| d.span);
+        let errors: Vec<usize> = spans.clone().map(|s| s.start as usize).collect();
+        let result_terminators = parse
+            .diagnostics
+            .iter()
+            .filter(|d| d.message == sysmlv2_parser::parser::RESULT_EXPRESSION_TERMINATOR)
+            .map(|d| d.span.start as usize)
+            .collect();
+        let missing = spans
+            .enumerate()
+            .filter(|(_, s)| s.start == s.end)
+            .map(|(order, s)| (s.start as usize, order))
+            .collect();
+        let mut ends = MemberEnds::default();
+        if !errors.is_empty() {
+            ends.visit_unit(&parse.unit);
+        }
+        let mut ends = ends.0;
+        ends.sort_unstable();
+        Parsed {
+            errors,
+            result_terminators,
+            missing,
+            ends,
+        }
+    }
+
+    /// Does a kept member end at byte `at`?
+    fn ends_member_at(&self, at: usize) -> bool {
+        self.ends.binary_search(&at).is_ok()
+    }
+
+    /// Did the parser report a `;` missing at byte `at`?
+    fn missing_at(&self, at: usize) -> bool {
+        self.missing_reported(at).is_some()
+    }
+
+    /// Which of the errors reports a `;` missing at byte `at`, if one
+    /// does.
+    fn missing_reported(&self, at: usize) -> Option<usize> {
+        self.missing
+            .iter()
+            .find(|&&(missing, _)| missing == at)
+            .map(|&(_, order)| order)
+    }
+
+    /// Does a kept member end with `token`, the parser reading on from
+    /// there as from the start of another? A member ends with its `;`,
+    /// the `}` closing its body, or its comment — or anywhere the parser
+    /// reported its `;` missing, taking the line break after for it. A
+    /// member kept ending anywhere else is one the parser reported
+    /// unfinished at the token after.
+    fn ends_member(&self, token: &Token) -> bool {
+        let end = token.span.end as usize;
+        self.ends_member_at(end) && (terminates(token) || self.missing_at(end))
+    }
+}
+
+/// Can a member end with `token` — its `;`, the `}` closing its body,
+/// its comment?
+fn terminates(token: &Token) -> bool {
+    matches!(
+        token.kind,
+        TokenKind::Semi | TokenKind::RBrace | TokenKind::RegularComment
+    )
+}
+
+/// Where every member declaration in a syntax tree ends.
+#[derive(Default)]
+struct MemberEnds(Vec<usize>);
+
+impl<'a> Visit<'a> for MemberEnds {
+    fn visit_member(&mut self, member: &'a Member) {
+        self.0.push(member.span.end as usize);
+        walk_member(self, member);
+    }
+}
+
+/// What one round of repair made of a text.
+struct Round {
+    text: String,
+    /// Where it took errors for the member before them, for the next
+    /// round's `retried` (see [`member_around`]).
+    taken_before: Vec<usize>,
+    /// Whether a repair keeping more than the member in error took part.
+    kept: bool,
+}
+
+/// One round over `text`, made from `original`: terminate each
+/// declaration the parser found missing its `;`, blank a `;` after a
+/// body's result expression, the member around each other error, then
+/// balance braces. With `keep`, a literal left open ends at its own
+/// line ([`open_literal`]): blanked through it with the member it
+/// opens, nothing blanked for another error reaching past it, while the
+/// errors after it, the swallowed text's doing, wait for the next
+/// round, which reads that text afresh; and a header in error keeps its
+/// body.
+fn repair(
+    original: &str,
+    text: &str,
+    parsed: &Parsed,
+    retried: &[usize],
+    kerml: bool,
+    keep: bool,
+) -> Round {
+    let tokens = significant_tokens(text);
+    let (strays, open) = brace_balance(&tokens);
+    let mut bytes = text.as_bytes().to_vec();
+    let mut terminators = Vec::new();
+    let mut blanked = Vec::new();
+    let mut taken_before = Vec::new();
+    let literal = keep
+        .then(|| open_literal(text, &tokens, parsed, kerml))
+        .flatten();
+    let mut kept = literal.is_some();
+    if let Some((i, line_end)) = literal {
+        let start = member_start(&tokens[..i], parsed, false);
+        blank(&mut bytes, original, start, line_end);
+        blanked.push((start, line_end));
+    }
+    // A declaration the parser kept, cut short by the end of the text
+    // itself, has no whitespace behind it to take its `;`, and with no
+    // body left open balancing adds no line break for the next round to
+    // write it into: the `;` is appended, which moves no offset either.
+    let mut append = false;
+    for (error, &at) in parsed.errors.iter().enumerate() {
+        if literal.is_some_and(|(i, _)| at >= tokens[i].span.start as usize) {
+            continue;
+        }
+        if parsed.result_terminators.contains(&at) {
+            blank(&mut bytes, original, at, at + 1);
+            blanked.push((at, at + 1));
+            continue;
+        }
+        match terminator_space(text, &tokens, at) {
+            Some(space) => terminators.push((at, space)),
+            None if open == 0 && at == text.len() && cut_short_at_end(&tokens, parsed, at) => {
+                append = true;
+            }
+            None => {
+                let blanking = member_around(text, &tokens, &strays, parsed, error, retried, keep);
+                if blanking.before {
+                    taken_before.push(at);
+                }
+                kept |= blanking.header;
+                let end = match literal {
+                    Some((_, line_end)) => blanking.end.min(line_end),
+                    None => blanking.end,
+                };
+                blank(&mut bytes, original, blanking.start, end);
+                blanked.push((blanking.start, end));
+            }
+        }
+    }
+    // A declaration blanked for another error takes no terminator.
+    for (at, space) in terminators {
+        if !blanked.iter().any(|&(start, end)| start < at && at <= end) {
+            bytes[space] = b';';
+        }
+    }
+    let mut text = into_text(bytes);
+    if append
+        && !blanked
+            .iter()
+            .any(|&(start, end)| start < text.len() && text.len() <= end)
+    {
+        text.push(';');
+    }
+    close_braces(&mut text);
+    Round {
+        text,
+        taken_before,
+        kept,
+    }
+}
+
+/// The literal left open in `text` — a string, quoted name, comment or
+/// note the lexer ran past its own line to the end of the text, as one
+/// error token — as its token's index and where the line it starts on
+/// ends. A quote left open pairs with the next of its kind, and each
+/// literal after it with the wrong quotes, until the last runs to the
+/// end: the quote left open is then the one opening a literal of its
+/// kind across lines, or that last one. Each is taken in turn for the
+/// quote left open (the first [`CANDIDATES`] and the last): taken away,
+/// its line on, the right one leaves the fewest literals across lines,
+/// which people rarely write; among equals — a literal written across
+/// lines, which any taking leaves one of — the one the unit parses the
+/// most members without (the member it opens blanked through its line,
+/// as a round blanks it), then the fewest errors, the first of equals
+/// winning.
+fn open_literal(
+    text: &str,
+    tokens: &[Token],
+    parsed: &Parsed,
+    kerml: bool,
+) -> Option<(usize, usize)> {
+    let spans_lines = |text: &str, t: &Token| {
+        text.get(t.span.start as usize..t.span.end as usize)
+            .is_some_and(|t| t.contains('\n'))
+    };
+    let last = parsed.errors.iter().find_map(|&at| {
+        let i = tokens.partition_point(|t| (t.span.end as usize) <= at);
+        let token = tokens.get(i)?;
+        (token.kind == TokenKind::Error
+            && token.span.start as usize == at
+            && spans_lines(text, token))
+        .then_some(i)
+    })?;
+    let line_end = |i: usize| {
+        let start = tokens[i].span.start as usize;
+        text[start..].find('\n').map_or(text.len(), |n| start + n)
+    };
+    let kind = match text.as_bytes()[tokens[last].span.start as usize] {
+        b'"' => TokenKind::String,
+        b'\'' => TokenKind::UnrestrictedName,
+        _ => return Some((last, line_end(last))),
+    };
+    let mut candidates: Vec<usize> = (0..last)
+        .filter(|&i| tokens[i].kind == kind && spans_lines(text, &tokens[i]))
+        .take(CANDIDATES)
+        .collect();
+    if candidates.is_empty() {
+        return Some((last, line_end(last)));
+    }
+    candidates.push(last);
+    // The text with `from` blanked through a candidate's line.
+    let without = |from: usize, i: usize| {
+        let mut bytes = text.as_bytes().to_vec();
+        blank(&mut bytes, text, from, line_end(i));
+        into_text(bytes)
+    };
+    // The literals across lines (or left open) the text leaves with a
+    // candidate's quote taken away, its line on.
+    let across = |i: usize| {
+        let text = without(tokens[i].span.start as usize, i);
+        sysmlv2_parser::lexer::tokenize(&text)
+            .0
+            .iter()
+            .filter(|t| matches!(t.kind, TokenKind::Error) || t.kind == kind)
+            .filter(|t| spans_lines(&text, t))
+            .count()
+    };
+    let scored: Vec<(usize, usize)> = candidates.iter().map(|&i| (across(i), i)).collect();
+    let fewest = scored.iter().map(|&(n, _)| n).min()?;
+    let tied: Vec<usize> = scored
+        .into_iter()
+        .filter(|&(n, _)| n == fewest)
+        .map(|(_, i)| i)
+        .collect();
+    let chosen = match tied[..] {
+        [only] => only,
+        // Among equals, the unit with the member a candidate opens
+        // blanked through its line, as a round blanks it.
+        _ => tied.into_iter().min_by_key(|&i| {
+            let text = without(member_start(&tokens[..i], parsed, false), i);
+            let parse = if kerml {
+                sysmlv2_parser::parser::parse_kerml_source(&text)
+            } else {
+                sysmlv2_parser::parser::parse_source(&text)
+            };
+            let mut members = MemberEnds::default();
+            members.visit_unit(&parse.unit);
+            (std::cmp::Reverse(members.0.len()), parse.diagnostics.len())
+        })?,
+    };
+    Some((chosen, line_end(chosen)))
+}
+
+/// How many literals across lines [`open_literal`] weighs, before the
+/// one the lexer ran to the end of the text.
+const CANDIDATES: usize = 8;
+
+/// Does a member the parser kept end at `at`, the end of the text, with
+/// a token that cannot end a member — the declaration cut short there,
+/// its `;` all that is missing?
+fn cut_short_at_end(tokens: &[Token], parsed: &Parsed, at: usize) -> bool {
+    let last = tokens.iter().rev().find(|t| t.kind != TokenKind::Eof);
+    parsed.missing_at(at)
+        && parsed.ends_member_at(at)
+        && last.is_some_and(|t| t.span.end as usize == at && !terminates(t))
+}
+
+/// Where a missing `;` reported at byte `at` can be written without
+/// moving an offset: a whitespace byte between the declaration's last
+/// token and the next one, outside any comment — a space or a tab, the
+/// next line's indentation as a rule, else the line break itself. The
+/// parser reports a declaration missing its terminator at the end of its
+/// last token, when the next line starts another member, and reads on
+/// as if the `;` were there: writing it keeps the declaration the parser
+/// kept. `None` for any other error.
+fn terminator_space(text: &str, tokens: &[Token], at: usize) -> Option<usize> {
+    let ended = tokens.iter().any(|t| t.span.end as usize == at);
+    let next = tokens
+        .iter()
+        .find(|t| t.span.start as usize >= at)?
+        .span
+        .start as usize;
+    if !ended || next == at {
+        return None;
+    }
+    let gap = text.get(at..next)?;
+    let spaces: Vec<usize> = sysmlv2_parser::lexer::tokenize(gap)
+        .0
+        .into_iter()
+        .filter(|t| t.kind == TokenKind::Whitespace)
+        .flat_map(|t| t.span.start as usize..t.span.end as usize)
+        .collect();
+    spaces
+        .iter()
+        .find(|&&i| matches!(gap.as_bytes()[i], b' ' | b'\t'))
+        .or_else(|| spaces.first())
+        .map(|&i| at + i)
+}
+
+/// The tokens the parser reads (trivia dropped), `Eof` last.
+fn significant_tokens(text: &str) -> Vec<Token> {
+    sysmlv2_parser::lexer::tokenize(text)
+        .0
+        .into_iter()
+        .filter(|t| !t.kind.is_trivia())
+        .collect()
+}
+
+/// The member declaration the syntax error `error` belongs to, as the
+/// byte range to blank. It starts just after the member boundary before
+/// it ([`member_start`]). It ends where the error is when that is
+/// between tokens (a missing `;` is reported at the end of the
+/// declaration's line), and at the end of the token before the one the
+/// error was reported at when the parser only found out there that the
+/// member had ended ([`ended_before`]); otherwise where [`member_extent`]
+/// puts the end of a member in error at that token. An error at a `}`
+/// nothing is open for is that closer's own, which balancing the braces
+/// blanks. One at a `}` right after a `;` or a `}` that ends no member
+/// the parser kept belongs to the member that token is part of — a `}`
+/// closing a body its value opened (`f({ in i; i }`), say — which goes
+/// whole. An error the last round took for the member before it and
+/// still reported where it was (`retried`), which blanking that member
+/// did not clear, is the member's at it. With `keep`, a member whose
+/// header is in error keeps the body it opens: what is blanked is the
+/// header from the error up to the body's `{` — from the token before,
+/// when the error is at the `{` — as long as some of the header stays;
+/// and a body opened right after a `}` nothing is open for waits for
+/// balancing to blank that `}`.
+fn member_around(
+    text: &str,
+    tokens: &[Token],
+    strays: &[usize],
+    parsed: &Parsed,
+    error: usize,
+    retried: &[usize],
+    keep: bool,
+) -> Blanking {
+    let at = parsed.errors[error];
+    // The first token ending past the error: the one it was reported at.
+    let i = tokens
+        .partition_point(|t| (t.span.end as usize) <= at)
+        .min(tokens.len().saturating_sub(1));
+    let token = &tokens[i];
+    let Some(prev) = i.checked_sub(1).map(|p| &tokens[p]) else {
+        return Blanking::of(0, member_extent(text, tokens).0);
+    };
+    if at < token.span.start as usize {
+        let start = member_start(&tokens[..i], parsed, true);
+        return Blanking::of(start, at);
+    }
+    let stray = |t: &Token| strays.binary_search(&(t.span.start as usize)).is_ok();
+    // A `}` nothing is open for is its own error, and a body opened right
+    // after one is the body of the declaration before it, which
+    // balancing the braces gives back.
+    if stray(token) || (keep && token.kind == TokenKind::LBrace && stray(prev)) {
+        return Blanking::of(at, at);
+    }
+    if ended_before(text, tokens, parsed, i, error) {
+        let start = member_start(&tokens[..i], parsed, true);
+        // Still reported where the last round took it for the member
+        // before, the error is the member's at it — unless the member
+        // before leaves a group open, whose close the parser reports
+        // here: blanking stopped short of that member's start, at a `;`
+        // inside the group.
+        if !retried.contains(&at) || leaves_group_open(tokens, start, i) {
+            return Blanking {
+                before: true,
+                ..Blanking::of(start, prev.span.end as usize)
+            };
+        }
+    }
+    let own = token.kind == TokenKind::RBrace
+        && matches!(prev.kind, TokenKind::Semi | TokenKind::RBrace)
+        && !parsed.ends_member(prev);
+    let start = member_start(&tokens[..i], parsed, own);
+    let (end, body) = member_extent(text, &tokens[i..]);
+    if let Some(body) = body.filter(|_| keep) {
+        let from = if token.span.start as usize == body {
+            prev.span.start as usize
+        } else {
+            token.span.start as usize
+        };
+        // Some of the header stays: the member's first token is before
+        // what goes.
+        let first = tokens[..i].iter().find(|t| t.span.start as usize >= start);
+        if first.is_some_and(|t| (t.span.start as usize) < from) {
+            return Blanking {
+                header: true,
+                ..Blanking::of(from, body)
+            };
+        }
+    }
+    Blanking::of(start, end)
+}
+
+/// The byte range [`member_around`] blanks for an error, and how it
+/// came by it.
+struct Blanking {
+    start: usize,
+    end: usize,
+    /// The error was taken for the member before it.
+    before: bool,
+    /// Only a header in error goes; the body it opens stays.
+    header: bool,
+}
+
+impl Blanking {
+    /// `start..end`, the range never ending before it starts.
+    fn of(start: usize, end: usize) -> Blanking {
+        Blanking {
+            start,
+            end: end.max(start),
+            before: false,
+            header: false,
+        }
+    }
+}
+
+/// Do the tokens from byte `start` up to `tokens[end]` leave a `(` or
+/// a `[` open?
+fn leaves_group_open(tokens: &[Token], start: usize, end: usize) -> bool {
+    let from = tokens.partition_point(|t| (t.span.start as usize) < start);
+    let mut depth = 0usize;
+    for t in tokens.get(from..end).unwrap_or_default() {
+        match t.kind {
+            TokenKind::LParen | TokenKind::LBracket => depth += 1,
+            TokenKind::RParen | TokenKind::RBracket => depth = depth.saturating_sub(1),
+            _ => {}
+        }
+    }
+    depth > 0
+}
+
+/// Whether the member the syntax error `error`, reported at
+/// `tokens[i]`, belongs to ended with the token before. The parser
+/// reads a line break in an unfinished declaration as its end when the
+/// next line could start a member — a group or a name left open, a
+/// value left out — and reports what it missed at that next line's
+/// first token. A declaration it did not keep then has its error there;
+/// one it kept has the `;` it found missing reported at its end as
+/// well, after the error: the parser reports a member's errors in the
+/// order it reads them, the missing `;` last — an error reported after
+/// that one is the next member's own. Not after a body opening, where
+/// the next line starts the body's first member.
+fn ended_before(text: &str, tokens: &[Token], parsed: &Parsed, i: usize, error: usize) -> bool {
+    let (prev, token) = (&tokens[i - 1], &tokens[i]);
+    if !starts_member_line(text, prev, token) || prev.kind == TokenKind::LBrace {
+        return false;
+    }
+    let end = prev.span.end as usize;
+    match parsed.missing_reported(end) {
+        Some(missing) => error < missing,
+        None => !parsed.ends_member_at(end),
+    }
+}
+
+/// Does `token` start a later line than `prev` with a token that could
+/// start a member — where the parser takes a declaration missing its
+/// terminator to have ended? The keyword connectives continue an
+/// expression instead.
+fn starts_member_line(text: &str, prev: &Token, token: &Token) -> bool {
+    let gap = text.get(prev.span.end as usize..token.span.start as usize);
+    let could_start = match token.kind {
+        TokenKind::Ident => !matches!(token.text(text), "and" | "or" | "xor" | "implies"),
+        kind => matches!(
+            kind,
+            TokenKind::RegularComment
+                | TokenKind::At
+                | TokenKind::Hash
+                | TokenKind::RBrace
+                | TokenKind::Eof
+        ),
+    };
+    could_start && gap.is_some_and(|gap| gap.contains('\n'))
+}
+
+/// Where the member that ends with `tokens` (or with an error right
+/// after them) starts: just after the last member boundary among them,
+/// or at the start of the text. Outside any group, a `;` or a `}` is a
+/// boundary, the way the parser's recovery ends a member; so is a `{`
+/// opening the body the member is in, or the end of a member the parser
+/// kept ([`Parsed::ends_member`]) — both also inside a `(` or `[` group
+/// left unmatched, but not inside a body of the member's own (one its
+/// value opens), whose members are the member's too. With `own_last`
+/// the last of `tokens` is the member's own, a boundary or not.
+fn member_start(tokens: &[Token], parsed: &Parsed, own_last: bool) -> usize {
+    use TokenKind as K;
+    // The closers read whose openers have not been, innermost last.
+    let mut open: Vec<K> = Vec::new();
+    for (k, t) in tokens.iter().rev().enumerate() {
+        let in_body = open.contains(&K::RBrace);
+        let boundary = (!in_body && (t.kind == K::LBrace || parsed.ends_member(t)))
+            || (open.is_empty() && matches!(t.kind, K::Semi | K::RBrace));
+        if boundary && !(own_last && k == 0) {
+            return t.span.end as usize;
+        }
+        let closer = match t.kind {
+            K::RParen | K::RBracket | K::RBrace => {
+                open.push(t.kind);
+                continue;
+            }
+            K::LParen => K::RParen,
+            K::LBracket => K::RBracket,
+            K::LBrace => K::RBrace,
+            _ => continue,
+        };
+        // An opener closes its closer and whatever was left unmatched
+        // since; with no closer for it, it is left unmatched itself.
+        if open.contains(&closer) {
+            while open.pop().is_some_and(|kind| kind != closer) {}
+        }
+    }
+    0
+}
+
+/// Where a member in error starting at `tokens[0]` ends, the way the
+/// parser's recovery skips one: through the `;` that ends it outside
+/// any group, or the `}` that closes a body it opened — never past a
+/// `}` it did not open, which closes the body around it. Like the
+/// recovery, it takes a `)` or `]` to close whatever group was opened
+/// last. It ends before a later line that could start a member, too,
+/// unless a body it opened is still open there: the parser reads an
+/// unfinished declaration as ended there (see [`ended_before`]), and
+/// the next line keeps its own meaning. With the end, where the body
+/// the member ends with opens — its `{`, when it ends with one.
+fn member_extent(text: &str, tokens: &[Token]) -> (usize, Option<usize>) {
+    use TokenKind as K;
+    // The groups the member opened and has not closed, innermost last.
+    let mut open: Vec<K> = Vec::new();
+    // The `{` opened with nothing else open.
+    let mut body = None;
+    for (k, t) in tokens.iter().enumerate() {
+        let body_open = open.contains(&K::LBrace);
+        if k > 0 && !body_open && starts_member_line(text, &tokens[k - 1], t) {
+            return (tokens[k - 1].span.end as usize, None);
+        }
+        match t.kind {
+            K::LBrace => {
+                if open.is_empty() {
+                    body = Some(t.span.start as usize);
+                }
+                open.push(t.kind);
+            }
+            K::LParen | K::LBracket => open.push(t.kind),
+            K::RParen | K::RBracket => {
+                open.pop();
+            }
+            // A body the member opened closes, and with it whatever was
+            // left open inside it.
+            K::RBrace if body_open => {
+                while open.pop().is_some_and(|kind| kind != K::LBrace) {}
+                if open.is_empty() {
+                    return (t.span.end as usize, body);
+                }
+            }
+            K::RBrace | K::Eof => return (t.span.start as usize, None),
+            K::Semi if open.is_empty() => return (t.span.end as usize, None),
+            _ => {}
+        }
+    }
+    (
+        tokens.last().map_or(text.len(), |t| t.span.end as usize),
+        None,
+    )
+}
+
+/// Blank `bytes[start..end]` of a text made from `original`: every byte
+/// but line breaks becomes a space — a line break the original held
+/// there, which a `;` was written over, included — so no offset moves
+/// and no line merges.
+fn blank(bytes: &mut [u8], original: &str, start: usize, end: usize) {
+    let original = original.as_bytes();
+    for (i, b) in bytes.iter_mut().enumerate().take(end).skip(start) {
+        *b = match original.get(i) {
+            Some(&o @ (b'\n' | b'\r')) => o,
+            _ if matches!(*b, b'\n' | b'\r') => *b,
+            _ => b' ',
+        };
+    }
+}
+
+/// Bytes back to text. Blanked ranges start and end on token
+/// boundaries, so the bytes stay UTF-8; the lossy fallback only keeps a
+/// misjudged range from ending the request.
+fn into_text(bytes: Vec<u8>) -> String {
+    String::from_utf8(bytes).unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned())
+}
+
+/// Balance braces: blank each `}` nothing is open for, and close what
+/// is still open at the end of the text.
+fn close_braces(text: &mut String) {
+    let (stray, open) = brace_balance(&significant_tokens(text));
+    if !stray.is_empty() {
+        let mut bytes = std::mem::take(text).into_bytes();
+        for at in stray {
+            bytes[at] = b' ';
+        }
+        *text = into_text(bytes);
+    }
+    for _ in 0..open {
+        text.push_str("\n}");
+    }
+}
+
+/// Where among `tokens` a `}` closes nothing, in order, and how many
+/// bodies are still open after the last of them.
+fn brace_balance(tokens: &[Token]) -> (Vec<usize>, usize) {
+    let mut stray = Vec::new();
+    let mut open = 0usize;
+    for t in tokens {
+        match t.kind {
+            TokenKind::LBrace => open += 1,
+            TokenKind::RBrace if open == 0 => stray.push(t.span.start as usize),
+            TokenKind::RBrace => open -= 1,
+            _ => {}
+        }
+    }
+    (stray, open)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{SalvageCache, salvage, typed_statement_cut};
+    use crate::position::offset32;
+
+    fn parses(text: &str) -> bool {
+        !sysmlv2_parser::parser::parse_source(text).has_errors()
+    }
+
+    /// The text [`typed_statement_cut`] leaves out of `marked`, whose
+    /// `^` marks the statement start and `|` the cursor.
+    fn cut(marked: &str) -> String {
+        let start = marked.find('^').expect("statement start mark");
+        let text = marked.replacen('^', "", 1);
+        let cursor = text.find('|').expect("cursor mark");
+        let text = text.replacen('|', "", 1);
+        let span = typed_statement_cut(&text, offset32(start), offset32(cursor));
+        text[span.start as usize..span.end as usize].to_string()
+    }
+
+    #[test]
+    fn the_cut_takes_the_statement_being_typed() {
+        for (marked, expected) in [
+            // through the line
+            (
+                "part def P {\n^  attribute m = v.|\n  attribute n;\n}",
+                "  attribute m = v.",
+            ),
+            // not the closer of the body around it
+            ("part def P {^ attribute m = v.| }", " attribute m = v. "),
+            ("assert constraint {^ f(v.| }", " f(v. "),
+            // groupings it opened itself, and its own terminator
+            (
+                "part def P {^ attribute m = f(v.|) + 1; attribute n; }",
+                " attribute m = f(v.) + 1;",
+            ),
+            // a body it opens after the cursor, across lines
+            (
+                "part def P {\n^  part x :> v.| {\n    attribute a;\n  }\n  part y;\n}",
+                "  part x :> v. {\n    attribute a;\n  }",
+            ),
+        ] {
+            assert_eq!(cut(marked), expected, "{marked:?}");
+        }
+    }
+
+    #[test]
+    fn a_workspace_is_salvaged_unit_by_unit_and_remembered() {
+        let clean = "package A { part def X; }\n";
+        let broken = "package B {\n  attribute x = ;\n  part def Y;\n}\n";
+        let units = |b: &str| {
+            vec![
+                ("a.sysml".to_string(), clean.to_string()),
+                ("b.sysml".to_string(), b.to_string()),
+            ]
+        };
+        let mut cache = SalvageCache::default();
+        for _ in 0..2 {
+            let out = cache.salvage_all(units(broken));
+            assert_eq!(out[0].1, clean, "a unit that parses stays as it is");
+            assert!(parses(&out[1].1), "{:?}", out[1].1);
+            assert!(out[1].1.contains("part def Y;"), "{:?}", out[1].1);
+        }
+        // A new text is salvaged afresh, not answered from memory.
+        let fixed = "package B {\n  attribute x = 1;\n  part def Y;\n}\n";
+        assert_eq!(cache.salvage_all(units(fixed))[1].1, fixed);
+    }
+
+    #[test]
+    fn parsing_text_is_unchanged() {
+        let text = "package P { part def A; }\n";
+        assert_eq!(salvage(text, false).as_deref(), Some(text));
+    }
+
+    #[test]
+    fn a_missing_value_blanks_its_own_declaration() {
+        // The parser reports the missing expression at the `;` in its
+        // place, which ends the declaration: the declaration is blanked
+        // through it, and the member after it survives, on the same line
+        // or the next.
+        for text in [
+            "package P { attribute x = ; part def Y; }\n",
+            "package P {\n  attribute x = ;\n  part def Y;\n}\n",
+        ] {
+            let out = salvage(text, false).expect("salvaged");
+            assert!(parses(&out), "{out}");
+            assert_eq!(out.len(), text.len(), "offsets hold");
+            assert!(!out.contains("attribute x"), "{out}");
+            assert!(out.contains("part def Y;"), "{out}");
+        }
+    }
+
+    #[test]
+    fn a_member_in_error_is_blanked_in_place() {
+        let text = "package P {\n  part def A {\n    attribute x : = 5;\n  }\n  part a : A;\n}\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert_eq!(out.len(), text.len(), "offsets hold");
+        assert!(!out.contains("attribute"), "{out}");
+        assert!(out.contains("part a : A;"), "the rest survives: {out}");
+        assert_eq!(out.lines().count(), text.lines().count(), "lines hold");
+    }
+
+    #[test]
+    fn a_missing_terminator_is_written_where_the_parser_assumed_it() {
+        // A declaration with no terminator, the next line another member.
+        let text = "package P {\n  attribute y : Real\n  attribute z;\n}\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert_eq!(out.len(), text.len(), "offsets hold");
+        assert_eq!(out.lines().count(), text.lines().count(), "lines hold");
+        for kept in ["attribute y : Real", "attribute z;"] {
+            assert!(out.contains(kept), "{kept} kept: {out}");
+        }
+        // With no indentation to write into, the line break takes it.
+        let text = "package P {\nattribute y : Real\nattribute z;\n}\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert!(out.contains("attribute y : Real;attribute z;"), "{out}");
+    }
+
+    #[test]
+    fn an_unclosed_body_is_closed_at_the_end() {
+        let text = "package P {\n  part def A {\n    attribute x;\n  part def B { part c; }\n}\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert!(out.starts_with(text), "only appended to: {out}");
+    }
+
+    #[test]
+    fn a_stray_closer_is_blanked() {
+        let text = "package P { part def A; } }\npart def B;\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert!(out.contains("part def B;"), "{out}");
+    }
+
+    #[test]
+    fn a_missing_terminator_at_the_end_of_a_kerml_unit() {
+        let text = "package K {\n  private import ScalarValues::*;\n  feature m : Real\n";
+        let out = salvage(text, true).expect("salvaged");
+        assert!(
+            !sysmlv2_parser::parser::parse_kerml_source(&out).has_errors(),
+            "{out}"
+        );
+        assert!(out.contains("private import ScalarValues::*;"), "{out}");
+        assert!(out.contains("feature m : Real;"), "{out}");
+    }
+
+    /// `text` salvaged, checked to parse with every offset and line in
+    /// place.
+    fn salvaged(text: &str) -> String {
+        let out = salvage(text, false).expect("salvaged").into_owned();
+        assert!(parses(&out), "{out}");
+        assert_eq!(out.len(), text.len(), "offsets hold: {out}");
+        assert_eq!(out.lines().count(), text.lines().count(), "lines hold");
+        out
+    }
+
+    /// `text` with the first `member` in it blanked, line breaks kept.
+    fn without(text: &str, member: &str) -> String {
+        let blank = member.bytes().map(|b| if b == b'\n' { '\n' } else { ' ' });
+        text.replacen(member, &blank.collect::<String>(), 1)
+    }
+
+    /// A member whose value is left out before the `}` closing the body
+    /// around it goes whole — the parser reports the missing expression
+    /// at the `;` where the value goes, which still ends the member — as
+    /// does one whose value opens a body and closes it there; the body
+    /// around them stays.
+    #[test]
+    fn a_member_cut_short_before_the_closing_brace_goes_whole() {
+        for (body, member) in [
+            ("part z", "attribute = ;"),
+            ("part z", "attribute q = (1 + ;"),
+            ("perform action a", "in x = ;"),
+            ("part z", "attribute a = f({ in i; i }"),
+        ] {
+            let text = format!(
+                "package P {{\n    part def V {{ attribute m; }}\n    {body} {{ {member} }}\n    part v : V;\n}}\n"
+            );
+            assert_eq!(salvaged(&text), without(&text, member), "{text}");
+        }
+    }
+
+    /// A member left unfinished at the end of its line — a group or a
+    /// name left open, an operand left out — is one the parser reports
+    /// at the next line's first token, whether that starts a member of
+    /// its own (read or not) or closes the body: that member goes alone,
+    /// with no terminator written for it, and the next line stays.
+    #[test]
+    fn a_member_left_unfinished_at_the_end_of_its_line_goes_alone() {
+        for member in [
+            "attribute q = (1 + ;",
+            "attribute q = f(1, ;",
+            "attribute q = (1 + 2",
+            "attribute q = 1 +",
+            "attribute m = 5 [kg",
+            "attribute q = v.",
+            "part x [1..",
+            "part x : V::",
+        ] {
+            for text in [
+                format!("package P {{\n    part def V;\n    {member}\n    part v : V;\n}}\n"),
+                format!(
+                    "package P {{\n    part def V;\n    part w {{\n        {member}\n    }}\n}}\n"
+                ),
+            ] {
+                assert_eq!(salvaged(&text), without(&text, member), "{text}");
+            }
+        }
+        // The next line in error too, each goes alone.
+        let text = "package P {\n    attribute q = 1 +\n    private import\n    part v;\n}\n";
+        let out = without(&without(text, "attribute q = 1 +"), "private import");
+        assert_eq!(salvaged(text), out);
+        // A tail left unfinished after a body goes without the body.
+        let text = "package P {\n    action a {\n        loop action l {\n            action m;\n        } until x >=\n        then action n;\n    }\n}\n";
+        assert_eq!(salvaged(text), without(text, "until x >="));
+    }
+
+    /// A member missing only its `;` is kept, the `;` written, before a
+    /// member in error on the next line, whose error — reported after
+    /// the missing `;` — is that member's own; so is an error on the
+    /// first line of a body. A member the parser kept unfinished on its
+    /// line, reporting what it missed at the token after, goes with the
+    /// member in error at that token.
+    #[test]
+    fn a_member_missing_its_terminator_is_kept_before_one_in_error() {
+        for next in ["attribute z : = 5;", "x y;", "to x;"] {
+            let text = format!("package P {{\n    attribute y : Real\n    {next}\n}}\n");
+            let kept = format!("package P {{\n    attribute y : Real\n;   {next}\n}}\n");
+            assert_eq!(salvaged(&text), without(&kept, next), "{text}");
+        }
+        let text = "package P {\n    part w { attribute a = 1; import X::; }\n    part v;\n}\n";
+        assert_eq!(salvaged(text), without(text, "import X::;"));
+        let text = "package P {\n    part def V {\n        to x;\n    }\n}\n";
+        assert_eq!(salvaged(text), without(text, "to x;"));
+    }
+
+    /// A `)` whose `(` is gone does not stand for every boundary before
+    /// it, nor a `}` inside a group for a body the member opened; a `[`
+    /// left open does not take the `}` closing the body around the member
+    /// for its own, while a `]` closes the `{` opened after the `[`, as
+    /// the parser's recovery reads it; a `}` nothing is open for is an
+    /// error of its own, which leaves the member before it be.
+    #[test]
+    fn unmatched_groupings_leave_the_members_around_them_be() {
+        let text = "package P {\n    part a;\n    part b = f(x));\n    part c;\n}\n";
+        assert_eq!(salvaged(text), without(text, "part b = f(x));"));
+        let text = "package P {\n    assert constraint c {\n        (1..n)->forAll {in i;\n            s#(i+} 1);\n";
+        let out = salvage(text, false).expect("salvaged");
+        assert_eq!(out, without(text, "s#(i+} 1);") + "\n}\n}\n}");
+        let text = "package P {\n    part w { attribute q = [ }\n    part v;\n}\n";
+        assert_eq!(salvaged(text), without(text, "attribute q = ["));
+        let text = "package P {\n    part def D {\n        part p : Q[*{ ] :>> r;\n        part s;\n    }\n}\n";
+        assert_eq!(salvaged(text), without(text, "part p : Q[*{ ] :>> r;"));
+        assert_eq!(
+            salvaged("part def V;\npart x : V\n}\n"),
+            "part def V;\npart x : V\n;\n"
+        );
+    }
+
+    /// A `;` after a body's result expression is the only thing in
+    /// error there: it goes, and the result stays.
+    #[test]
+    fn a_terminator_after_a_result_goes_alone() {
+        for (text, spare) in [
+            (
+                "package P {\n    calc def F { in x : Real; x * 2; }\n    part v;\n}\n",
+                "x * 2;",
+            ),
+            (
+                "package P {\n    calc def F { in x : Real; x * 2;; }\n    part v;\n}\n",
+                "x * 2;;",
+            ),
+            (
+                "package P {\n    calc def F {\n        in x : Real;\n        x * 2;\n    }\n}\n",
+                "x * 2;",
+            ),
+        ] {
+            let result = spare.trim_end_matches(';');
+            let kept = format!("{result}{}", " ".repeat(spare.len() - result.len()));
+            assert_eq!(salvaged(text), text.replacen(spare, &kept, 1), "{text}");
+        }
+    }
+
+    /// A member the parser kept, cut short at the very end of the text
+    /// with nothing after it — no line break to write its `;` into, no
+    /// body around it for balancing to close — takes a `;` after it.
+    #[test]
+    fn a_member_cut_short_at_the_end_of_the_text_is_terminated() {
+        for (text, kept) in [
+            ("part def V;\nprivate import X::*", "private import X::*;"),
+            ("package P { part v; }\nalias A for P", "alias A for P;"),
+        ] {
+            let out = salvage(text, false).expect("salvaged").into_owned();
+            assert!(parses(&out), "{out}");
+            assert!(out.starts_with(text), "offsets hold: {out}");
+            assert!(out.ends_with(kept), "{out}");
+        }
+    }
+
+    /// An error still reported where it was once the member before it
+    /// was blanked for it is the member's at it. Where the parser kept
+    /// none of the members before the error — it read them into the body
+    /// of an expression a stray `{` opened — the member just before is
+    /// lost, not every one back to the `{`, one a round, until the rounds
+    /// run out.
+    #[test]
+    fn an_error_that_blanking_the_member_before_left_is_its_own() {
+        let text = "package P {\n    { part a1;\n    part a2;\n    part a3;\n    part a4;\n    \
+                    part a5;\n    def C :> D { part e; }\n    part f;\n}\n";
+        let out = salvage(text, false).expect("salvaged");
+        let gone = without(&without(text, "part a5;"), "def C :> D { part e; }");
+        assert_eq!(out, gone + "\n}");
+    }
+
+    /// A member that leaves a group open at its `;` (`f(1, ;`) is
+    /// reported at that `;`, which still ends it: the member goes through
+    /// its `;`, the stray line after it goes on its own, and the members
+    /// around them stay.
+    #[test]
+    fn a_group_left_open_at_its_terminator_ends_the_member_there() {
+        let text = "package P {\n    part a;\n    attribute q = f(1, ;\n    /\n    part b { part c; }\n    part d;\n}\n";
+        let gone = without(&without(text, "attribute q = f(1, ;"), "/");
+        assert_eq!(salvaged(text), gone);
+    }
+
+    /// A member the parser read on into the definition on the next line
+    /// — a `return` left without its feature takes that definition for
+    /// one, and reports so at the line after — goes with the definition,
+    /// body and all; the member after it stays.
+    #[test]
+    fn a_member_that_read_on_into_a_body_goes_with_it() {
+        let text = "package K {\n    function f { in x: Integer[1]; return\n    function g { in y: Integer[1]; }\n    function h { in z: Integer[1]; }\n}\n";
+        let out = salvage(text, true).expect("salvaged");
+        let gone = without(text, "return");
+        assert_eq!(
+            out,
+            without(&gone, "function g { in y: Integer[1]; }") + "\n}"
+        );
+    }
+
+    /// A declaration whose header does not parse — a stray `}` in its
+    /// name, a second name, a specialization naming nothing — keeps its
+    /// body: salvage blanks the header from the error up to the body's
+    /// `{` (the token before, when the error is at the `{`), so the
+    /// declaration and its members survive.
+    #[test]
+    fn a_header_in_error_keeps_its_body() {
+        for (text, gone) in [
+            (
+                "package Foo Bar {\n    part def V;\n    part v : V;\n}\n",
+                "Bar",
+            ),
+            (
+                "package Fo}o {\n    part def V;\n    part v : V;\n}\n",
+                "}o",
+            ),
+            ("package Foo} {\n    part def V;\n    part v : V;\n}\n", "}"),
+            (
+                "package P {\n  part def X :> { attribute a; }\n  part def Y;\n}\n",
+                ":>",
+            ),
+        ] {
+            assert_eq!(salvaged(text), without(text, gone), "{text}");
+        }
+        // A header in error from its first token leaves nothing for the
+        // body to belong to: the declaration goes whole, at once.
+        for text in [
+            "package P {\n    123 {\n        part x;\n    }\n    part y;\n}\n",
+            "package P {123 {\n        part x;\n    }\n    part y;\n}\n",
+        ] {
+            let gone = without(text, "123 {\n        part x;\n    }");
+            let parsed = super::Parsed::of(text, false);
+            assert_eq!(
+                super::repair(text, text, &parsed, &[], false, true).text,
+                gone
+            );
+        }
+    }
+
+    /// A string, quoted name, comment or note left open runs to the end
+    /// of the text as the lexer reads it, and would take every member
+    /// after it along: salvage ends it at its own line — blanking it with
+    /// the member it opens, which an error before it does not stretch
+    /// past that line either — and keeps what follows.
+    #[test]
+    fn a_literal_left_open_ends_at_its_own_line() {
+        for open in [
+            "attribute a = \"open",
+            "part 'open",
+            "/* open",
+            "//* open",
+            "attribute a = f(1 +, \"open",
+        ] {
+            let text = format!("package P {{\n    part def V;\n    {open}\n    part v : V;\n}}\n");
+            assert_eq!(salvaged(&text), without(&text, open), "{text}");
+        }
+        // A quote left open pairs with the next one of its kind, and the
+        // literals after it with the wrong quotes, until the last runs to
+        // the end: the literal left open is the first to span a line.
+        for open in ["attribute a = \"open", "part 'open"] {
+            let text = format!(
+                "package P {{\n    part def V;\n    {open}\n    attribute b = \"x\";\n    \
+                 part 'y' : V;\n    attribute c = \"z\";\n    part v : V;\n}}\n"
+            );
+            assert_eq!(salvaged(&text), without(&text, open), "{text}");
+        }
+        // A string spanning lines before a name left open is not the
+        // literal left open.
+        let text = "package P {\n    part def V;\n    attribute s = \"two\nlines\";\n    \
+                    part 'open\n    part v : V;\n}\n";
+        assert_eq!(salvaged(text), without(text, "part 'open"));
+    }
+
+    /// A string or a name spanning lines as written — above a quote left
+    /// open, two of them, below one — is no literal left open, nor is
+    /// one above a comment left open: only the member that opens the
+    /// literal left open goes.
+    #[test]
+    fn a_literal_spanning_lines_as_written_is_not_one_left_open() {
+        let note = "attribute note = \"first line\nsecond line\";";
+        for text in [
+            format!(
+                "package P {{\n    {note}\n    part def V;\n    attribute a = \"open\n    part v : V;\n}}\n"
+            ),
+            format!(
+                "package P {{\n    {note}\n    attribute n = \"third line\nfourth line\";\n    \
+                 part def V;\n    attribute a = \"open\n    part v : V;\n}}\n"
+            ),
+            format!(
+                "package P {{\n    part def V;\n    attribute a = \"open\n    {note}\n    part v : V;\n}}\n"
+            ),
+            "package P {\n    part 'first\nline' : V;\n    part def V;\n    part 'open\n    \
+             part v : V;\n}\n"
+                .to_string(),
+        ] {
+            let open = if text.contains("part 'open") {
+                "part 'open"
+            } else {
+                "attribute a = \"open"
+            };
+            assert_eq!(salvaged(&text), without(&text, open), "{text}");
+        }
+        let text = format!(
+            "package P {{\n    {note}\n    part def V;\n    /* open\n    part v : V;\n}}\n"
+        );
+        assert_eq!(salvaged(&text), without(&text, "/* open"), "{text}");
+    }
+
+    /// A `;` written over a line break — no other whitespace there to
+    /// take it — that a later round blanks gives the line break back:
+    /// every line keeps its place.
+    #[test]
+    fn a_terminator_over_a_line_break_gives_it_back() {
+        let text = "package P {\n    part x [1..\n/* c */\n}\n";
+        let out = salvaged(text);
+        assert_eq!(out, without(text, "part x [1.."));
+    }
+
+    /// Where keeping a body — or what follows a literal left open — does
+    /// not get the text to parse within the rounds, salvage blanks the
+    /// members in error whole, as it did before: a `{` typed into a
+    /// flow's header takes the header apart a token a round.
+    #[test]
+    fn keeping_more_gives_way_to_blanking_whole() {
+        let text = "package P {\n    action def A {\n        action a;\n        action b;\n        \
+                    flow from a.x.y { to b.x;\n    }\n    part v;\n}\n";
+        let kept = super::rounds(text, false, super::Parsed::of(text, false), true);
+        assert_eq!(kept, (None, true));
+        let out = salvage(text, false).expect("salvaged");
+        assert!(parses(&out), "{out}");
+        assert!(out.contains("part v;"), "{out}");
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/signature.rs b/crates/sysmlv2-lsp/src/signature.rs
new file mode 100644
index 0000000..5ac45ac
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/signature.rs
@@ -0,0 +1,587 @@
+//! Signature help: with the cursor in an invocation's argument list
+//! (`KineticEnergy(m, |`), the signature of what the invocation calls —
+//! the line a hover over the callable leads with — and the parameter the
+//! argument being typed binds: by its position among the callable's
+//! inputs (an output takes no argument), or by name when the argument is
+//! written `name = …`. Calculations, constraints, and actions
+//! (definitions and usages), and the KerML functions, predicates, and
+//! behaviors, are the callables.
+//!
+//! Finding the invocation is lexical, on the toolkit's tokens back from
+//! the cursor: the innermost `(` still open that follows a name.
+//! Balanced groups — a body expression passed as an argument
+//! (`f({ in z; z }, |`), a sequence, an index — and strings and comments
+//! are passed over whole; a parenthesis grouping an argument, or a
+//! bracket opened inside one (`f((a + b) * c, 9.8 [m|`), is looked
+//! out of; a `;` ending the statement, or a body the cursor sits in
+//! (`{ in x; |`), ends the search. An invocation on a feature chain
+//! (`g(1, vehicle.ke(|`) calls the chain's last step, resolved as a
+//! member of what the receiver before its dot reaches.
+//! With the cursor in a comment, a note, or a string or quoted name
+//! still open, there is no answer at all; one left open on an earlier
+//! line runs no further than it, and the cursor's line is read on its
+//! own, as completion reads it. Resolving the name is the model's (see
+//! [`Nav::invocation_signature`]).
+
+use crate::nav::Nav;
+use crate::{Document, dialect_of};
+use lsp_types::{
+    Documentation, MarkupContent, MarkupKind, ParameterInformation, ParameterLabel, SignatureHelp,
+    SignatureInformation, Uri,
+};
+use std::collections::BTreeMap;
+use sysmlv2_parser::ast::{Dialect, Expr, ExprKind, Name, QualifiedName, TargetRef};
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+
+/// The invocation whose argument list the cursor sits in.
+struct Call {
+    /// The invoked name, as written.
+    name: QualifiedName,
+    /// On a feature chain (`a.b.f(`), the receiver the name is a
+    /// member of, as written (`a.b`).
+    receiver: Option<String>,
+    /// The position of the argument being typed.
+    argument: usize,
+    /// The parameter the argument being typed names (`name = …`).
+    named: Option<String>,
+}
+
+/// Signature help at `offset` in `uri`: `None` outside an invocation's
+/// argument list, or when what it invokes is not a callable the model
+/// knows.
+pub(crate) fn signature_help(
+    nav: &mut Nav,
+    docs: &BTreeMap<Uri, Document>,
+    uri: &Uri,
+    offset: u32,
+) -> Option<SignatureHelp> {
+    let text = docs.get(uri)?.text.clone();
+    let (call, stmt_start) = call_at(&text, offset, dialect_of(uri))?;
+    // The statement completion cuts out of the model it reads, so the
+    // two read one session.
+    let cut = crate::salvage::typed_statement_cut(&text, stmt_start, offset);
+    let (line, doc) = nav.invocation_signature(docs, uri, cut, &call.callee(dialect_of(uri))?)?;
+    // Arguments bind the inputs, in order; a name no input carries, or a
+    // position past the last, highlights none.
+    let active = match &call.named {
+        Some(n) => line
+            .inputs
+            .iter()
+            .copied()
+            .find(|&i| line.params[i].0 == *n),
+        None => line.inputs.get(call.argument).copied(),
+    }
+    .unwrap_or(line.params.len());
+    let active = u32::try_from(active).ok();
+    let offsets = nav.signature_label_offsets();
+    let parameters = line
+        .params
+        .iter()
+        .map(|(_, range)| ParameterInformation {
+            label: if offsets {
+                ParameterLabel::LabelOffsets([
+                    utf16_len(&line.label[..range.start]),
+                    utf16_len(&line.label[..range.end]),
+                ])
+            } else {
+                ParameterLabel::Simple(line.label[range.clone()].to_string())
+            },
+            documentation: None,
+        })
+        .collect();
+    Some(SignatureHelp {
+        signatures: vec![SignatureInformation {
+            label: line.label,
+            documentation: doc.map(|value| {
+                Documentation::MarkupContent(MarkupContent {
+                    kind: MarkupKind::Markdown,
+                    value,
+                })
+            }),
+            parameters: Some(parameters),
+            active_parameter: active,
+        }],
+        active_signature: Some(0),
+        active_parameter: active,
+    })
+}
+
+impl Call {
+    /// The expression naming what the invocation calls: its name, or
+    /// the chain's step on its receiver. `None` when the receiver does
+    /// not read as an expression.
+    fn callee(&self, dialect: Dialect) -> Option<Expr> {
+        let name = Expr {
+            kind: ExprKind::Ref(self.name.clone()),
+            span: Span::new(0, 0),
+        };
+        let Some(receiver) = &self.receiver else {
+            return Some(name);
+        };
+        Some(Expr {
+            kind: ExprKind::ChainStep {
+                target: Box::new(crate::receiver::parse_receiver(receiver, dialect)?),
+                member: TargetRef::Name(self.name.clone()),
+            },
+            span: Span::new(0, 0),
+        })
+    }
+}
+
+/// A label offset: the protocol counts them in UTF-16 code units.
+fn utf16_len(s: &str) -> u32 {
+    crate::position::offset32(s.encode_utf16().count())
+}
+
+/// The invocation whose argument list the cursor at `offset` sits in
+/// (see the module docs), and where the statement holding it starts —
+/// the one completion cuts out of the model it reads (see
+/// [`crate::site::statement_begins`]); `None` in a comment, a note, or
+/// a string or quoted name being typed. The call is looked for in the
+/// text from the start of a line a few lines back — twice as many each
+/// time the tokens run out before the scan decides — so a long document
+/// is not lexed whole for a `,` typed outside any call. A call found is
+/// settled on the whole text ahead of the cursor, lexed once, as
+/// completion lexes it (see [`crate::site::tokens_ahead`]): a line
+/// start can fall inside a comment or string running into the lines
+/// read, which the scan then reads as code.
+fn call_at(text: &str, offset: u32, dialect: Dialect) -> Option<(Call, u32)> {
+    let prefix = text.get(..offset as usize)?;
+    let mut lines = 1;
+    let found = loop {
+        // The start of the line `lines - 1` lines above the cursor's.
+        let from = prefix
+            .rmatch_indices('\n')
+            .nth(lines - 1)
+            .map_or(0, |(i, _)| i + 1);
+        if from == 0 {
+            // The whole text: read once, below.
+            break None;
+        }
+        let window = &prefix[from..];
+        let lexed = sysmlv2_parser::lexer::tokenize(window).0;
+        match scan(window, &significant(&lexed), dialect, false) {
+            Scan::Nothing => return None,
+            Scan::More => lines *= 2,
+            Scan::Found(call) => break Some((call, from)),
+        }
+    };
+    let (tokens, line) = crate::site::tokens_ahead(prefix);
+    if in_text(prefix, &tokens) {
+        return None;
+    }
+    let read_right = |from: usize| {
+        line.is_none()
+            && !tokens
+                .iter()
+                .any(|t| (t.span.start as usize) < from && from < t.span.end as usize)
+    };
+    let call = match found {
+        Some((call, from)) if read_right(from) => call,
+        // The whole text — or, with a quote left open on an earlier
+        // line running into it, the cursor's line on its own.
+        _ => match scan(
+            prefix,
+            &significant(&tokens[line.unwrap_or(0)..]),
+            dialect,
+            true,
+        ) {
+            Scan::Found(call) => call,
+            Scan::Nothing | Scan::More => return None,
+        },
+    };
+    Some((call, crate::site::statement_begins(prefix, &tokens, line)))
+}
+
+/// The tokens the scan reads: trivia and the end of input dropped.
+fn significant(tokens: &[Token]) -> Vec<Token> {
+    tokens
+        .iter()
+        .copied()
+        .filter(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof)
+        .collect()
+}
+
+/// Does the end of `text`, lexed as `tokens`, sit inside text rather
+/// than code: a line note, or a comment, note, string, or quoted name
+/// still open?
+fn in_text(text: &str, tokens: &[Token]) -> bool {
+    let Some(last) = tokens.iter().rev().find(|t| t.kind != TokenKind::Eof) else {
+        return false;
+    };
+    match last.kind {
+        TokenKind::LineNote => true,
+        TokenKind::Error => {
+            let opened = last.text(text);
+            ["\"", "'", "/*", "//"]
+                .iter()
+                .any(|o| opened.starts_with(o))
+        }
+        _ => false,
+    }
+}
+
+/// What a backward scan over a window's tokens decided.
+enum Scan {
+    /// The call.
+    Found(Call),
+    /// The cursor is in no invocation's argument list.
+    Nothing,
+    /// The window's first token came before anything was decided.
+    More,
+}
+
+/// Scan `tokens` of `window` back from its end (see [`call_at`]).
+/// `whole`: the window starts the text, so running out of tokens means
+/// the statement starts there.
+fn scan(window: &str, tokens: &[Token], dialect: Dialect, whole: bool) -> Scan {
+    use TokenKind as K;
+    // Groups being passed over whole: closers met, openers not yet.
+    let mut closers = 0usize;
+    // Separators met at the level being scanned, and the first of them
+    // (the one closest to the cursor): the argument being typed follows
+    // it.
+    let mut argument = 0usize;
+    let mut last_comma: Option<usize> = None;
+    let mut found: Option<Call> = None;
+    for i in (0..tokens.len()).rev() {
+        let kind = tokens[i].kind;
+        if closers > 0 {
+            match kind {
+                K::RParen | K::RBracket | K::RBrace => closers += 1,
+                K::LParen | K::LBracket | K::LBrace => closers -= 1,
+                _ => {}
+            }
+            continue;
+        }
+        match kind {
+            K::RParen | K::RBracket => closers += 1,
+            // Before the call is found, a `}` closes a body expression
+            // passed as an argument; after it, outside the call's own
+            // parentheses, the member before the statement.
+            K::RBrace if found.is_none() => closers += 1,
+            // The statement ends at a `;`, at a body it sits in, and at
+            // the member before it.
+            K::Semi | K::LBrace | K::RBrace => {
+                return match found {
+                    Some(call) => Scan::Found(call),
+                    None => Scan::Nothing,
+                };
+            }
+            K::LParen if found.is_none() => {
+                let first = last_comma.map_or(i + 1, |c| c + 1);
+                match invoked_name(window, &tokens[..i], dialect) {
+                    // The name may run on before the window.
+                    Some(Head::Call(_, _, 0)) if !whole => return Scan::More,
+                    Some(Head::Select) => return Scan::Nothing,
+                    Some(Head::Call(name, receiver, _)) => {
+                        found = Some(Call {
+                            name,
+                            receiver: None,
+                            // `x->f(a)` passes `x` as the first argument.
+                            argument: argument + usize::from(receiver),
+                            named: named_argument(window, &tokens[first..], dialect),
+                        });
+                    }
+                    Some(Head::Step(name, dot)) => {
+                        let start = match crate::receiver::receiver_start(&tokens[..dot]) {
+                            // The receiver may run on before the window.
+                            Some(0) | None if !whole => return Scan::More,
+                            None => return Scan::Nothing,
+                            Some(start) => start,
+                        };
+                        let receiver = &window
+                            [tokens[start].span.start as usize..tokens[dot].span.start as usize];
+                        found = Some(Call {
+                            name,
+                            receiver: Some(receiver.trim_end().to_string()),
+                            argument,
+                            named: named_argument(window, &tokens[first..], dialect),
+                        });
+                    }
+                    // A group inside an argument: what was counted is
+                    // its own.
+                    None => {
+                        argument = 0;
+                        last_comma = None;
+                    }
+                }
+            }
+            K::LBracket if found.is_none() => {
+                argument = 0;
+                last_comma = None;
+            }
+            K::Comma if found.is_none() => {
+                argument += 1;
+                last_comma.get_or_insert(i);
+            }
+            _ => {}
+        }
+    }
+    match found {
+        Some(call) if whole => Scan::Found(call),
+        None if whole => Scan::Nothing,
+        _ => Scan::More,
+    }
+}
+
+/// What a `(` follows, when a name does.
+enum Head {
+    /// The name it invokes — `f`, `P::f`, `$::P::f` — whether through
+    /// `->` on a receiver, and the index of the name's first token.
+    Call(QualifiedName, bool, usize),
+    /// A feature-chain step (`a.f(`): the name, a member of what the
+    /// receiver ending before the `.` at the index reaches.
+    Step(QualifiedName, usize),
+    /// A name after `.?` (`a.?f(`), where a body belongs: no
+    /// invocation.
+    Select,
+}
+
+/// The name an invocation's `(` follows (see [`Head`]). `None` when no
+/// name precedes the `(` (a grouping parenthesis), or when a keyword
+/// does (`if (`).
+fn invoked_name(seg: &str, before: &[Token], dialect: Dialect) -> Option<Head> {
+    let mut segments = Vec::new();
+    let mut is_global = false;
+    // Back over `Name (:: Name)*`, with `$::` possibly in front; `i`
+    // ends at the path's first token.
+    let mut i = before.len();
+    loop {
+        i = i.checked_sub(1)?;
+        segments.push(name_value(seg, before[i], dialect)?);
+        if i >= 1 && before[i - 1].kind == TokenKind::ColonColon {
+            if i >= 2 && before[i - 2].kind == TokenKind::Dollar {
+                is_global = true;
+                i -= 2;
+                break;
+            }
+            i -= 1;
+            continue;
+        }
+        break;
+    }
+    segments.reverse();
+    let name = QualifiedName {
+        is_global,
+        segments,
+        span: Span::new(0, 0),
+    };
+    let prev = i.checked_sub(1).map(|p| before[p].kind);
+    Some(match prev {
+        Some(TokenKind::Dot) => Head::Step(name, i - 1),
+        Some(TokenKind::DotQuestion) => Head::Select,
+        _ => Head::Call(name, prev == Some(TokenKind::Arrow), i),
+    })
+}
+
+/// The parameter an argument's tokens name, when it is written
+/// `name = …`.
+fn named_argument(seg: &str, argument: &[Token], dialect: Dialect) -> Option<String> {
+    match argument {
+        [name, eq, ..] if eq.kind == TokenKind::Eq => {
+            name_value(seg, *name, dialect).map(|n| n.value)
+        }
+        _ => None,
+    }
+}
+
+/// A name token's value — a basic name the dialect does not reserve, or
+/// a quoted name, unescaped.
+fn name_value(seg: &str, t: Token, dialect: Dialect) -> Option<Name> {
+    let text = t.text(seg);
+    let value = match t.kind {
+        TokenKind::Ident if !sysmlv2_parser::parser::is_reserved(dialect, text) => text.to_string(),
+        TokenKind::UnrestrictedName => sysmlv2_parser::lexer::unescape(text),
+        _ => return None,
+    };
+    Some(Name {
+        value,
+        span: Span::new(0, 0),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::call_at;
+    use crate::position::offset32;
+    use sysmlv2_parser::ast::Dialect;
+
+    /// The call at the end of `stmt`: its name as written — after its
+    /// receiver and a `.` on a feature chain — the argument position,
+    /// and the named parameter.
+    fn call(stmt: &str) -> Option<(String, usize, Option<String>)> {
+        call_at(stmt, offset32(stmt.len()), Dialect::Sysml).map(|(c, _)| {
+            let name = c
+                .name
+                .segments
+                .iter()
+                .map(|s| s.value.as_str())
+                .collect::<Vec<_>>()
+                .join("::");
+            let name = if c.name.is_global {
+                format!("$::{name}")
+            } else {
+                name
+            };
+            let name = match c.receiver {
+                Some(receiver) => format!("{receiver}.{name}"),
+                None => name,
+            };
+            (name, c.argument, c.named)
+        })
+    }
+
+    #[test]
+    fn finds_the_innermost_open_invocation() {
+        let at = |name: &str, argument: usize| Some((name.to_string(), argument, None));
+        assert_eq!(call("attribute e = KineticEnergy("), at("KineticEnergy", 0));
+        assert_eq!(
+            call("attribute e = KineticEnergy(m, "),
+            at("KineticEnergy", 1)
+        );
+        assert_eq!(call("attribute e = P::Q::F(a, b, c"), at("P::Q::F", 2));
+        assert_eq!(call("attribute e = $::P::F("), at("$::P::F", 0));
+        assert_eq!(call("attribute e = 'my calc'(1, "), at("my calc", 1));
+        // Nested: the inner call while it is open, the outer after it.
+        assert_eq!(call("attribute e = f(1, g(2, "), at("g", 1));
+        assert_eq!(call("attribute e = f(1, g(2, 3), "), at("f", 2));
+        // A group, a sequence, or a unit bracket inside an argument.
+        assert_eq!(call("attribute e = f(a, (b + c) * "), at("f", 1));
+        assert_eq!(call("attribute e = f(a, (b, c"), at("f", 1));
+        assert_eq!(call("attribute e = f(a, 9.8 [m"), at("f", 1));
+        // `->` passes the receiver first, a chain for one included.
+        assert_eq!(call("attribute e = xs->including("), at("including", 1));
+        assert_eq!(call("attribute e = x.y->f("), at("f", 1));
+        // A closed call on a feature chain is an argument like any other.
+        assert_eq!(call("attribute e = g(1, a.f(2), "), at("g", 2));
+        // An open one is the call: the chain's step, on its receiver.
+        assert_eq!(call("attribute e = a.f("), at("a.f", 0));
+        assert_eq!(call("attribute e = g(1, a.b.f(2, "), at("a.b.f", 1));
+        assert_eq!(call("attribute e = P::a.f(x, "), at("P::a.f", 1));
+        assert_eq!(call("attribute e = $::P::a.f("), at("$::P::a.f", 0));
+        assert_eq!(call("attribute e = xs#(1).f("), at("xs#(1).f", 0));
+        assert_eq!(call("attribute e = g(x).f(y, "), at("g(x).f", 1));
+        assert_eq!(call("attribute e = (a + b).f("), at("(a + b).f", 0));
+        // A receiver starting lines before the call.
+        assert_eq!(
+            call(
+                "part def P {\n    attribute e = a\n        .b\n        .f(\n            1,\n            "
+            ),
+            at("a\n        .b.f", 1)
+        );
+        // Inside a body expression, the call the body holds.
+        assert_eq!(call("attribute e = xs->select {in x; f("), at("f", 0));
+        // After a body expression passed as an argument, and past a
+        // string or comment holding a statement's punctuation.
+        assert_eq!(call("attribute e = f({ in z; z }, "), at("f", 1));
+        assert_eq!(call("attribute e = f(\"a;b}\", "), at("f", 1));
+        assert_eq!(call("attribute e = f(a /* ; { */, "), at("f", 1));
+        // Across lines, however many.
+        assert_eq!(
+            call("part def P {\n    attribute e = f(\n        a,\n\n\n        b,\n        "),
+            at("f", 2)
+        );
+    }
+
+    #[test]
+    fn named_arguments_name_their_parameter() {
+        assert_eq!(
+            call("attribute e = KineticEnergy(v = 3, m = "),
+            Some(("KineticEnergy".to_string(), 1, Some("m".to_string())))
+        );
+        assert_eq!(
+            call("attribute e = f(a == "),
+            Some(("f".to_string(), 0, None)),
+            "a comparison names nothing"
+        );
+    }
+
+    /// The whole text ahead of the cursor is lexed once for a call
+    /// found — whether in the lines read first or only in the whole
+    /// text — and not at all for a `,` typed outside any call.
+    #[test]
+    fn the_text_ahead_is_lexed_once() {
+        let lexes = |stmt: &str| {
+            crate::site::PREFIX_LEXES.with(|n| n.set(0));
+            let found = call_at(stmt, offset32(stmt.len()), Dialect::Sysml).is_some();
+            (found, crate::site::PREFIX_LEXES.with(std::cell::Cell::get))
+        };
+        assert_eq!(
+            lexes("package P {\n    part def Q;\n    attribute e = f(1, "),
+            (true, 1)
+        );
+        assert_eq!(lexes("attribute e = f(\n    1,\n    "), (true, 1));
+        assert_eq!(
+            lexes("package P {\n    part def Q;\n    attribute e = (1, "),
+            (false, 0)
+        );
+    }
+
+    #[test]
+    fn nothing_in_a_comment_or_string() {
+        for stmt in [
+            // A doc comment whose earlier line holds a statement's
+            // punctuation, the window starting inside it.
+            "part def V {\n    doc /* The energy\n     * of a moving mass; see below }\n     * KineticEnergy(m, ",
+            "attribute e = KineticEnergy(m, // with (a, ",
+            "attribute e = KineticEnergy(\"a, ",
+            "attribute e = KineticEnergy(m, /* (a, ",
+            "attribute e = KineticEnergy(m, 'my (a, ",
+        ] {
+            assert_eq!(call(stmt), None, "{stmt:?}");
+        }
+        // After a closed comment or string, the call is still there.
+        assert_eq!(
+            call("attribute e = f(m /* (c; */, \"d(\", "),
+            Some(("f".to_string(), 2, None))
+        );
+    }
+
+    /// A quote left open on an earlier line runs no further than it:
+    /// the cursor's line is read on its own, as completion reads it —
+    /// the call typed there found, and none around it before the line.
+    #[test]
+    fn a_quote_left_open_above_runs_no_further_than_it() {
+        for (stmt, statement) in [
+            (
+                "package P {\n    attribute s = \"open;\n    attribute e = f(1, ",
+                "attribute e = f(1, ",
+            ),
+            (
+                "package P {\n    attribute 'open = 1;\n    attribute e = f('a', ",
+                "attribute e = f('a', ",
+            ),
+        ] {
+            assert_eq!(call(stmt), Some(("f".to_string(), 1, None)), "{stmt:?}");
+            let (_, start) = call_at(stmt, offset32(stmt.len()), Dialect::Sysml).expect("call");
+            assert_eq!(&stmt[start as usize..], statement);
+        }
+        for stmt in [
+            "package P {\n    attribute s = g(\"open;\n    attribute e = (1, ",
+            "package P {\n    attribute s = g(\"open;\n    h(\n    attribute e = (1, ",
+        ] {
+            assert_eq!(call(stmt), None, "{stmt:?}");
+        }
+    }
+
+    #[test]
+    fn nothing_outside_an_argument_list() {
+        for stmt in [
+            "attribute e = KineticEnergy(m, v)",
+            "attribute e = (a + ",
+            "attribute e = if (",
+            // `.?` takes a body: a name after it invokes nothing, and
+            // the call around it is not the one being typed.
+            "attribute e = g(1, a.?f(",
+            // A dot no receiver reads before.
+            "attribute e = g(1, .f(",
+            "attribute e = f(a, {in x; ",
+            "attribute e = \"f(",
+            "attribute e = f(a); attribute g = ",
+        ] {
+            assert_eq!(call(stmt), None, "{stmt:?}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/site.rs b/crates/sysmlv2-lsp/src/site.rs
new file mode 100644
index 0000000..c51c04f
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/site.rs
@@ -0,0 +1,3461 @@
+//! Where a completion request's cursor sits. One pass over the
+//! toolkit's tokens of the text ahead of the cursor answers what the
+//! completion tier must know before it offers anything:
+//!
+//! - whether there is anything to complete at all. Inside a comment, a
+//!   note, a documentation body, or a string literal there is not, and
+//!   neither is there inside a number (`5.`, `1.5e`) or at a range bound
+//!   (`[0..`, `[1..*`) — not even when a trigger character opened the
+//!   request;
+//! - where the statement being typed starts: its first token after the
+//!   last `;`, `{`, or `}` token, or after a comment body, which ends
+//!   the comment, `doc`, or `rep` member it belongs to. Boundaries
+//!   inside comments, notes, strings, and quoted names never count;
+//! - whether that statement is an import, whether it leaves a `[` open
+//!   ahead of the word being completed, and where the quoted name the
+//!   cursor is typing opens, if it is typing one;
+//! - what the word being completed fills: a name the statement declares
+//!   (`part def Boat`, `in item fuel`, an enumeration literal) is new,
+//!   so no existing element belongs there — only the keywords the
+//!   grammar allows in its place (`part` + `def`);
+//! - and otherwise which keywords and which kinds of element the
+//!   position takes, best-fitting first: the definitions a usage of the
+//!   statement's kind may be typed by after `:` (see
+//!   [`crate::kinds::typed_by`]), the definitions a definition may
+//!   specialize after `:>`, features after `:>` on a usage and after
+//!   `:>>`, expression operands after `=`, the keywords the enclosing
+//!   body takes at a statement's start, metadata definitions after `#`
+//!   and `@`, the referenced kind after `perform`, `exhibit`, `satisfy`,
+//!   …. A position the statement does not tell apart takes everything;
+//! - which of the enclosing element's features the position names ahead
+//!   of every other name (see [`Members`]): a redefinition its inherited
+//!   ones, a succession and a usage's subsetting those in scope, a
+//!   metadata body its metadata definition's;
+//! - and where measurement units rank among an expression's operands:
+//!   after every other name, or first where the statement's type is a
+//!   unit type (see [`Want::unit_group`]). Within a group shorter names
+//!   rank first (see [`sort_text`]).
+//!
+//! The declared-name positions are transcribed from the normative
+//! grammars into one table per dialect, which a test keeps sorted and
+//! made of the dialect's reserved words: each keyword after which the
+//! next word is a name being declared, with the keywords that may stand
+//! there instead. A keyword whose next word may be a reference is not
+//! in the table, so completion stays on after it — `perform` (`perform
+//! takePicture`), `then`, `first` — and neither is one whose next word
+//! is either a name being declared or a reference, as only the rest of
+//! the statement tells: `transition` (`transition t first s …` beside
+//! `transition s then t`), `accept`, `flow`, `message`, `interface`,
+//! `metadata`, `dependency`, and in KerML `connector`, `binding`,
+//! `succession`, and `featuring`.
+
+use crate::kinds::{ALL_DEFINITIONS, CALLABLES, Decl};
+use std::collections::HashSet;
+use sysmlv2_parser::ast::{DefKind, Dialect, UsageKind};
+use sysmlv2_parser::parser::is_reserved;
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+
+/// What one token pass over the text ahead of the cursor tells about
+/// the statement being typed.
+pub(crate) struct Scan {
+    /// Byte offset where the statement starts: its first token after
+    /// the last `;`, `{`, `}`, or comment body token ahead of the cursor
+    /// (notes and whitespace skipped), the cursor when it has none yet —
+    /// never on the end of the member before it, which a position query
+    /// there would take for the enclosing element.
+    pub stmt_start: u32,
+    /// The statement is an import: `import` is among its words.
+    pub import: bool,
+    /// The statement leaves a `[` open ahead of the word being
+    /// completed — the cursor sits where a quantity's unit is written
+    /// (`9.8 [m`). A multiplicity (`[0..*]`) counts too: the tokens
+    /// cannot tell the two apart, and names are rarely typed into one.
+    pub in_bracket: bool,
+    /// The opening quote of the quoted name the cursor is typing
+    /// (`'metre per sec|`): the text ahead of the cursor ends in a
+    /// quoted name left open on the cursor's line. A quote inside a
+    /// comment, a string, or a note never counts, and one left open on
+    /// an earlier line runs no further than it (see [`tokens_ahead`]).
+    pub quote: Option<u32>,
+    /// What the word being completed fills.
+    pub slot: Slot,
+}
+
+/// What the word being completed fills.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum Slot {
+    /// Nothing to complete: the cursor is in a comment, a note, a
+    /// documentation body, or a string literal, in a number, or at a
+    /// range bound.
+    Quiet,
+    /// A name the statement declares: only these keywords may stand in
+    /// its place.
+    Declared(Vec<&'static str>),
+    /// A position the statement tells apart: the keywords and the kinds
+    /// of element it takes.
+    Want(Want),
+    /// A position the statement does not tell apart: every keyword and
+    /// every name.
+    Open,
+}
+
+/// The body a statement is a member of, as far as the keywords its
+/// members start with and the names they declare or take tell apart.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Body {
+    /// The root namespace, or a package's or namespace's body.
+    Namespace,
+    /// The body of a definition or usage of structure: a part, an item,
+    /// a port, an attribute, a connection, ….
+    Definition,
+    /// An action's body, which also takes nodes and successions.
+    Action,
+    /// A state's body, which also takes entry, do, and exit actions and
+    /// transitions.
+    State,
+    /// A calculation's, a constraint's, or a case's body, ending in a
+    /// result expression; a case's also takes a subject, actors, and an
+    /// objective.
+    Calculation { case: bool },
+    /// A requirement's, a concern's, or a viewpoint's body.
+    Requirement,
+    /// A view's body, which also takes exposures, filters, and
+    /// renderings.
+    View,
+    /// An enumeration definition's body, whose bare members declare
+    /// its literals (`enum def Color { red; green; }`).
+    Enumeration,
+    /// A metadata usage's body, whose members redefine the metadata's
+    /// features, naming them as references (`@Safety { ref isMandatory
+    /// = true; }`).
+    Metadata,
+    /// A KerML type's or feature's body.
+    Type,
+    /// A KerML function's, predicate's, or expression's body, ending in
+    /// a result expression.
+    Function,
+    /// A body its header does not tell.
+    Other,
+}
+
+/// Scan `text`, written in `dialect`, up to `offset`, the word being
+/// completed spanning `word_start..offset`.
+pub(crate) fn scan(text: &str, word_start: u32, offset: u32, dialect: Dialect) -> Scan {
+    let prefix = &text[..text.floor_char_boundary(offset as usize)];
+    let word_start = prefix.floor_char_boundary(word_start as usize);
+    let (tokens, line) = tokens_ahead(prefix);
+    let last = tokens
+        .iter()
+        .rev()
+        .find(|t| t.kind != TokenKind::Eof)
+        .copied();
+    // A quoted name being typed (`'Vehicle On`) is the word being
+    // completed, from its opening quote on.
+    let quoted = last.filter(|t| t.kind == TokenKind::Error && t.text(prefix).starts_with('\''));
+    let cut = quoted.map_or(word_start, |q| word_start.min(q.span.start as usize));
+    let (begin, depth, bodies) = statement(prefix, &tokens, line);
+    let statement = significant(&tokens[begin..]);
+    let stmt_start = statement
+        .first()
+        .map_or(crate::position::offset32(prefix.len()), |t| t.span.start);
+    let head: Vec<Token> = statement
+        .into_iter()
+        .filter(|t| t.span.end as usize <= cut)
+        .collect();
+    let quiet = quoted.is_none()
+        && (last.is_some_and(|t| in_prose(prefix, t)) || in_number(prefix, &tokens, word_start));
+    let line_start = prefix.rfind('\n').map_or(0, |i| i + 1);
+    Scan {
+        stmt_start,
+        import: head.iter().any(|t| t.is_kw(prefix, "import")),
+        in_bracket: depth > 0,
+        quote: quoted
+            .map(|q| q.span.start)
+            .filter(|&open| open as usize >= line_start),
+        slot: if quiet {
+            Slot::Quiet
+        } else {
+            slot(
+                prefix,
+                &head,
+                bodies.last().copied().unwrap_or(Body::Namespace),
+                depth > 0,
+                dialect,
+            )
+        },
+    }
+}
+
+#[cfg(test)]
+thread_local! {
+    /// Lexes of the whole text ahead of the cursor on this thread, so a
+    /// test can pin what one request costs.
+    pub(crate) static PREFIX_LEXES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Where the statement being typed at the end of `prefix`, the text
+/// ahead of the cursor lexed as `tokens` and `line` by [`tokens_ahead`],
+/// starts: its first token (see [`statement`]), the cursor when it has
+/// none yet. Completion cuts this statement out of the model it reads,
+/// and so does signature help: the two share one session.
+pub(crate) fn statement_begins(prefix: &str, tokens: &[Token], line: Option<usize>) -> u32 {
+    let (begin, _, _) = statement(prefix, tokens, line);
+    tokens[begin..]
+        .iter()
+        .find(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof)
+        .map_or(crate::position::offset32(prefix.len()), |t| t.span.start)
+}
+
+/// A group the text ahead of the cursor leaves open.
+#[derive(Clone, Copy)]
+enum Group {
+    Paren,
+    Bracket,
+    /// A body: an expression's, passed within a `(` or `[` (`f({ in x;
+    /// x }, …)`), keeps where the statement around it began and the
+    /// brackets it had open, for that statement goes on past its `}`.
+    Brace(Option<(usize, usize)>),
+}
+
+/// The statement being typed at the end of `tokens`, the toolkit's
+/// tokens of `prefix` (see [`tokens_ahead`]): the index of the token it
+/// begins at, how many `[` it leaves open, and the bodies around it,
+/// innermost last. A statement begins after a `;`, a `{`, a `}`, or a
+/// comment body — but an expression's body passed within a `(` or `[`
+/// is part of the statement it sits in (`Twice({ in z; z }, v.|`) — and
+/// no earlier than `line`, the token the cursor's line starts at when
+/// it is read on its own.
+fn statement(prefix: &str, tokens: &[Token], line: Option<usize>) -> (usize, usize, Vec<Body>) {
+    // Groups a statement left open end with it, back to its body.
+    fn settle(groups: &mut Vec<Group>) {
+        while matches!(groups.last(), Some(Group::Paren | Group::Bracket)) {
+            groups.pop();
+        }
+    }
+    let mut begin = 0;
+    let mut depth = 0usize;
+    let mut bodies: Vec<Body> = Vec::new();
+    let mut groups: Vec<Group> = Vec::new();
+    for (i, t) in tokens.iter().enumerate() {
+        if line == Some(i) {
+            begin = i;
+            depth = 0;
+            settle(&mut groups);
+        }
+        match t.kind {
+            TokenKind::LParen => groups.push(Group::Paren),
+            TokenKind::RParen => {
+                if matches!(groups.last(), Some(Group::Paren)) {
+                    groups.pop();
+                }
+            }
+            TokenKind::LBracket => {
+                groups.push(Group::Bracket);
+                depth += 1;
+            }
+            TokenKind::RBracket => {
+                if matches!(groups.last(), Some(Group::Bracket)) {
+                    groups.pop();
+                }
+                depth = depth.saturating_sub(1);
+            }
+            TokenKind::LBrace => {
+                bodies.push(Body::opened_by(prefix, &significant(&tokens[begin..i])));
+                let around = matches!(groups.last(), Some(Group::Paren | Group::Bracket))
+                    .then_some((begin, depth));
+                groups.push(Group::Brace(around));
+                begin = i + 1;
+                depth = 0;
+            }
+            TokenKind::RBrace => {
+                bodies.pop();
+                settle(&mut groups);
+                if let Some(Group::Brace(Some((outer, open)))) = groups.pop() {
+                    begin = outer;
+                    depth = open;
+                } else {
+                    begin = i + 1;
+                    depth = 0;
+                }
+            }
+            TokenKind::Semi => {
+                settle(&mut groups);
+                begin = i + 1;
+                depth = 0;
+            }
+            TokenKind::RegularComment => {
+                begin = i + 1;
+                depth = 0;
+            }
+            _ => {}
+        }
+    }
+    (begin, depth, bodies)
+}
+
+/// The toolkit's tokens of `prefix`, the text ahead of the cursor. A
+/// quote left open on an earlier line — of a quoted name, or of a
+/// string, which then runs to the end — runs into the cursor's line,
+/// swallowing it, or pairing with the first quote on it and flipping
+/// every pairing after that: the line is then read on its own, as an
+/// editor shows it, and the statement starts no earlier than the line;
+/// its first token's index comes along.
+pub(crate) fn tokens_ahead(prefix: &str) -> (Vec<Token>, Option<usize>) {
+    #[cfg(test)]
+    PREFIX_LEXES.with(|n| n.set(n.get() + 1));
+    let mut tokens = sysmlv2_parser::lexer::tokenize(prefix).0;
+    let line_start = prefix.rfind('\n').map_or(0, |i| i + 1);
+    let runs_in = tokens.iter().position(|t| {
+        let from = &prefix[t.span.start as usize..];
+        (t.span.start as usize) < line_start
+            && line_start < t.span.end as usize
+            && (from.starts_with('\'') || (t.kind == TokenKind::Error && from.starts_with('"')))
+    });
+    let Some(at) = runs_in else {
+        return (tokens, None);
+    };
+    tokens.truncate(at);
+    let base = crate::position::offset32(line_start);
+    tokens.extend(
+        sysmlv2_parser::lexer::tokenize(&prefix[line_start..])
+            .0
+            .into_iter()
+            .map(|t| Token::new(t.kind, Span::new(t.span.start + base, t.span.end + base))),
+    );
+    (tokens, Some(at))
+}
+
+/// What the word after the statement's `head` fills, in a member of
+/// `body`; `bracket`: the statement leaves a `[` open.
+fn slot(src: &str, head: &[Token], body: Body, bracket: bool, dialect: Dialect) -> Slot {
+    if let Some(keywords) = declared(src, head, body, dialect) {
+        return Slot::Declared(keywords);
+    }
+    // Inside a bracket the statement leaves open, a unit is written
+    // (`9.8 [m/s`, a name typed word by word: `[metre per`), or a
+    // multiplicity: no position class describes it.
+    if bracket {
+        return Slot::Open;
+    }
+    match position(src, head, body, dialect) {
+        Some(mut want) => {
+            want.keywords.retain(|&(k, _)| is_reserved(dialect, k));
+            let mut seen = std::collections::HashSet::new();
+            want.keywords.retain(|&(k, _)| seen.insert(k));
+            Slot::Want(want)
+        }
+        None => Slot::Open,
+    }
+}
+
+/// The tokens that are not trivia (whitespace and notes), the end
+/// marker dropped.
+fn significant(tokens: &[Token]) -> Vec<Token> {
+    tokens
+        .iter()
+        .filter(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof)
+        .copied()
+        .collect()
+}
+
+/// Is the cursor in prose: a comment, a note, a documentation body, or
+/// a string literal? The text ahead of the cursor ends inside one when
+/// its `last` token is a line note (which runs to the end of its line)
+/// or an unterminated comment, note, or string.
+fn in_prose(prefix: &str, last: Token) -> bool {
+    match last.kind {
+        TokenKind::LineNote => true,
+        TokenKind::Error => {
+            let text = last.text(prefix);
+            text.starts_with("/*") || text.starts_with("//*") || text.starts_with('"')
+        }
+        _ => false,
+    }
+}
+
+/// Is the word being completed part of a number or a range bound? A
+/// name never starts with a digit, so a word that does is a number
+/// (`12`, `1.5e`); with no word typed yet, the cursor may follow a
+/// number's decimal point (`5.`) or stand where one begins (`= .`), a
+/// range's `..` (`[0..`), the infinity literal (`[1..*`), or an
+/// exponent's sign (`1.5e-`).
+fn in_number(prefix: &str, tokens: &[Token], word_start: usize) -> bool {
+    if let Some(c) = prefix[word_start..].chars().next() {
+        return c.is_ascii_digit();
+    }
+    let mut ahead = tokens
+        .iter()
+        .rev()
+        .filter(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof);
+    let Some(last) = ahead.next() else {
+        return false;
+    };
+    let before = ahead.next();
+    match last.kind {
+        TokenKind::DotDot => true,
+        TokenKind::Dot => before.is_none_or(|b| {
+            matches!(b.kind, TokenKind::Decimal | TokenKind::Exp) || !ends_operand(b.kind)
+        }),
+        TokenKind::Star => before.is_none_or(|b| !ends_operand(b.kind)),
+        TokenKind::Plus | TokenKind::Minus => {
+            let letter = before.filter(|e| {
+                e.kind == TokenKind::Ident
+                    && e.span.end == last.span.start
+                    && matches!(e.text(prefix), "e" | "E")
+            });
+            letter.zip(ahead.next()).is_some_and(|(e, mantissa)| {
+                mantissa.kind == TokenKind::Decimal && mantissa.span.end == e.span.start
+            })
+        }
+        _ => false,
+    }
+}
+
+/// Can a token of this kind end an operand, so that an operator may
+/// follow it (`a *` is a product, `[*` the infinity literal)?
+fn ends_operand(kind: TokenKind) -> bool {
+    matches!(
+        kind,
+        TokenKind::Ident
+            | TokenKind::UnrestrictedName
+            | TokenKind::String
+            | TokenKind::Decimal
+            | TokenKind::Exp
+            | TokenKind::RParen
+            | TokenKind::RBracket
+            | TokenKind::RBrace
+    )
+}
+
+impl Body {
+    /// The body a `{` opens, from the significant tokens of the
+    /// statement it ends (visibility and prefix metadata first, then
+    /// the declaration's head).
+    fn opened_by(src: &str, header: &[Token]) -> Body {
+        let rest = &header[past_prefixes(src, header)..];
+        // An expression's body: `->collect { … }`.
+        if let [.., arrow, name] = rest {
+            if arrow.kind == TokenKind::Arrow && name.kind == TokenKind::Ident {
+                return Body::Calculation { case: false };
+            }
+        }
+        if rest.first().is_some_and(|t| t.kind == TokenKind::At) {
+            return Body::Metadata;
+        }
+        let words: Vec<&str> = rest
+            .iter()
+            .filter(|t| t.kind == TokenKind::Ident)
+            .map(|t| t.text(src))
+            .collect();
+        if let Some(at) = words.iter().position(|w| *w == "def") {
+            return match at.checked_sub(1).map(|i| words[i]) {
+                Some("action") => Body::Action,
+                Some("state") => Body::State,
+                Some("calc" | "constraint") => Body::Calculation { case: false },
+                Some("case" | "analysis" | "verification") => Body::Calculation { case: true },
+                Some("requirement" | "concern" | "viewpoint") => Body::Requirement,
+                Some("view") => Body::View,
+                Some("enum") => Body::Enumeration,
+                _ => Body::Definition,
+            };
+        }
+        for w in words {
+            return match w {
+                // Prefixes: the kind is still to come.
+                "abstract" | "composite" | "const" | "constant" | "derived" | "end" | "in"
+                | "individual" | "inout" | "out" | "portion" | "snapshot" | "then"
+                | "timeslice" | "use" | "var" | "variation" => continue,
+                "accept" | "action" | "assign" | "decide" | "do" | "else" | "entry" | "exit"
+                | "for" | "fork" | "if" | "join" | "loop" | "merge" | "perform" | "send"
+                | "terminate" | "transition" | "while" => Body::Action,
+                "exhibit" | "state" => Body::State,
+                "assert" | "assume" | "calc" | "constraint" | "require" => {
+                    Body::Calculation { case: false }
+                }
+                "analysis" | "case" | "include" | "verification" => {
+                    Body::Calculation { case: true }
+                }
+                "concern" | "frame" | "objective" | "requirement" | "satisfy" | "verify"
+                | "viewpoint" => Body::Requirement,
+                "view" => Body::View,
+                "metadata" => Body::Metadata,
+                "library" | "namespace" | "package" | "standard" => Body::Namespace,
+                "assoc" | "behavior" | "class" | "classifier" | "connector" | "datatype"
+                | "feature" | "interaction" | "metaclass" | "multiplicity" | "step" | "struct"
+                | "type" => Body::Type,
+                "bool" | "expr" | "function" | "inv" | "predicate" => Body::Function,
+                "alias" | "dependency" | "expose" | "filter" | "import" => Body::Other,
+                // Any other usage keyword, or the name of a usage declared
+                // without one.
+                _ => Body::Definition,
+            };
+        }
+        Body::Other
+    }
+
+    /// Does a statement at this body's top level read as its result
+    /// expression when it does not start with a declaration keyword?
+    fn results(self) -> bool {
+        matches!(self, Body::Calculation { .. } | Body::Function)
+    }
+}
+
+/// How many leading tokens of a statement are its visibility and its
+/// prefix metadata annotations (`private #Safety #Security::Level`).
+fn past_prefixes(src: &str, stmt: &[Token]) -> usize {
+    let mut i = 0;
+    while let Some(t) = stmt.get(i) {
+        let named = stmt
+            .get(i + 1)
+            .is_some_and(|n| matches!(n.kind, TokenKind::Ident | TokenKind::UnrestrictedName));
+        if t.kind == TokenKind::Hash && named {
+            i = past_annotation(stmt, i);
+        } else if t.kind == TokenKind::Ident && is_visibility(t.text(src)) {
+            i += 1;
+        } else {
+            break;
+        }
+    }
+    i
+}
+
+/// The index past the prefix metadata annotation at `stmt[at]` (its
+/// `#`), which names a metadata definition by qualified name.
+fn past_annotation(stmt: &[Token], at: usize) -> usize {
+    let mut i = at + 1;
+    while stmt
+        .get(i)
+        .is_some_and(|t| matches!(t.kind, TokenKind::Ident | TokenKind::UnrestrictedName))
+    {
+        i += 1;
+        if stmt.get(i).is_some_and(|t| t.kind == TokenKind::ColonColon) {
+            i += 1;
+        } else {
+            break;
+        }
+    }
+    i
+}
+
+/// May every token of `ahead` prefix a definition? Then a `def` may
+/// follow the kind keyword after it (`abstract #Safety part def`, not
+/// `ref part def`).
+fn definition_prefix(src: &str, ahead: &[Token]) -> bool {
+    let mut i = 0;
+    while let Some(t) = ahead.get(i) {
+        if t.kind == TokenKind::Hash {
+            i = past_annotation(ahead, i);
+        } else if t.kind == TokenKind::Ident && DEFINITION_PREFIXES.contains(&t.text(src)) {
+            i += 1;
+        } else {
+            return false;
+        }
+    }
+    true
+}
+
+fn is_visibility(word: &str) -> bool {
+    matches!(word, "public" | "private" | "protected")
+}
+
+/// A keyword after which the next word is a name the statement
+/// declares.
+struct Declarer {
+    keyword: &'static str,
+    /// The keywords that may take the name's place and continue the
+    /// declaration's head: `part` → `def`, `in` → `item`, `comment` →
+    /// `about`. A `def` among them is offered only where every word
+    /// ahead of the keyword may prefix a definition.
+    instead: &'static [&'static [&'static str]],
+}
+
+const fn declarer(keyword: &'static str, instead: &'static [&'static [&'static str]]) -> Declarer {
+    Declarer { keyword, instead }
+}
+
+const NOTHING: &[&[&str]] = &[];
+/// A usage's kind keyword: `def` makes it a definition's; a usage with no
+/// name of its own often redefines one right away (`part redefines
+/// engine`) — the one keyword after a name the table offers.
+const DEF: &[&[&str]] = &[&["def", "redefines"]];
+
+/// The SysML keywords naming a usage's kind, which may follow its prefix
+/// keywords (`in item`, `ref part`, `abstract action`, `variation
+/// perform`), and `redefines` for a usage redefining without a kind
+/// (`ref redefines engine`).
+const USAGE_KINDS: &[&str] = &[
+    "action",
+    "allocation",
+    "analysis",
+    "assert",
+    "attribute",
+    "binding",
+    "calc",
+    "case",
+    "concern",
+    "connection",
+    "constraint",
+    "enum",
+    "event",
+    "exhibit",
+    "flow",
+    "include",
+    "interface",
+    "item",
+    "message",
+    "occurrence",
+    "part",
+    "perform",
+    "port",
+    "redefines",
+    "rendering",
+    "requirement",
+    "satisfy",
+    "state",
+    "succession",
+    "use",
+    "verification",
+    "view",
+    "viewpoint",
+];
+
+/// SysML: every keyword after which the next word is a name being
+/// declared. Sorted by keyword.
+const SYSML: &[Declarer] = &[
+    declarer(
+        "abstract",
+        &[
+            &[
+                "constant",
+                "individual",
+                "metadata",
+                "ref",
+                "snapshot",
+                "timeslice",
+            ],
+            USAGE_KINDS,
+        ],
+    ),
+    declarer("action", DEF),
+    declarer("actor", NOTHING),
+    declarer("alias", NOTHING),
+    declarer("allocation", &[&["allocate", "def", "redefines"]]),
+    declarer("analysis", DEF),
+    declarer("attribute", DEF),
+    declarer("binding", &[&["bind"]]),
+    declarer("calc", DEF),
+    declarer("case", DEF),
+    declarer("comment", &[&["about", "locale"]]),
+    declarer("concern", DEF),
+    declarer("connection", &[&["connect", "def", "redefines"]]),
+    declarer(
+        "constant",
+        &[&["individual", "ref", "snapshot", "timeslice"], USAGE_KINDS],
+    ),
+    declarer("constraint", DEF),
+    declarer("decide", NOTHING),
+    declarer("def", NOTHING),
+    declarer(
+        "derived",
+        &[
+            &[
+                "abstract",
+                "constant",
+                "individual",
+                "ref",
+                "snapshot",
+                "timeslice",
+                "variation",
+            ],
+            USAGE_KINDS,
+        ],
+    ),
+    declarer("doc", &[&["locale"]]),
+    declarer(
+        "end",
+        &[
+            &[
+                "abstract",
+                "constant",
+                "derived",
+                "in",
+                "inout",
+                "out",
+                "ref",
+                "variation",
+            ],
+            USAGE_KINDS,
+        ],
+    ),
+    declarer("enum", DEF),
+    declarer("for", NOTHING),
+    declarer("fork", NOTHING),
+    declarer("in", DIRECTED),
+    declarer(
+        "individual",
+        &[&["def", "snapshot", "timeslice"], USAGE_KINDS],
+    ),
+    declarer("inout", DIRECTED),
+    declarer("item", DEF),
+    declarer("join", NOTHING),
+    declarer("merge", NOTHING),
+    declarer("objective", NOTHING),
+    declarer("occurrence", DEF),
+    declarer("out", DIRECTED),
+    declarer("package", NOTHING),
+    declarer("part", DEF),
+    declarer("port", DEF),
+    declarer(
+        "ref",
+        &[&["individual", "snapshot", "timeslice"], USAGE_KINDS],
+    ),
+    declarer("rendering", DEF),
+    declarer("rep", &[&["language"]]),
+    declarer("requirement", DEF),
+    declarer(
+        "return",
+        &[
+            &[
+                "abstract",
+                "constant",
+                "derived",
+                "end",
+                "in",
+                "individual",
+                "inout",
+                "out",
+                "ref",
+                "snapshot",
+                "timeslice",
+                "variation",
+            ],
+            USAGE_KINDS,
+        ],
+    ),
+    declarer("snapshot", &[USAGE_KINDS]),
+    declarer("stakeholder", NOTHING),
+    declarer("state", &[&["def", "parallel", "redefines"]]),
+    declarer("subject", NOTHING),
+    declarer("succession", &[&["first", "flow"]]),
+    declarer("timeslice", &[USAGE_KINDS]),
+    declarer(
+        "variation",
+        &[
+            &["constant", "individual", "ref", "snapshot", "timeslice"],
+            USAGE_KINDS,
+        ],
+    ),
+    declarer("verification", DEF),
+    declarer("view", DEF),
+    declarer("viewpoint", DEF),
+];
+
+/// What may follow a SysML direction (`in`, `out`, `inout`): the rest
+/// of the usage prefix, or the usage's kind.
+const DIRECTED: &[&[&str]] = &[
+    &[
+        "abstract",
+        "constant",
+        "derived",
+        "individual",
+        "ref",
+        "snapshot",
+        "timeslice",
+        "variation",
+    ],
+    USAGE_KINDS,
+];
+
+/// The words that may prefix a SysML definition besides its prefix
+/// metadata: its visibility, `abstract` or `variation`, `individual`,
+/// and `use` (of `use case`).
+const DEFINITION_PREFIXES: &[&str] = &[
+    "abstract",
+    "individual",
+    "private",
+    "protected",
+    "public",
+    "use",
+    "variation",
+];
+
+/// The keywords that may start a member of an enumeration body other
+/// than a bare literal.
+const ENUMERATION_MEMBERS: &[&str] = &[
+    "comment",
+    "doc",
+    "enum",
+    "language",
+    "locale",
+    "metadata",
+    "private",
+    "protected",
+    "public",
+    "rep",
+];
+
+/// The KerML keywords naming a feature's kind, which may follow its
+/// prefix keywords, and `redefines` for a feature redefining without a
+/// kind (`in redefines x`).
+const FEATURE_KINDS: &[&str] = &[
+    "binding",
+    "bool",
+    "connector",
+    "expr",
+    "feature",
+    "flow",
+    "inv",
+    "redefines",
+    "step",
+    "succession",
+];
+
+/// The KerML keywords naming a type's kind.
+const TYPE_KINDS: &[&str] = &[
+    "assoc",
+    "behavior",
+    "class",
+    "classifier",
+    "datatype",
+    "function",
+    "interaction",
+    "metaclass",
+    "predicate",
+    "struct",
+    "type",
+];
+
+/// What may follow a KerML direction: the rest of the feature prefix,
+/// or the feature's kind.
+const DIRECTED_FEATURE: &[&[&str]] = &[
+    &[
+        "abstract",
+        "composite",
+        "const",
+        "derived",
+        "portion",
+        "var",
+    ],
+    FEATURE_KINDS,
+];
+
+/// What may follow KerML `member` and `return`: a feature's whole
+/// prefix, or its kind.
+const FEATURE_PREFIXED: &[&[&str]] = &[
+    &[
+        "abstract",
+        "composite",
+        "const",
+        "derived",
+        "end",
+        "in",
+        "inout",
+        "out",
+        "portion",
+        "var",
+    ],
+    FEATURE_KINDS,
+];
+
+/// `all` (a sufficient type) may stand where a KerML type's name would.
+const ALL: &[&[&str]] = &[&["all"]];
+
+/// `all` may stand where a KerML feature's name would, and a feature
+/// with no name of its own often redefines one (`feature redefines x`).
+const FEATURE_HEAD: &[&[&str]] = &[&["all", "redefines"]];
+
+/// KerML: every keyword after which the next word is a name being
+/// declared. Sorted by keyword.
+const KERML: &[Declarer] = &[
+    declarer(
+        "abstract",
+        &[
+            &["composite", "const", "portion", "var"],
+            FEATURE_KINDS,
+            TYPE_KINDS,
+        ],
+    ),
+    declarer("alias", NOTHING),
+    declarer("assoc", &[&["all", "struct"]]),
+    declarer("behavior", ALL),
+    declarer("bool", FEATURE_HEAD),
+    declarer("class", ALL),
+    declarer("classifier", ALL),
+    declarer("comment", &[&["about", "locale"]]),
+    declarer("composite", &[&["const", "var"], FEATURE_KINDS]),
+    declarer("conjugation", &[&["conjugate"]]),
+    declarer("const", &[&["end"], FEATURE_KINDS]),
+    declarer("datatype", ALL),
+    declarer(
+        "derived",
+        &[
+            &["abstract", "composite", "const", "portion", "var"],
+            FEATURE_KINDS,
+        ],
+    ),
+    declarer("disjoining", &[&["disjoint"]]),
+    declarer("doc", &[&["locale"]]),
+    declarer(
+        "end",
+        &[
+            &[
+                "abstract",
+                "composite",
+                "const",
+                "derived",
+                "in",
+                "inout",
+                "out",
+                "portion",
+                "var",
+            ],
+            FEATURE_KINDS,
+        ],
+    ),
+    declarer("expr", FEATURE_HEAD),
+    declarer("feature", FEATURE_HEAD),
+    declarer("function", ALL),
+    declarer("in", DIRECTED_FEATURE),
+    declarer("inout", DIRECTED_FEATURE),
+    declarer("interaction", ALL),
+    declarer("inv", &[&["false", "true"]]),
+    declarer("inverting", &[&["inverse"]]),
+    declarer("member", FEATURE_PREFIXED),
+    declarer("metaclass", ALL),
+    declarer("multiplicity", NOTHING),
+    declarer("namespace", NOTHING),
+    declarer("out", DIRECTED_FEATURE),
+    declarer("package", NOTHING),
+    declarer("portion", &[&["const", "var"], FEATURE_KINDS]),
+    declarer("predicate", ALL),
+    declarer("rep", &[&["language"]]),
+    declarer("return", FEATURE_PREFIXED),
+    declarer(
+        "specialization",
+        &[&[
+            "redefinition",
+            "subclassifier",
+            "subset",
+            "subtype",
+            "typing",
+        ]],
+    ),
+    declarer("step", FEATURE_HEAD),
+    declarer("struct", ALL),
+    declarer("type", ALL),
+    declarer("var", &[FEATURE_KINDS]),
+];
+
+fn table(dialect: Dialect) -> &'static [Declarer] {
+    match dialect {
+        Dialect::Sysml => SYSML,
+        Dialect::Kerml => KERML,
+    }
+}
+
+/// The keywords that may stand where the word being completed is, when
+/// that word is a name the statement declares; `None` when it is not.
+fn declared(src: &str, head: &[Token], body: Body, dialect: Dialect) -> Option<Vec<&'static str>> {
+    let keyword = |t: &Token| {
+        (t.kind == TokenKind::Ident && is_reserved(dialect, t.text(src))).then(|| t.text(src))
+    };
+    // A bare member of an enumeration body declares a literal.
+    let literal = |ahead: &[Token]| {
+        dialect == Dialect::Sysml
+            && body == Body::Enumeration
+            && ahead.iter().all(|t| keyword(t).is_some_and(is_visibility))
+    };
+    // The declarer the keyword at `head[at]` is, read in its statement.
+    let declarer_at = |at: usize| -> Option<&'static Declarer> {
+        let word = keyword(&head[at])?;
+        let d = table(dialect)
+            .binary_search_by(|d| d.keyword.cmp(word))
+            .ok()
+            .map(|i| &table(dialect)[i])?;
+        let ahead = || head[..at].iter().filter_map(keyword);
+        let applies = match (dialect, word) {
+            // `alias A for B`: the aliased element.
+            (Dialect::Sysml, "for") => !ahead().any(|w| w == "alias"),
+            // `for i in items`: the collection iterated.
+            (Dialect::Sysml, "in") => !ahead().any(|w| w == "for"),
+            // A metadata body's members redefine features they name.
+            (Dialect::Sysml, "ref") | (Dialect::Kerml, "feature") => body != Body::Metadata,
+            _ => true,
+        };
+        applies.then_some(d)
+    };
+    if literal(head) {
+        let visible = !head.is_empty();
+        return Some(
+            ENUMERATION_MEMBERS
+                .iter()
+                .copied()
+                .filter(|w| !(visible && is_visibility(w)))
+                .collect(),
+        );
+    }
+    let (last, ahead) = head.split_last()?;
+    match last.kind {
+        TokenKind::Ident => {
+            // A KerML type's or feature's sufficiency (`class all C`)
+            // and an invariant's polarity (`inv true c`) come between
+            // its keyword and its name: the name still follows.
+            let n = head.len();
+            let at = match keyword(last) {
+                Some(w @ ("all" | "true" | "false"))
+                    if n >= 2
+                        && declarer_at(n - 2)
+                            .is_some_and(|d| d.instead.iter().any(|g| g.contains(&w))) =>
+                {
+                    n - 2
+                }
+                _ => n - 1,
+            };
+            let d = declarer_at(at)?;
+            let definable = body != Body::Enumeration && definition_prefix(src, &head[..at]);
+            let skipped = at < n - 1;
+            let mut words: Vec<&'static str> = Vec::new();
+            for &w in d.instead.iter().flat_map(|group| group.iter()) {
+                let spent = skipped && matches!(w, "all" | "true" | "false");
+                if (w != "def" || definable) && !spent && !words.contains(&w) {
+                    words.push(w);
+                }
+            }
+            Some(words)
+        }
+        // A short name: `part def <V`.
+        TokenKind::Lt => {
+            let declares = match ahead.len() {
+                0 => false,
+                n => declarer_at(n - 1).is_some(),
+            };
+            (declares || literal(ahead)).then(Vec::new)
+        }
+        // The name after a short name: `part def <V> Vehicle`.
+        TokenKind::Gt => {
+            let n = head.len();
+            let shaped = n >= 3
+                && matches!(
+                    head[n - 2].kind,
+                    TokenKind::Ident | TokenKind::UnrestrictedName
+                )
+                && head[n - 3].kind == TokenKind::Lt;
+            if !shaped {
+                return None;
+            }
+            let declares = n >= 4 && declarer_at(n - 4).is_some();
+            (declares || literal(&head[..n - 3])).then(Vec::new)
+        }
+        _ => None,
+    }
+}
+
+/// What completion offers at a position the statement tells apart.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct Want {
+    /// The keywords offered, each with its sort key (see [`sort_text`]).
+    pub keywords: Vec<(&'static str, u8)>,
+    /// Which names are offered, and how they rank; `None` offers none.
+    pub names: Option<Names>,
+}
+
+/// Which of its enclosing element's features a position names — the
+/// names in scope there that the symbol tables do not hold: members
+/// inherited from a specialization or typing, or from the library base
+/// every element of its kind implicitly specializes (`Actions::Action`'s
+/// `start` and `done` in an action).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Members {
+    /// None beyond the symbol tables.
+    None,
+    /// The features it inherits: what a redefinition names.
+    Inherited,
+    /// Its own features and those it inherits: what a succession or a
+    /// subsetting names.
+    Scope,
+}
+
+/// Which names a position takes, and in which groups: a lower group
+/// ranks first. A name's sort key is its group's tens plus its source
+/// — `0` a workspace name, `1` one that needs an import, `2` a library
+/// name, `3` one that needs an import — plus `4` for a name of a kind
+/// specializing the one a feature position's statement declares (see
+/// [`Want::tier`]). A name whose declaration's kind is unknown (see
+/// [`Decl::Other`]: an alias whose target another unit declares may
+/// name anything) ranks with the namespaces wherever names are taken.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum Names {
+    /// Every name: a position the statement does not tell apart, or one
+    /// that takes any element (`expose`, `about`, `alias … for`).
+    All,
+    /// Types: definitions of the `exact` kinds, then of the
+    /// `compatible` ones and of user-defined kinds (`#Service def`),
+    /// which may be of any kind, then namespaces, which qualify a
+    /// type's name.
+    Types {
+        exact: Vec<DefKind>,
+        compatible: Vec<DefKind>,
+        /// Usages too, ranked with the namespaces: a KerML type
+        /// operator's operand (`classifier C unions …`) may be a feature,
+        /// which is a type as well.
+        features: bool,
+    },
+    /// Features: usages of the `preferred` kinds (of any kind when
+    /// empty), those of the statement's own kind ahead of the `specific`
+    /// ones, then other usages, then definitions of the `definitions`
+    /// kinds, then namespaces and the workspace's other definitions,
+    /// which qualify the features they own (`redefines Vehicle::mass`).
+    /// A `strict` position takes no usage whose kind keyword names
+    /// another kind (`satisfy` takes no attribute), and ranks the
+    /// definitions ahead of the usages declared without one.
+    Features {
+        preferred: Vec<UsageKind>,
+        definitions: Vec<DefKind>,
+        strict: bool,
+        /// Which features of the element the statement is a member of
+        /// the position names too, ahead of every other name.
+        members: Members,
+        /// Of `preferred`, the kinds specializing the kind the statement
+        /// declares (parts at an item's redefinition): their names rank
+        /// after those of its own kind (see [`Want::tier`]).
+        specific: Vec<UsageKind>,
+    },
+    /// Expression operands: features and the definitions an expression
+    /// invokes, then enumerations and namespaces, which qualify a
+    /// literal's or a feature's name, then the workspace's other
+    /// definitions, which qualify the features they own
+    /// (`WheelAssy::wheel`); measurement units last, or first where the
+    /// statement's type is a unit type (see [`Want::unit_group`]).
+    Operands {
+        /// The type the statement declares, last segment only
+        /// (`attribute b : Boolean = …`).
+        typed: Option<String>,
+    },
+}
+
+impl Names {
+    /// The group of a candidate declared as `decl`, `workspace` when the
+    /// workspace declares it; `None` when the position does not take it.
+    /// Only the workspace's definitions qualify features: the library's
+    /// would double the lists.
+    pub(crate) fn group(&self, decl: Decl, workspace: bool) -> Option<u8> {
+        match self {
+            Names::All => Some(1),
+            Names::Types {
+                exact,
+                compatible,
+                features,
+            } => match decl {
+                Decl::Definition(k) if exact.contains(&k) => Some(1),
+                Decl::Definition(k) if compatible.contains(&k) || k == DefKind::Extended => Some(2),
+                Decl::Namespace | Decl::Other => Some(3),
+                Decl::Usage(_) if *features => Some(3),
+                _ => None,
+            },
+            Names::Features {
+                preferred,
+                definitions,
+                strict,
+                ..
+            } => match decl {
+                Decl::Usage(u) if preferred.is_empty() || preferred.contains(&u) => Some(1),
+                Decl::Definition(k) if definitions.contains(&k) => {
+                    Some(if *strict { 2 } else { 3 })
+                }
+                // Declared without a kind keyword: it may be of any kind.
+                Decl::Usage(UsageKind::Default | UsageKind::Ref | UsageKind::Feature) => {
+                    Some(if *strict { 3 } else { 2 })
+                }
+                Decl::Usage(_) if !strict => Some(2),
+                Decl::Namespace | Decl::Other => Some(4),
+                Decl::Definition(_) if workspace => Some(4),
+                Decl::Usage(_) | Decl::Definition(_) => None,
+            },
+            Names::Operands { .. } => match decl {
+                Decl::Usage(_) => Some(1),
+                Decl::Definition(k) if CALLABLES.contains(&k) => Some(1),
+                Decl::Definition(DefKind::Enum) | Decl::Namespace | Decl::Other => Some(3),
+                Decl::Definition(_) if workspace => Some(4),
+                Decl::Definition(_) => None,
+            },
+        }
+    }
+}
+
+impl Want {
+    /// `self`, naming the enclosing element's `members` too.
+    fn with(mut self, members: Members) -> Want {
+        if let Some(Names::Features { members: m, .. }) = &mut self.names {
+            *m = members;
+        }
+        self
+    }
+
+    /// Which of the enclosing element's features the position names
+    /// ahead of every other name.
+    pub(crate) fn members(&self) -> Members {
+        match &self.names {
+            Some(Names::Features { members, .. }) => *members,
+            _ => Members::None,
+        }
+    }
+
+    /// What a position the statement does not tell apart takes: every
+    /// keyword of `dialect`, ranked with the workspace's names, and
+    /// every name.
+    pub(crate) fn open(dialect: Dialect) -> Want {
+        Want {
+            keywords: crate::tokens::keywords(dialect)
+                .map(|k| (k, WITH_WORKSPACE))
+                .collect(),
+            names: Some(Names::All),
+        }
+    }
+
+    /// The group of a name declared as `decl`, `workspace` when the
+    /// workspace declares it (see [`Names::group`]); `None` when the
+    /// position takes no such name.
+    pub(crate) fn group(&self, decl: Decl, workspace: bool) -> Option<u8> {
+        self.names.as_ref()?.group(decl, workspace)
+    }
+
+    /// The tier within its group of a name declared as `decl`: `1` for
+    /// a usage of a kind specializing the one the statement declares
+    /// (a part at an item's redefinition), whose names rank after those
+    /// of the statement's own kind; `0` otherwise.
+    pub(crate) fn tier(&self, decl: Decl) -> u8 {
+        match (&self.names, decl) {
+            (Some(Names::Features { specific, .. }), Decl::Usage(u)) => {
+                u8::from(specific.contains(&u))
+            }
+            _ => 0,
+        }
+    }
+
+    /// The group a measurement unit takes at an expression operand,
+    /// `unit_types` naming the unit types: first where the statement's
+    /// type is one (`attribute <N> newton : ForceUnit = kg*m/s^2`), after
+    /// every other name otherwise — units write quantities' values and
+    /// other units, rarely anything else. `None` at other positions.
+    pub(crate) fn unit_group(&self, unit_types: &HashSet<String>) -> Option<u8> {
+        match &self.names {
+            Some(Names::Operands { typed }) => {
+                Some(if typed.as_ref().is_some_and(|t| unit_types.contains(t)) {
+                    0
+                } else {
+                    UNITS
+                })
+            }
+            _ => None,
+        }
+    }
+
+    fn new(keywords: &[&'static str], key: u8, names: Option<Names>) -> Want {
+        Want {
+            keywords: keywords.iter().map(|&k| (k, key)).collect(),
+            names,
+        }
+    }
+}
+
+/// Keywords ranked ahead of every name.
+const FIRST: u8 = 0;
+/// Keywords ranked among the best-fitting workspace names, ahead of the
+/// library's.
+const WITH_WORKSPACE: u8 = 10;
+/// Keywords ranked after the best-fitting names.
+const AFTER: u8 = 14;
+/// The group measurement units take after every other operand.
+const UNITS: u8 = 5;
+
+/// The `sortText` of a candidate labeled `label` with sort key `key`:
+/// keys sort as numbers, equal keys by the label's length — the word
+/// typed is more of a short name (`Mas` of `MassValue` than of
+/// `MassAttenuationCoefficientValue`) — and equal lengths by label.
+pub(crate) fn sort_text(key: u8, label: &str) -> String {
+    format!("{key:02}{:03}", label.chars().count().min(999))
+}
+
+/// The sort key of a name in `group` from `source` (see [`Names`]),
+/// of `tier` within its group (see [`Want::tier`]): a more specific
+/// kind's names after those of the statement's own kind from every
+/// source.
+pub(crate) fn name_key(group: u8, source: u8, tier: u8) -> u8 {
+    group * 10 + 4 * tier + source
+}
+
+fn types(exact: &[DefKind], compatible: &[DefKind]) -> Want {
+    Want {
+        keywords: Vec::new(),
+        names: Some(Names::Types {
+            exact: exact.to_vec(),
+            compatible: compatible.to_vec(),
+            features: false,
+        }),
+    }
+}
+
+/// After a KerML type operator (`unions`, `intersects`, `differences`,
+/// `disjoint from`): types, features among them — a feature's operands
+/// are features first, a type's types.
+fn type_operands(src: &str, stmt: &[Token], dialect: Dialect) -> Want {
+    if definition_kind(src, stmt, dialect).is_none() {
+        return features(&[], ALL_DEFINITIONS);
+    }
+    types_then_features()
+}
+
+/// Types, then features, which are types too.
+fn types_then_features() -> Want {
+    Want {
+        keywords: Vec::new(),
+        names: Some(Names::Types {
+            exact: ALL_DEFINITIONS.to_vec(),
+            compatible: Vec::new(),
+            features: true,
+        }),
+    }
+}
+
+/// Features, those of the `preferred` kinds first.
+fn features(preferred: &[UsageKind], definitions: &[DefKind]) -> Want {
+    Want {
+        keywords: Vec::new(),
+        names: Some(Names::Features {
+            preferred: preferred.to_vec(),
+            definitions: definitions.to_vec(),
+            strict: false,
+            members: Members::None,
+            specific: Vec::new(),
+        }),
+    }
+}
+
+/// Features of the `preferred` kinds only (see [`Names::Features`]).
+fn strictly(preferred: &[UsageKind], definitions: &[DefKind]) -> Want {
+    Want {
+        keywords: Vec::new(),
+        names: Some(Names::Features {
+            preferred: preferred.to_vec(),
+            definitions: definitions.to_vec(),
+            strict: true,
+            members: Members::None,
+            specific: Vec::new(),
+        }),
+    }
+}
+
+/// A reference of a kind, or one of `keywords` declaring one in its
+/// place (`perform takePicture`, `perform action a`).
+fn reference(preferred: &[UsageKind], definitions: &[DefKind], keywords: &[&'static str]) -> Want {
+    Want {
+        keywords: keywords.iter().map(|&k| (k, FIRST)).collect(),
+        ..strictly(preferred, definitions)
+    }
+}
+
+fn metadata_types() -> Want {
+    types(&[DefKind::Metadata, DefKind::Metaclass], &[])
+}
+
+/// Literal and prefix keywords that may start an expression.
+const EXPRESSION_START: &[&str] = &["all", "false", "if", "new", "not", "null", "true"];
+
+/// The keywords that may follow an expression's operand.
+const INFIX: &[&str] = &[
+    "and", "as", "else", "hastype", "implies", "istype", "meta", "or", "xor",
+];
+
+/// The usages a succession steps between first: actions, states, and
+/// other occurrences, and KerML's steps, expressions, and invariants.
+const BEHAVIORS: &[UsageKind] = &[
+    UsageKind::Action,
+    UsageKind::Perform,
+    UsageKind::State,
+    UsageKind::Exhibit,
+    UsageKind::Accept,
+    UsageKind::Send,
+    UsageKind::Assign,
+    UsageKind::IfNode,
+    UsageKind::WhileLoop,
+    UsageKind::ForLoop,
+    UsageKind::Terminate,
+    UsageKind::Merge,
+    UsageKind::Decide,
+    UsageKind::Join,
+    UsageKind::Fork,
+    UsageKind::Calc,
+    UsageKind::Case,
+    UsageKind::Analysis,
+    UsageKind::Verification,
+    UsageKind::UseCase,
+    UsageKind::Include,
+    UsageKind::Occurrence,
+    UsageKind::Event,
+    UsageKind::Step,
+    UsageKind::Expr,
+    UsageKind::BoolExpr,
+    UsageKind::Invariant,
+];
+
+/// The usages a `perform` names: actions of every kind.
+const PERFORMED: &[UsageKind] = &[
+    UsageKind::Action,
+    UsageKind::Perform,
+    UsageKind::State,
+    UsageKind::Exhibit,
+    UsageKind::Accept,
+    UsageKind::Send,
+    UsageKind::Assign,
+    UsageKind::IfNode,
+    UsageKind::WhileLoop,
+    UsageKind::ForLoop,
+    UsageKind::Terminate,
+    UsageKind::Merge,
+    UsageKind::Decide,
+    UsageKind::Join,
+    UsageKind::Fork,
+    UsageKind::Calc,
+    UsageKind::Case,
+    UsageKind::Analysis,
+    UsageKind::Verification,
+    UsageKind::UseCase,
+    UsageKind::Include,
+];
+
+/// The action usages a state's entry, do, and exit actions perform.
+const ACTIONS: &[UsageKind] = &[
+    UsageKind::Action,
+    UsageKind::Perform,
+    UsageKind::Accept,
+    UsageKind::Send,
+    UsageKind::Assign,
+    UsageKind::Calc,
+];
+
+/// The keywords that declare the successor after `then` in an action
+/// body instead of naming it.
+const SUCCESSORS: &[&str] = &[
+    "accept",
+    "action",
+    "assign",
+    "decide",
+    "for",
+    "fork",
+    "if",
+    "join",
+    "loop",
+    "merge",
+    "send",
+    "state",
+    "terminate",
+    "while",
+];
+
+/// The position the word being completed fills, as far as the
+/// statement's tokens tell; `None` when they do not.
+fn position(src: &str, head: &[Token], body: Body, dialect: Dialect) -> Option<Want> {
+    let start = past_prefixes(src, head);
+    let stmt = &head[start..];
+    let Some((&last, ahead)) = stmt.split_last() else {
+        return statement_start(body, dialect, start > 0);
+    };
+    let word = |t: &Token| (t.kind == TokenKind::Ident).then(|| t.text(src));
+    let keyword = |t: &Token| word(t).filter(|w| is_reserved(dialect, w));
+    let before = ahead.last();
+    let has = |w: &str| stmt.iter().any(|t| keyword(t) == Some(w));
+    match last.kind {
+        TokenKind::Hash => Some(metadata_types()),
+        TokenKind::At if ahead.is_empty() => Some(metadata_types()),
+        TokenKind::At | TokenKind::AtAt => Some(types(ALL_DEFINITIONS, &[])),
+        TokenKind::Colon => Some(typing(src, stmt, dialect)),
+        TokenKind::Tilde
+            if before.is_some_and(|b| b.kind == TokenKind::Colon || word(b) == Some("by")) =>
+        {
+            Some(typing(src, stmt, dialect))
+        }
+        TokenKind::ColonGt => Some(specializing(src, stmt, dialect)),
+        TokenKind::ColonGtGt => Some(of_kind(src, stmt, dialect, Members::Inherited)),
+        TokenKind::ColonColonGt | TokenKind::FatArrow => {
+            Some(of_kind(src, stmt, dialect, Members::None))
+        }
+        TokenKind::Eq if has("bind") => Some(features(&[], &[])),
+        TokenKind::Eq | TokenKind::ColonEq => Some(expression(src, stmt)),
+        TokenKind::Comma => continuing(src, ahead, dialect),
+        TokenKind::LParen => Some(opened(src, ahead, dialect)),
+        TokenKind::Arrow => Some(types(CALLABLES, &[])),
+        TokenKind::Plus
+        | TokenKind::Minus
+        | TokenKind::Star
+        | TokenKind::StarStar
+        | TokenKind::Slash
+        | TokenKind::Percent
+        | TokenKind::Caret
+        | TokenKind::EqEq
+        | TokenKind::EqEqEq
+        | TokenKind::BangEq
+        | TokenKind::BangEqEq
+        | TokenKind::Lt
+        | TokenKind::Gt
+        | TokenKind::LtEq
+        | TokenKind::GtEq
+        | TokenKind::Pipe
+        | TokenKind::Amp
+        | TokenKind::Question
+        | TokenKind::QuestionQuestion
+        | TokenKind::DotDot => Some(expression(src, stmt)),
+        TokenKind::Ident => match keyword(&last) {
+            Some(w) => after_keyword(src, stmt, w, dialect),
+            // The function an arrow invokes (`->reduce`): a function
+            // reference may follow it (`->reduce max`).
+            None if before.is_some_and(|b| b.kind == TokenKind::Arrow) => {
+                Some(types(CALLABLES, &[]))
+            }
+            None => after_operand(src, stmt, body, dialect),
+        },
+        // A connector end's multiplicity: the end's feature follows.
+        TokenKind::RBracket if ends_multiplicity(src, stmt, dialect) => Some(features(&[], &[])),
+        TokenKind::Decimal
+        | TokenKind::Exp
+        | TokenKind::String
+        | TokenKind::UnrestrictedName
+        | TokenKind::RParen
+        | TokenKind::RBracket => after_operand(src, stmt, body, dialect),
+        _ => None,
+    }
+}
+
+/// Does the `]` ending `stmt` close a connector end's multiplicity
+/// (`bind [1] a = [1] b`, `connect [1] a to [1] b`): a `[` opening
+/// where an end starts, after `=`, `to`, `from`, `bind`, `,`, or `(`?
+/// A quantity's unit bracket follows its value instead.
+fn ends_multiplicity(src: &str, stmt: &[Token], dialect: Dialect) -> bool {
+    let mut depth = 0usize;
+    for (i, t) in stmt.iter().enumerate().rev() {
+        match t.kind {
+            TokenKind::RBracket => depth += 1,
+            TokenKind::LBracket => {
+                depth = depth.saturating_sub(1);
+                if depth == 0 {
+                    return i.checked_sub(1).is_some_and(|j| {
+                        let b = stmt[j];
+                        matches!(b.kind, TokenKind::Eq | TokenKind::Comma | TokenKind::LParen)
+                            || (b.kind == TokenKind::Ident
+                                && is_reserved(dialect, b.text(src))
+                                && matches!(b.text(src), "bind" | "from" | "to"))
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
+    false
+}
+
+/// What may follow the keyword `word` that ends `stmt`.
+fn after_keyword(src: &str, stmt: &[Token], word: &str, dialect: Dialect) -> Option<Want> {
+    use DefKind as D;
+    use UsageKind as U;
+    let words: Vec<&str> = stmt
+        .iter()
+        .filter(|t| t.kind == TokenKind::Ident)
+        .map(|t| t.text(src))
+        .filter(|w| is_reserved(dialect, w))
+        .collect();
+    let before = stmt
+        .len()
+        .checked_sub(2)
+        .map(|i| stmt[i])
+        .filter(|t| t.kind == TokenKind::Ident)
+        .map(|t| t.text(src));
+    let requirements = &[U::Requirement, U::Satisfy, U::Concern, U::Viewpoint];
+    // Requirements are constraints too.
+    let constraints = &[
+        U::Constraint,
+        U::AssertConstraint,
+        U::Requirement,
+        U::Satisfy,
+        U::Concern,
+        U::Viewpoint,
+    ];
+    Some(match word {
+        "perform" => reference(PERFORMED, &[], &["action"]),
+        "exhibit" => reference(&[U::State, U::Exhibit], &[], &["state"]),
+        "include" => reference(&[U::UseCase, U::Include], &[], &["use"]),
+        "satisfy" | "verify" => reference(
+            requirements,
+            &[D::Requirement, D::Concern, D::Viewpoint],
+            &["requirement"],
+        ),
+        "frame" => reference(&[U::Concern], &[D::Concern], &["concern"]),
+        "assert" => reference(
+            constraints,
+            &[D::Constraint],
+            &["constraint", "not", "satisfy"],
+        ),
+        "not" if before == Some("assert") => {
+            reference(constraints, &[D::Constraint], &["constraint", "satisfy"])
+        }
+        "require" | "assume" => reference(constraints, &[D::Constraint], &["constraint"]),
+        "render" => reference(&[U::Rendering], &[], &["rendering"]),
+        "event" => Want {
+            keywords: vec![("occurrence", FIRST)],
+            ..features(&[U::Occurrence, U::Event], &[])
+        },
+        "entry" | "do" | "exit" => reference(ACTIONS, &[], &["accept", "action", "assign", "send"]),
+        // A successor is named more often than declared. A succession
+        // steps between occurrences of any kind — parts, messages, and
+        // KerML steps as well as actions and states: behaviors first.
+        "then" => Want {
+            keywords: SUCCESSORS.iter().map(|&k| (k, AFTER)).collect(),
+            ..features(BEHAVIORS, &[]).with(Members::Scope)
+        },
+        "first" => features(BEHAVIORS, &[]).with(Members::Scope),
+        // A transition's source: a state, or the entry action a state
+        // machine starts from (`transition initial then off`).
+        "transition" => Want {
+            keywords: vec![("first", AFTER)],
+            ..features(&[U::State, U::Exhibit, U::Perform, U::Action], &[])
+        },
+        // A payload: a type, or the name of a new parameter.
+        "accept" => Want {
+            keywords: ["after", "at", "when"].map(|k| (k, AFTER)).to_vec(),
+            ..types(ALL_DEFINITIONS, &[])
+        },
+        "redefines" => of_kind(src, stmt, dialect, Members::Inherited),
+        "subsets" => of_kind(src, stmt, dialect, Members::Scope),
+        "references" | "crosses" => of_kind(src, stmt, dialect, Members::None),
+        // `ref` and KerML `feature` reach here only in a metadata body,
+        // where they name the feature redefined.
+        "feature" | "ref" => features(&[], &[]).with(Members::Inherited),
+        "allocate" | "assign" | "bind" | "chains" | "connect" | "featuring" | "inverse"
+        | "redefinition" | "subset" | "typing" | "variant" => features(&[], &[]),
+        "to" if words.contains(&"dependency") => Want::new(&[], FIRST, Some(Names::All)),
+        "to" if words.contains(&"send") => expression(src, stmt),
+        "from" if before == Some("disjoint") => type_operands(src, stmt, dialect),
+        "from" if words.contains(&"dependency") => Want::new(&[], FIRST, Some(Names::All)),
+        "to" | "from" => features(&[], &[]),
+        "by" => match before {
+            Some("defined" | "typed") => typing(src, stmt, dialect),
+            Some("featured") => types(ALL_DEFINITIONS, &[]),
+            _ => features(&[], &[]),
+        },
+        "specializes" => specializing(src, stmt, dialect),
+        "differences" | "intersects" | "unions" => type_operands(src, stmt, dialect),
+        // A type, usually, but a feature may stand there too (`all
+        // engineChoice`, `new testVehicle(…)`, `vehicles as vehicle`).
+        "all" | "as" | "new" => types_then_features(),
+        "conjugate" | "conjugates" | "disjoint" | "hastype" | "istype" | "meta"
+        | "subclassifier" | "subtype" => types(ALL_DEFINITIONS, &[]),
+        // An inverse's feature; a KerML binding's first end.
+        "of" if before == Some("inverse") || words.contains(&"binding") => features(&[], &[]),
+        "of" => types(ALL_DEFINITIONS, &[]),
+        "about" | "expose" | "for" => Want::new(&[], FIRST, Some(Names::All)),
+        "dependency" => Want::new(&["from"], AFTER, Some(Names::All)),
+        "after" | "and" | "at" | "default" | "else" | "filter" | "if" | "implies" | "in"
+        | "not" | "or" | "send" | "terminate" | "until" | "via" | "when" | "while" | "xor" => {
+            expression(src, stmt)
+        }
+        "defined" | "featured" | "typed" => Want::new(&["by"], FIRST, None),
+        "use" => Want::new(&["case"], FIRST, None),
+        "standard" => Want::new(&["library"], FIRST, None),
+        "library" => Want::new(&["package"], FIRST, None),
+        // A string follows.
+        "language" | "locale" => Want::new(&[], FIRST, None),
+        "metadata" => Want {
+            keywords: vec![("def", FIRST)],
+            ..metadata_types()
+        },
+        // A new name or a connector's end, which names a feature.
+        "flow" | "message" => ending(&["def", "from", "of"]),
+        "interface" => ending(&["connect", "def"]),
+        "connector" => ending(&["all", "from"]),
+        "binding" => ending(&["all", "of"]),
+        "succession" => ending(&["all", "first"]),
+        _ => return None,
+    })
+}
+
+/// Features, or one of `keywords` continuing the declaration instead.
+fn ending(keywords: &[&'static str]) -> Want {
+    Want {
+        keywords: keywords.iter().map(|&k| (k, AFTER)).collect(),
+        ..features(&[], &[])
+    }
+}
+
+/// After an operand: in an expression, only an operator may follow, so
+/// only the keyword operators are offered.
+fn after_operand(src: &str, stmt: &[Token], body: Body, dialect: Dialect) -> Option<Want> {
+    let keyword = |t: &Token| {
+        (t.kind == TokenKind::Ident)
+            .then(|| t.text(src))
+            .filter(|w| is_reserved(dialect, w))
+    };
+    let opened = stmt.iter().any(|t| {
+        matches!(
+            t.kind,
+            TokenKind::Eq | TokenKind::ColonEq | TokenKind::Question
+        ) || keyword(t).is_some_and(|w| {
+            matches!(
+                w,
+                "after"
+                    | "and"
+                    | "at"
+                    | "default"
+                    | "filter"
+                    | "if"
+                    | "implies"
+                    | "not"
+                    | "or"
+                    | "send"
+                    | "terminate"
+                    | "until"
+                    | "via"
+                    | "when"
+                    | "while"
+                    | "xor"
+            )
+        })
+    });
+    // A result expression: the body's statement does not start with a
+    // declaration keyword.
+    let result = body.results()
+        && stmt
+            .first()
+            .is_some_and(|t| keyword(t).is_none_or(|w| EXPRESSION_START.contains(&w)));
+    // Where the grammar goes on with `then`: after an action's `if`
+    // condition (`if level > 0 then …`), after an accept's payload or
+    // trigger — an action's (`accept Sig then …`, `accept after 5 [s]
+    // then …`) or a transition's (`accept after 5 [s] then on`) — after a
+    // transition's guard (`if x > 0 then on`) — a state body's transition
+    // starts at either — and after a succession's guard (`first a1 if x >
+    // 0 then a2`).
+    let has = |w: &str| stmt.iter().any(|t| keyword(t) == Some(w));
+    let first = stmt.first().and_then(keyword);
+    let transition =
+        has("transition") || (body == Body::State && matches!(first, Some("accept" | "if")));
+    let then = !has("then")
+        && ((body == Body::Action && matches!(first, Some("if" | "accept")))
+            || (transition && (has("accept") || has("if")))
+            || (first == Some("first") && has("if")));
+    // After a payload's type no operator follows: the grammar goes on
+    // with `then` (`accept Sig then …`), the port the payload arrives
+    // through (`accept Sig via port`), and a transition's guard and
+    // effect (`accept Sig if ready do …`).
+    if !(opened || result) {
+        if !then {
+            return None;
+        }
+        let mut keywords = vec!["then"];
+        let effect = has("if") || has("do");
+        if has("accept") && !has("via") && !effect {
+            keywords.push("via");
+        }
+        if transition && !effect {
+            keywords.push("if");
+        }
+        if transition && !has("do") {
+            keywords.push("do");
+        }
+        return Some(Want::new(&keywords, FIRST, None));
+    }
+    let mut want = Want::new(INFIX, FIRST, None);
+    if then {
+        want.keywords.push(("then", FIRST));
+    }
+    Some(want)
+}
+
+/// An expression operand; literal booleans first where the statement
+/// declares a `Boolean`.
+fn expression(src: &str, stmt: &[Token]) -> Want {
+    let typed = declared_type(src, stmt);
+    let boolean = typed.as_deref() == Some("Boolean");
+    Want {
+        keywords: EXPRESSION_START
+            .iter()
+            .map(|&k| {
+                let first = boolean && matches!(k, "true" | "false");
+                (k, if first { FIRST } else { WITH_WORKSPACE })
+            })
+            .collect(),
+        names: Some(Names::Operands { typed }),
+    }
+}
+
+/// The type the statement declares what it declares by, last segment
+/// only: `Boolean` for `: Boolean` and `: ScalarValues::Boolean`.
+fn declared_type(src: &str, stmt: &[Token]) -> Option<String> {
+    let at = stmt.iter().position(|t| t.kind == TokenKind::Colon)?;
+    let mut name = None;
+    for t in &stmt[at + 1..] {
+        match t.kind {
+            TokenKind::Ident | TokenKind::UnrestrictedName if name.is_none() => {
+                name = Some(sysmlv2_parser::lexer::unescape(t.text(src)));
+            }
+            TokenKind::ColonColon if name.is_some() => name = None,
+            _ => break,
+        }
+    }
+    name
+}
+
+/// A typing: the definitions the statement's usage may be typed by.
+fn typing(src: &str, stmt: &[Token], dialect: Dialect) -> Want {
+    let metadata = stmt.first().is_some_and(|t| {
+        t.kind == TokenKind::At || (t.kind == TokenKind::Ident && t.text(src) == "metadata")
+    });
+    if metadata {
+        return metadata_types();
+    }
+    let kind = usage_kind(src, stmt, dialect).unwrap_or(UsageKind::Default);
+    let (exact, compatible) = crate::kinds::typed_by(kind);
+    types(exact, compatible)
+}
+
+/// After `:>` or `specializes`: a definition's supertypes, a usage's
+/// subsetted features.
+fn specializing(src: &str, stmt: &[Token], dialect: Dialect) -> Want {
+    match definition_kind(src, stmt, dialect) {
+        Some(kind) => {
+            let (exact, compatible) = crate::kinds::specializes(kind);
+            types(&exact, &compatible)
+        }
+        None => of_kind(src, stmt, dialect, Members::Scope),
+    }
+}
+
+/// Inside `(`: a connector's ends (`connect (a, b)`) or an expression.
+fn opened(src: &str, ahead: &[Token], dialect: Dialect) -> Want {
+    let connector = ahead.last().is_some_and(|t| {
+        t.kind == TokenKind::Ident
+            && is_reserved(dialect, t.text(src))
+            && matches!(t.text(src), "allocate" | "connect" | "interface")
+    });
+    if connector {
+        features(&[], &[])
+    } else {
+        expression(src, ahead)
+    }
+}
+
+/// After a `,`: the list it continues decides — a typing, a
+/// specialization, subsetted or redefined features, arguments, ends.
+fn continuing(src: &str, ahead: &[Token], dialect: Dialect) -> Option<Want> {
+    let mut depth = 0usize;
+    for (i, t) in ahead.iter().enumerate().rev() {
+        let upto = &ahead[..=i];
+        match t.kind {
+            TokenKind::RParen | TokenKind::RBracket => depth += 1,
+            TokenKind::LParen | TokenKind::LBracket if depth > 0 => depth -= 1,
+            TokenKind::LParen => return Some(opened(src, &ahead[..i], dialect)),
+            TokenKind::LBracket => return None,
+            _ if depth > 0 => {}
+            TokenKind::Colon => return Some(typing(src, upto, dialect)),
+            TokenKind::ColonGt => return Some(specializing(src, upto, dialect)),
+            TokenKind::ColonGtGt => {
+                return Some(of_kind(src, upto, dialect, Members::Inherited));
+            }
+            TokenKind::ColonColonGt | TokenKind::FatArrow => {
+                return Some(of_kind(src, upto, dialect, Members::None));
+            }
+            TokenKind::Eq | TokenKind::ColonEq => return Some(expression(src, upto)),
+            TokenKind::Ident if is_reserved(dialect, t.text(src)) => {
+                if matches!(
+                    t.text(src),
+                    "about"
+                        | "by"
+                        | "crosses"
+                        | "differences"
+                        | "disjoint"
+                        | "from"
+                        | "intersects"
+                        | "redefines"
+                        | "references"
+                        | "specializes"
+                        | "subsets"
+                        | "to"
+                        | "unions"
+                ) {
+                    return after_keyword(src, upto, t.text(src), dialect);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// A feature position of `stmt` (`:>>`, `subsets`, `references`, …)
+/// naming the enclosing element's `members`: features of the kind of the
+/// usage it declares (see [`usage_kind`]) first, then of the kinds
+/// specializing it, whose usages are of that kind too — an item
+/// redefines the parts it inherits (see [`crate::kinds::usages_of`]) —
+/// or of every kind where its keywords name none: a `ref`, a `subject`,
+/// and a KerML `feature` may be features of any. A redefinition ranks a
+/// compound keyword's kind first among those its kind word takes (see
+/// [`declared_kinds`]): a `perform action` redefines the performed
+/// actions first, then the others. A subsetting or a reference ranks
+/// the kind word's own first, more general than what it declares
+/// (`include use case board_a :> board` subsets a plain use case). An
+/// individual, a snapshot, or a time slice naming no kind of its own is
+/// one of whatever occurrence it names, every kind of occurrence alike
+/// (`snapshot crewAtIngress :> crew`).
+fn of_kind(src: &str, stmt: &[Token], dialect: Dialect, members: Members) -> Want {
+    let occurrence = stmt
+        .iter()
+        .any(|t| t.kind == TokenKind::Ident && t.text(src) == "occurrence");
+    let all = |kind: UsageKind| {
+        let (own, under) = crate::kinds::usages_of(kind);
+        [own, under].concat()
+    };
+    let (own, specific) = match declared_kinds(src, stmt, dialect) {
+        None | Some((UsageKind::Ref | UsageKind::Feature, _)) => (Vec::new(), Vec::new()),
+        Some((UsageKind::Occurrence, _)) if !occurrence => (all(UsageKind::Occurrence), Vec::new()),
+        // The kinds its kind word takes, the first one ahead.
+        Some((kind, word)) => {
+            let first = if members == Members::Inherited {
+                kind
+            } else {
+                word
+            };
+            let (own, _) = crate::kinds::usages_of(first);
+            let specific = all(word).into_iter().filter(|k| !own.contains(k)).collect();
+            (own, specific)
+        }
+    };
+    Want {
+        keywords: Vec::new(),
+        names: Some(Names::Features {
+            preferred: [own, specific.clone()].concat(),
+            definitions: Vec::new(),
+            strict: false,
+            members,
+            specific,
+        }),
+    }
+}
+
+/// The kind of the usage `stmt` declares, from its kind keywords (`in
+/// item fuel` is an item, `perform action a` a performed action); `None`
+/// when it has none (`in x`, `ref`-less `x`, a bare `perform`). A payload
+/// follows `accept` and a flow's or a message's `of` (`action trigger
+/// accept sig : Signal`, `message of cmd : Command`): the statement's
+/// kind does not type it.
+fn usage_kind(src: &str, stmt: &[Token], dialect: Dialect) -> Option<UsageKind> {
+    declared_kinds(src, stmt, dialect).map(|(kind, _)| kind)
+}
+
+/// The kind of the usage `stmt` declares (see [`usage_kind`]) and the
+/// kind its last kind word names alone: a keyword ahead of that word
+/// makes it a more specific kind — `perform action` a performed action,
+/// which is an action, `exhibit state` an exhibited state, `include use
+/// case` an included use case, `satisfy requirement` a satisfied
+/// requirement, `assert constraint` an asserted constraint, and `event
+/// occurrence` an event — while `item x` declares an item alone.
+fn declared_kinds(src: &str, stmt: &[Token], dialect: Dialect) -> Option<(UsageKind, UsageKind)> {
+    use UsageKind as U;
+    let mut kinds = None;
+    let (mut prev, mut before): (Option<&str>, Option<&str>) = (None, None);
+    for t in stmt {
+        let Some(w) = (t.kind == TokenKind::Ident)
+            .then(|| t.text(src))
+            .filter(|w| is_reserved(dialect, w))
+        else {
+            (prev, before) = (None, None);
+            continue;
+        };
+        if matches!(w, "accept" | "of") {
+            kinds = None;
+            (prev, before) = (Some(w), prev);
+            continue;
+        }
+        let word = match w {
+            "attribute" => Some(U::Attribute),
+            "enum" => Some(U::Enum),
+            "occurrence" => Some(U::Occurrence),
+            "item" => Some(U::Item),
+            "part" | "actor" | "stakeholder" => Some(U::Part),
+            "port" => Some(U::Port),
+            "connection" => Some(U::Connection),
+            "interface" => Some(U::Interface),
+            "allocation" => Some(U::Allocation),
+            "flow" if prev == Some("succession") => Some(U::SuccessionFlow),
+            "flow" => Some(U::Flow),
+            "message" => Some(U::Message),
+            "action" => Some(U::Action),
+            "state" => Some(U::State),
+            "calc" => Some(U::Calc),
+            "constraint" => Some(U::Constraint),
+            "requirement" | "objective" => Some(U::Requirement),
+            "concern" => Some(U::Concern),
+            "case" if prev == Some("use") => Some(U::UseCase),
+            "case" => Some(U::Case),
+            "analysis" => Some(U::Analysis),
+            "verification" => Some(U::Verification),
+            "view" => Some(U::View),
+            "viewpoint" => Some(U::Viewpoint),
+            "rendering" => Some(U::Rendering),
+            "metadata" => Some(U::Metadata),
+            "ref" | "subject" => Some(U::Ref),
+            "event" => Some(U::Event),
+            "individual" | "snapshot" | "timeslice" => Some(U::Occurrence),
+            "binding" => Some(U::Binding),
+            "succession" => Some(U::Succession),
+            "feature" => Some(U::Feature),
+            "step" => Some(U::Step),
+            "expr" => Some(U::Expr),
+            "bool" => Some(U::BoolExpr),
+            "inv" => Some(U::Invariant),
+            "connector" => Some(U::Connector),
+            _ => None,
+        };
+        let declared = match (w, prev, before) {
+            ("action", Some("perform"), _) => Some(U::Perform),
+            ("state", Some("exhibit"), _) => Some(U::Exhibit),
+            ("case", Some("use"), Some("include")) => Some(U::Include),
+            ("requirement", Some("satisfy"), _) => Some(U::Satisfy),
+            ("constraint", Some("assert"), _) | ("constraint", Some("not"), Some("assert")) => {
+                Some(U::AssertConstraint)
+            }
+            ("occurrence", Some("event"), _) => Some(U::Event),
+            _ => word,
+        };
+        if let (Some(declared), Some(word)) = (declared, word) {
+            kinds = Some((declared, word));
+        }
+        (prev, before) = (Some(w), prev);
+    }
+    kinds
+}
+
+/// The kind of the definition or KerML type `stmt` declares; `None`
+/// when it declares a usage or a feature.
+fn definition_kind(src: &str, stmt: &[Token], dialect: Dialect) -> Option<DefKind> {
+    use DefKind as D;
+    let words: Vec<&str> = stmt
+        .iter()
+        .filter(|t| t.kind == TokenKind::Ident)
+        .map(|t| t.text(src))
+        .filter(|w| is_reserved(dialect, w))
+        .collect();
+    if let Some(at) = words.iter().position(|w| *w == "def") {
+        let kind = |w: &str| match w {
+            "attribute" => D::Attribute,
+            "enum" => D::Enum,
+            "occurrence" => D::Occurrence,
+            "individual" => D::Individual,
+            "item" => D::Item,
+            "metadata" => D::Metadata,
+            "part" => D::Part,
+            "port" => D::Port,
+            "connection" => D::Connection,
+            "interface" => D::Interface,
+            "allocation" => D::Allocation,
+            "flow" => D::Flow,
+            "action" => D::Action,
+            "state" => D::State,
+            "calc" => D::Calc,
+            "constraint" => D::Constraint,
+            "requirement" => D::Requirement,
+            "concern" => D::Concern,
+            "case" if at >= 2 && words[at - 2] == "use" => D::UseCase,
+            "case" => D::Case,
+            "analysis" => D::Analysis,
+            "verification" => D::Verification,
+            "view" => D::View,
+            "viewpoint" => D::Viewpoint,
+            "rendering" => D::Rendering,
+            _ => D::Extended,
+        };
+        return Some(at.checked_sub(1).map_or(D::Extended, |i| kind(words[i])));
+    }
+    words.iter().enumerate().find_map(|(i, w)| match *w {
+        "assoc" if words.get(i + 1) == Some(&"struct") => Some(D::AssocStruct),
+        "assoc" => Some(D::Assoc),
+        "behavior" => Some(D::Behavior),
+        "class" => Some(D::Class),
+        "classifier" => Some(D::Classifier),
+        "datatype" => Some(D::DataType),
+        "function" => Some(D::Function),
+        "interaction" => Some(D::Interaction),
+        "metaclass" => Some(D::Metaclass),
+        "predicate" => Some(D::Predicate),
+        "struct" => Some(D::Struct),
+        "type" => Some(D::Type),
+        _ => None,
+    })
+}
+
+const VISIBILITY: &[&str] = &["private", "protected", "public"];
+
+/// The annotating members any body takes.
+const ANNOTATIONS: &[&str] = &["comment", "doc", "language", "locale", "metadata", "rep"];
+
+/// The SysML keywords starting a definition or a usage, or a namespace
+/// member, in any body that declares members.
+const MEMBERS: &[&str] = &[
+    "abstract",
+    "action",
+    "alias",
+    "allocate",
+    "allocation",
+    "analysis",
+    "assert",
+    "attribute",
+    "bind",
+    "binding",
+    "calc",
+    "case",
+    "concern",
+    "connect",
+    "connection",
+    "constant",
+    "constraint",
+    "dependency",
+    "derived",
+    "end",
+    "enum",
+    "event",
+    "exhibit",
+    "first",
+    "flow",
+    "import",
+    "in",
+    "include",
+    "individual",
+    "inout",
+    "interface",
+    "item",
+    "library",
+    "message",
+    "occurrence",
+    "out",
+    "package",
+    "part",
+    "perform",
+    "port",
+    "ref",
+    "rendering",
+    "requirement",
+    "satisfy",
+    "snapshot",
+    "standard",
+    "state",
+    "succession",
+    "timeslice",
+    "use",
+    "variation",
+    "verification",
+    "view",
+    "viewpoint",
+];
+
+/// The KerML keywords starting a type, a feature, a relationship, or a
+/// namespace member.
+const KERML_MEMBERS: &[&str] = &[
+    "abstract",
+    "alias",
+    "assoc",
+    "behavior",
+    "binding",
+    "bool",
+    "class",
+    "classifier",
+    "composite",
+    "conjugate",
+    "conjugation",
+    "connector",
+    "const",
+    "datatype",
+    "dependency",
+    "derived",
+    "disjoining",
+    "disjoint",
+    "end",
+    "expr",
+    "feature",
+    "featuring",
+    "flow",
+    "function",
+    "import",
+    "in",
+    "inout",
+    "interaction",
+    "inv",
+    "inverse",
+    "inverting",
+    "library",
+    "metaclass",
+    "multiplicity",
+    "namespace",
+    "out",
+    "package",
+    "portion",
+    "predicate",
+    "redefinition",
+    "specialization",
+    "standard",
+    "step",
+    "struct",
+    "subclassifier",
+    "subset",
+    "subtype",
+    "succession",
+    "type",
+    "typing",
+    "var",
+];
+
+/// A statement's first word: the keywords its body takes, and names
+/// where the body ends in a result expression (or, in a metadata
+/// body, redefines features by name). `after_prefix`: visibility or
+/// prefix metadata came first.
+fn statement_start(body: Body, dialect: Dialect, after_prefix: bool) -> Option<Want> {
+    let action: &[&str] = &[
+        "accept",
+        "assign",
+        "decide",
+        "for",
+        "fork",
+        "if",
+        "join",
+        "loop",
+        "merge",
+        "send",
+        "terminate",
+        "while",
+    ];
+    let (groups, key, names): (Vec<&[&str]>, u8, Option<Names>) = match (dialect, body) {
+        (_, Body::Other | Body::Enumeration) => return None,
+        (_, Body::Metadata) => (
+            vec![&["alias", "feature", "import", "redefines", "ref"]],
+            AFTER,
+            features(&[], &[]).with(Members::Inherited).names,
+        ),
+        (Dialect::Sysml, Body::Namespace) => (vec![MEMBERS, &["filter"]], FIRST, None),
+        (Dialect::Sysml, Body::Definition | Body::Type) => {
+            (vec![MEMBERS, &["then", "variant"]], FIRST, None)
+        }
+        (Dialect::Sysml, Body::Action) => {
+            (vec![MEMBERS, &["then", "variant"], action], FIRST, None)
+        }
+        (Dialect::Sysml, Body::State) => (
+            vec![
+                MEMBERS,
+                &["then", "variant"],
+                &["accept", "do", "entry", "exit", "if", "transition"],
+            ],
+            FIRST,
+            None,
+        ),
+        (Dialect::Sysml, Body::Calculation { case }) => (
+            vec![
+                MEMBERS,
+                &["then", "variant", "return"],
+                action,
+                EXPRESSION_START,
+                if case {
+                    &["actor", "objective", "subject"]
+                } else {
+                    &[]
+                },
+            ],
+            WITH_WORKSPACE,
+            Some(Names::Operands { typed: None }),
+        ),
+        (Dialect::Sysml, Body::Function) => (
+            vec![
+                MEMBERS,
+                &["then", "variant", "return"],
+                action,
+                EXPRESSION_START,
+            ],
+            WITH_WORKSPACE,
+            Some(Names::Operands { typed: None }),
+        ),
+        (Dialect::Sysml, Body::Requirement) => (
+            vec![
+                MEMBERS,
+                &["then", "variant"],
+                &[
+                    "actor",
+                    "assume",
+                    "frame",
+                    "require",
+                    "stakeholder",
+                    "subject",
+                    "verify",
+                ],
+            ],
+            FIRST,
+            None,
+        ),
+        (Dialect::Sysml, Body::View) => (
+            vec![
+                MEMBERS,
+                &["then", "variant"],
+                &["expose", "filter", "render"],
+            ],
+            FIRST,
+            None,
+        ),
+        (Dialect::Kerml, Body::Namespace) => (vec![KERML_MEMBERS, &["filter"]], FIRST, None),
+        (Dialect::Kerml, Body::Function | Body::Calculation { .. }) => (
+            vec![KERML_MEMBERS, &["member", "return"], EXPRESSION_START],
+            WITH_WORKSPACE,
+            Some(Names::Operands { typed: None }),
+        ),
+        (Dialect::Kerml, _) => (vec![KERML_MEMBERS, &["member"]], FIRST, None),
+    };
+    let mut keywords: Vec<(&'static str, u8)> = Vec::new();
+    let prefixes: &[&[&str]] = if after_prefix { &[] } else { &[VISIBILITY] };
+    for &group in prefixes.iter().chain(&[ANNOTATIONS]).chain(&groups) {
+        for &w in group {
+            if !keywords.iter().any(|&(k, _)| k == w) {
+                keywords.push((w, key));
+            }
+        }
+    }
+    Some(Want { keywords, names })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Declarer, KERML, SYSML, Slot, scan};
+    use crate::position::offset32;
+    use sysmlv2_parser::ast::Dialect;
+    use sysmlv2_parser::parser::is_reserved;
+
+    /// The slot at the `|` in `marked`, the word being completed being
+    /// the identifier run before it.
+    fn slot_in(dialect: Dialect, marked: &str) -> Slot {
+        let at = marked.find('|').expect("cursor marker");
+        let text = marked.replacen('|', "", 1);
+        let word_start = text[..at]
+            .rfind(|c: char| !(c.is_ascii_alphanumeric() || c == '_'))
+            .map_or(0, |i| i + 1);
+        scan(&text, offset32(word_start), offset32(at), dialect).slot
+    }
+
+    fn slot(marked: &str) -> Slot {
+        slot_in(Dialect::Sysml, marked)
+    }
+
+    /// Neither quiet nor a declared name: completion is on.
+    fn open(slot: &Slot) -> bool {
+        matches!(slot, Slot::Want(_) | Slot::Open)
+    }
+
+    fn scanned(marked: &str) -> super::Scan {
+        let at = marked.find('|').expect("cursor marker");
+        let text = marked.replacen('|', "", 1);
+        scan(&text, offset32(at), offset32(at), Dialect::Sysml)
+    }
+
+    #[test]
+    fn tables_are_sorted_reserved_words() {
+        for (dialect, table) in [(Dialect::Sysml, SYSML), (Dialect::Kerml, KERML)] {
+            assert!(
+                table.windows(2).all(|w| w[0].keyword < w[1].keyword),
+                "{dialect:?} table must stay sorted for binary search"
+            );
+            for Declarer { keyword, instead } in table {
+                assert!(is_reserved(dialect, keyword), "{dialect:?}: {keyword}");
+                for w in instead.iter().flat_map(|g| g.iter()) {
+                    assert!(is_reserved(dialect, w), "{dialect:?}: {keyword} → {w}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn prose_is_quiet() {
+        for marked in [
+            "part def V {\n    /* the wheel|",
+            "part def V {\n    doc /* A vehicle part.|",
+            "part def V {\n    doc /* A vehicle part.|\n     */\n}",
+            "part def V {\n    // TODO:|",
+            "part def V {\n    // see Wheel::|",
+            "part def V {\n    //* note: |*/\n}",
+            "part def V {\n    comment about V /* see V.|",
+            "attribute s : String = \"v1.|",
+            "attribute s : String = \"v1.|2\";",
+            "attribute s = \"a\" + \"b: |",
+            "attribute s = \"say \\\"hi|",
+        ] {
+            assert_eq!(slot(marked), Slot::Quiet, "{marked:?}");
+        }
+        for marked in [
+            // after a closed comment, note, or string
+            "part def V {\n    /* done */ part w : W|",
+            "part def V {\n    //* done */ part w : W|",
+            "part def V {\n    // done\n    part w : W|",
+            "attribute s = \"a\" + b|",
+            // a quoted name being typed is a name, not prose
+            "part w : 'Wheel O|",
+            "part w : '|",
+        ] {
+            assert!(open(&slot(marked)), "{marked:?}: {:?}", slot(marked));
+        }
+    }
+
+    #[test]
+    fn numbers_and_range_bounds_are_quiet() {
+        for marked in [
+            "attribute x = 5|",
+            "attribute x = 12|",
+            "attribute x = 5.|",
+            "attribute x = 5.4|",
+            "attribute x = 1.5e|",
+            "attribute x = 1.5e3|",
+            "attribute x = 1.5e-|",
+            "attribute x = 2E+|",
+            "attribute x = .|",
+            "attribute x = (.|",
+            "part ws : Wheel [0.|",
+            "part ws : Wheel [0..|",
+            "part ws : Wheel [1..*|",
+            "part ws : Wheel [*|",
+            "attribute x = *|",
+        ] {
+            assert_eq!(slot(marked), Slot::Quiet, "{marked:?}");
+        }
+        for marked in [
+            // a feature chain, a product, a bound named by a feature
+            "attribute x = vehicle.|",
+            "attribute x = vehicle.ma|",
+            "attribute x = 2 * |",
+            "attribute x = a *|",
+            "part ws : Wheel [0..n|",
+            "attribute x = e-|",
+            "attribute x = v1|",
+            "attribute x = 9.8 [|",
+            "attribute x = 9.8 [k|",
+        ] {
+            assert!(open(&slot(marked)), "{marked:?}: {:?}", slot(marked));
+        }
+    }
+
+    /// Every class of SysML declaration: its name takes no reference.
+    #[test]
+    fn sysml_declared_names() {
+        for marked in [
+            // definitions, with their prefixes
+            "part def B|",
+            "abstract part def B|",
+            "variation part def B|",
+            "#Safety part def B|",
+            "private attribute def M|",
+            "use case def U|",
+            "individual def I|",
+            "individual part def I|",
+            "enum def E|",
+            "metadata def M|",
+            "occurrence def O|",
+            "flow def F|",
+            "interface def I|",
+            // usages of every kind that declares a name
+            "part e|",
+            "attribute m|",
+            "state o|",
+            "action a|",
+            "port p|",
+            "item i|",
+            "connection c|",
+            "allocation a|",
+            "calc c|",
+            "constraint c|",
+            "requirement r|",
+            "concern c|",
+            "case c|",
+            "use case u|",
+            "analysis a|",
+            "verification v|",
+            "view v|",
+            "viewpoint v|",
+            "rendering r|",
+            "occurrence o|",
+            "enum e|",
+            "binding b|",
+            "succession s|",
+            "event occurrence e|",
+            // usage prefixes, with or without a kind
+            "ref part x|",
+            "in item fuel|",
+            "out attribute a|",
+            "abstract part p|",
+            "derived ref r|",
+            "in f|",
+            "out d|",
+            "inout x|",
+            "return r|",
+            "end e|",
+            "ref r|",
+            "abstract a|",
+            "constant c|",
+            "derived d|",
+            "variation v|",
+            "individual i|",
+            "snapshot s|",
+            "timeslice t|",
+            // behaviors declared with their usage keyword
+            "perform action a|",
+            "exhibit state s|",
+            "include use case u|",
+            "assert constraint c|",
+            "assert not constraint c|",
+            "satisfy requirement r|",
+            "require constraint c|",
+            "assume constraint c|",
+            "frame concern c|",
+            "verify requirement r|",
+            "render rendering r|",
+            "entry action e|",
+            "then action a|",
+            // annotations, namespaces, aliases
+            "comment c|",
+            "doc d|",
+            "rep r|",
+            "package P|",
+            "library package L|",
+            "standard library package S|",
+            "alias A|",
+            // requirement and case members
+            "subject s|",
+            "actor d|",
+            "stakeholder s|",
+            "objective o|",
+            // control nodes and loop variables
+            "merge m|",
+            "decide d|",
+            "join j|",
+            "fork f|",
+            "for i|",
+            // short names, and the name after one
+            "part def <V|",
+            "part <p|",
+            "alias <a|",
+            "package <P|",
+            "part def <V> Veh|",
+            "part def <'V'> Veh|",
+            // with nothing typed yet
+            "part def |",
+            "part |",
+        ] {
+            assert!(
+                matches!(slot(marked), Slot::Declared(_)),
+                "{marked:?}: {:?}",
+                slot(marked)
+            );
+        }
+    }
+
+    /// A bare member of an enumeration body declares a literal.
+    #[test]
+    fn enumeration_literals() {
+        for marked in [
+            "enum def Color {\n    r|",
+            "enum def Color {\n    red;\n    g|",
+            "enum def Color {\n    enum b|",
+            "enum def Color {\n    private g|",
+            "enum def Color {\n    doc /* The colors */\n    g|",
+            "enum def Color {\n    <r|",
+            "enum def Color {\n    <r> re|",
+            "#Palette enum def Color {\n    r|",
+            "package P {\n    enum def Color {\n        |",
+        ] {
+            assert!(
+                matches!(slot(marked), Slot::Declared(_)),
+                "{marked:?}: {:?}",
+                slot(marked)
+            );
+        }
+        // Past the body, or in another body, a bare word is no literal.
+        for marked in [
+            "enum def Color {\n    red;\n}\nr|",
+            "enum def Color {\n    red;\n}\npart def P {\n    r|",
+            "enum def Color {\n    red = c|",
+            "enum def Color {\n    red :> c|",
+            "part def P {\n    enum def Color;\n    r|",
+            "enum e : Color {\n    r|",
+        ] {
+            assert!(open(&slot(marked)), "{marked:?}: {:?}", slot(marked));
+        }
+    }
+
+    /// Keywords whose next word may be a reference keep completion on.
+    #[test]
+    fn sysml_references_stay_open() {
+        for marked in [
+            "perform x|",
+            "exhibit x|",
+            "include x|",
+            "assert x|",
+            "assert not x|",
+            "satisfy R|",
+            "satisfy R by v|",
+            "satisfy requirement r : R by v|",
+            "verify R|",
+            "frame C|",
+            "require C|",
+            "render asTree|",
+            "then a|",
+            "first o|",
+            "first o then a|",
+            "entry e|",
+            "do d|",
+            "exit e|",
+            "accept sig : S|",
+            "bind a = b|",
+            "bind a|",
+            "connect a|",
+            "connect a to b|",
+            "connection c connect a to b|",
+            "allocate a|",
+            "alias A for B|",
+            "event e|",
+            "variant v|",
+            "for i in c|",
+            "import X|",
+            "private import X::|",
+            "expose x|",
+            "send x|",
+            "assign x|",
+            "if c|",
+            "part p : T|",
+            "part p defined by T|",
+            "part p :> q|",
+            "part p subsets q|",
+            "part p :>> q|",
+            "part def C :> V|",
+            "part def C specializes V|",
+            "attribute m = x|",
+            "attribute m : T = x|",
+            "part p : T [0..n|",
+            "part p = a.|",
+            "part p = a.b|",
+            "part p : A::|",
+            "part def P :> A::B|",
+            // either a name or a reference: only the rest tells
+            "transition t|",
+            "transition initial then off|",
+            "accept s|",
+            "flow f|",
+            "message m|",
+            "interface i|",
+            "metadata M|",
+            "@M|",
+            "dependency d|",
+            "succession flow f|",
+            // a statement's first word: a keyword, a name, or a reference
+            "part def P {\n    x|",
+            "part def P {\n    private x|",
+            // past the declared name
+            "part def Car s|",
+            "part engine : E|",
+            // a metadata body's members redefine features by name
+            "@M {\n    ref r|",
+            "metadata m : M {\n    ref r|",
+        ] {
+            assert!(open(&slot(marked)), "{marked:?}: {:?}", slot(marked));
+        }
+    }
+
+    /// A `def` continues the head only after definition prefixes.
+    #[test]
+    fn def_follows_definition_prefixes_only() {
+        let declared = |marked: &str| match slot(marked) {
+            Slot::Declared(words) => words,
+            other => panic!("{marked:?}: {other:?}"),
+        };
+        for marked in [
+            "part |",
+            "abstract part |",
+            "variation part |",
+            "individual part |",
+            "private #Safety part |",
+            "use case |",
+            "individual |",
+        ] {
+            assert!(declared(marked).contains(&"def"), "{marked:?}");
+        }
+        for marked in [
+            "ref part |",
+            "in item |",
+            "perform action |",
+            "include use case |",
+            "event occurrence |",
+            "then action |",
+            "enum def Color {\n    enum |",
+        ] {
+            assert!(!declared(marked).contains(&"def"), "{marked:?}");
+        }
+        assert_eq!(declared("part def |"), Vec::<&str>::new());
+        assert_eq!(declared("package |"), Vec::<&str>::new());
+        assert_eq!(declared("comment |"), vec!["about", "locale"]);
+        assert!(declared("in |").contains(&"item"));
+        assert!(declared("ref |").contains(&"part"));
+        assert_eq!(declared("part def <V|"), Vec::<&str>::new());
+    }
+
+    #[test]
+    fn kerml_declared_names() {
+        for marked in [
+            "class C|",
+            "abstract class C|",
+            "struct S|",
+            "datatype D|",
+            "assoc A|",
+            "assoc struct A|",
+            "behavior B|",
+            "function F|",
+            "predicate P|",
+            "interaction I|",
+            "metaclass M|",
+            "classifier C|",
+            "type T|",
+            "feature f|",
+            "step s|",
+            "expr e|",
+            "bool b|",
+            "inv i|",
+            "in x|",
+            "out y|",
+            "inout z|",
+            "abstract a|",
+            "composite c|",
+            "portion p|",
+            "var v|",
+            "const c|",
+            "end e|",
+            "derived d|",
+            "member m|",
+            "return r|",
+            "multiplicity m|",
+            "namespace N|",
+            "package P|",
+            "specialization s|",
+            "conjugation c|",
+            "disjoining d|",
+            "inverting i|",
+            "alias A|",
+            "comment c|",
+            "doc d|",
+            "rep r|",
+            "class <C|",
+            "class <C> Ca|",
+            "function F {\n    in x|",
+            // sufficiency and polarity come before the name
+            "class all C|",
+            "assoc all B|",
+            "feature all f|",
+            "step all s|",
+            "inv true c|",
+            "inv false c|",
+        ] {
+            assert!(
+                matches!(slot_in(Dialect::Kerml, marked), Slot::Declared(_)),
+                "{marked:?}: {:?}",
+                slot_in(Dialect::Kerml, marked)
+            );
+        }
+        for marked in [
+            // either a name or a reference
+            "connector c|",
+            "binding b|",
+            "succession s|",
+            "flow f|",
+            "featuring f|",
+            "metadata M|",
+            // references
+            "subtype a|",
+            "subclassifier a|",
+            "typing t|",
+            "feature f : T|",
+            "class C specializes B|",
+            "alias A for B|",
+            "@M {\n    feature f|",
+            "import all X|",
+            "connector all a|",
+            // SysML words are names in KerML
+            "part p|",
+            "attribute a|",
+        ] {
+            let slot = slot_in(Dialect::Kerml, marked);
+            assert!(open(&slot), "{marked:?}: {slot:?}");
+        }
+        // ... and KerML words are names in SysML.
+        for marked in ["class C|", "feature f|", "datatype D|"] {
+            assert!(open(&slot(marked)), "{marked:?}: {:?}", slot(marked));
+        }
+    }
+
+    /// Keywords the grammar puts where a declaration's name would be:
+    /// `abstract metadata def`, `variation perform`, and a usage
+    /// redefining without a name of its own (`part redefines engine`,
+    /// `ref redefines x`, KerML `feature redefines f`).
+    #[test]
+    fn declaration_heads_take_their_grammar_keywords() {
+        let declared = |dialect: Dialect, marked: &str| match slot_in(dialect, marked) {
+            Slot::Declared(words) => words,
+            other => panic!("{marked:?}: {other:?}"),
+        };
+        for (marked, word) in [
+            ("abstract |", "metadata"),
+            ("variation |", "perform"),
+            ("abstract |", "exhibit"),
+            ("part |", "redefines"),
+            ("attribute |", "redefines"),
+            ("ref |", "redefines"),
+            ("in |", "redefines"),
+        ] {
+            assert!(
+                declared(Dialect::Sysml, marked).contains(&word),
+                "{marked:?}"
+            );
+        }
+        for (marked, word) in [("feature |", "redefines"), ("in |", "redefines")] {
+            assert!(
+                declared(Dialect::Kerml, marked).contains(&word),
+                "{marked:?}"
+            );
+        }
+        assert!(!declared(Dialect::Kerml, "class all |").contains(&"all"));
+        assert!(declared(Dialect::Kerml, "inv true |").is_empty());
+    }
+
+    /// The statement starts after the last `;`, `{`, `}`, or comment
+    /// body token — never inside a comment, note, string, or quoted
+    /// name, nor in an expression's body passed within a `(`, which is
+    /// part of the statement around it. Signature help cuts the
+    /// statement completion does.
+    #[test]
+    fn statement_start_on_tokens() {
+        for (marked, start) in [
+            (
+                "package P {\n    attribute e = f({ in z; z }, v.|",
+                "attribute e",
+            ),
+            ("package P {\n    attribute e = f(1, g({ in z; z|", "z"),
+            (
+                "attribute a; attribute e = f({ in z; z }, (1), [2], |",
+                "attribute e",
+            ),
+            ("part def A { }\n    attribute e = f(1, |", "attribute e"),
+            (
+                "x\ndoc /* The\n * energy; }\n */ attribute e = f(1, |",
+                "attribute e",
+            ),
+            ("package P {\n    part x : T|", "part x"),
+            ("package P {\n    /* a; b { c } */ part x : T|", "part x"),
+            // notes are no statements' tokens
+            ("package P {\n    // a; b }\n    part x|", "part x"),
+            ("package P {\n    //* a;\n b } */ part x|", "part x"),
+            (
+                "package P {\n    attribute s = \"a;b}\" + c|",
+                "attribute s",
+            ),
+            ("package P {\n    attribute 'a;b' : T|", "attribute 'a;b'"),
+            ("package P {\n    doc /* d */\n    part x|", "part x"),
+            ("package P {\n    part x;\n    part y|", "part y"),
+            // a quoted name, or a string, left open on an earlier line
+            // runs no further than it: this line is read on its own
+            (
+                "package P {\n    attribute s = 'open;\n    part y|",
+                "part y",
+            ),
+            (
+                "package P {\n    attribute s = \"open;\n    part y|",
+                "part y",
+            ),
+            ("part x|", "part x"),
+        ] {
+            let s = scanned(marked);
+            let text = marked.replacen('|', "", 1);
+            assert!(
+                text[s.stmt_start as usize..].starts_with(start),
+                "{marked:?}: starts at {:?}",
+                &text[s.stmt_start as usize..]
+            );
+            let prefix = &text[..marked.find('|').expect("cursor")];
+            let (tokens, line) = super::tokens_ahead(prefix);
+            assert_eq!(
+                super::statement_begins(prefix, &tokens, line),
+                s.stmt_start,
+                "{marked:?}"
+            );
+        }
+        // Nothing typed yet: the cursor.
+        let marked = "package P {\n    part x;\n    |";
+        assert_eq!(scanned(marked).stmt_start as usize, marked.len() - 1);
+    }
+
+    #[test]
+    fn import_statements_on_tokens() {
+        for (marked, import) in [
+            ("package P {\n    private import X|", true),
+            ("package P {\n    import A::B::|", true),
+            ("package P {\n    public import all X|", true),
+            // the word inside a note, a comment, or a string is no keyword
+            ("package P {\n    // import note\n    part w : W|", false),
+            ("package P {\n    part w : W /* import */|", false),
+            ("package P {\n    attribute s = \"import\" + x|", false),
+            ("package P {\n    private import X;\n    part w : W|", false),
+        ] {
+            assert_eq!(scanned(marked).import, import, "{marked:?}");
+        }
+    }
+
+    /// The `Want` at the `|` in `marked`, which must be one.
+    fn want_in(dialect: Dialect, marked: &str) -> super::Want {
+        match slot_in(dialect, marked) {
+            Slot::Want(want) => want,
+            other => panic!("{marked:?}: {other:?}"),
+        }
+    }
+
+    fn want(marked: &str) -> super::Want {
+        want_in(Dialect::Sysml, marked)
+    }
+
+    fn keywords(want: &super::Want) -> Vec<&'static str> {
+        want.keywords.iter().map(|&(k, _)| k).collect()
+    }
+
+    /// After `:` (or `~`, `defined by`), the definitions a usage of the
+    /// statement's kind may be typed by — and no keyword.
+    #[test]
+    fn typing_positions_take_their_kinds_definitions() {
+        use super::Names;
+        use sysmlv2_parser::ast::DefKind as D;
+        for (marked, fits, loose, not) in [
+            (
+                "part p : |",
+                &[D::Part, D::Connection, D::Interface, D::View][..],
+                &[D::Item, D::Port][..],
+                &[D::Attribute, D::Action][..],
+            ),
+            (
+                "attribute x : Rea|",
+                &[D::Attribute, D::Enum, D::DataType],
+                &[],
+                &[D::Part, D::Item],
+            ),
+            ("port p : ~|", &[D::Port], &[], &[D::Part]),
+            ("port p defined by ~|", &[D::Port], &[], &[D::Part]),
+            (
+                "action d : Dr|",
+                &[D::Action, D::Behavior],
+                &[D::Calc],
+                &[D::Part],
+            ),
+            (
+                "in item f : F|",
+                &[D::Item, D::Part],
+                &[D::Port],
+                &[D::Attribute],
+            ),
+            ("state s : |", &[D::State], &[D::Action], &[D::Part]),
+            (
+                "constraint c : |",
+                &[D::Constraint, D::Predicate],
+                &[D::Requirement],
+                &[],
+            ),
+            ("calc k : |", &[D::Calc, D::Function], &[D::Case], &[]),
+            ("requirement r : |", &[D::Requirement], &[D::Concern], &[]),
+            ("exhibit state s : |", &[D::State], &[D::Action], &[D::Part]),
+            (
+                "perform action a : |",
+                &[D::Action],
+                &[D::State],
+                &[D::Part],
+            ),
+            ("include use case u : |", &[D::UseCase], &[], &[D::Case]),
+            ("frame concern c : |", &[D::Concern], &[], &[]),
+            ("actor d : |", &[D::Part], &[D::Item], &[]),
+            ("enum e : |", &[D::Enum], &[], &[D::Attribute]),
+            (
+                "metadata m : |",
+                &[D::Metadata, D::Metaclass],
+                &[],
+                &[D::Part],
+            ),
+            ("part p : A, |", &[D::Part], &[D::Item], &[D::Attribute]),
+            // a reference, a parameter without kind, a payload: any type
+            ("ref r : |", &[D::Part, D::Attribute, D::DataType], &[], &[]),
+            ("in x : |", &[D::Part, D::Attribute, D::Class], &[], &[]),
+            ("accept sig : S|", &[D::Item, D::Attribute], &[], &[]),
+        ] {
+            let w = want(marked);
+            assert!(w.keywords.is_empty(), "{marked:?}: {:?}", w.keywords);
+            let Some(Names::Types {
+                exact, compatible, ..
+            }) = &w.names
+            else {
+                panic!("{marked:?}: {:?}", w.names);
+            };
+            for k in fits {
+                assert!(exact.contains(k), "{marked:?}: {k:?} in {exact:?}");
+            }
+            for k in loose {
+                assert!(
+                    compatible.contains(k),
+                    "{marked:?}: {k:?} in {compatible:?}"
+                );
+            }
+            for k in not {
+                assert!(
+                    !exact.contains(k) && !compatible.contains(k),
+                    "{marked:?}: {k:?}"
+                );
+            }
+        }
+    }
+
+    /// `:>` on a definition takes supertypes of its kind first, on a
+    /// usage the features it subsets; `:>>` the features it redefines,
+    /// those of the usage's kind and of the kinds specializing it first
+    /// (a part is an item, an interface a connection, and a message a
+    /// flow), of every kind after a `ref` or a KerML `feature`, which
+    /// name none.
+    #[test]
+    fn specialization_and_feature_positions() {
+        use super::Names;
+        use crate::kinds::Decl;
+        use sysmlv2_parser::ast::{DefKind as D, UsageKind as U};
+        for (marked, exact) in [
+            ("part def Sedan :> C|", D::Part),
+            ("attribute def Temp :> Therm|", D::Attribute),
+            ("port def P2 specializes Fu|", D::Port),
+            ("action def A2 :> D|", D::Action),
+            ("abstract part def T :> V, |", D::Part),
+        ] {
+            let Some(Names::Types { exact: e, .. }) = want(marked).names else {
+                panic!("{marked:?}");
+            };
+            assert_eq!(e, vec![exact], "{marked:?}");
+        }
+        let Some(Names::Types { exact, .. }) =
+            want_in(Dialect::Kerml, "classifier C specializes B|").names
+        else {
+            panic!("classifier");
+        };
+        assert_eq!(exact, vec![D::Classifier]);
+        let parts = vec![
+            U::Part,
+            U::Connection,
+            U::Interface,
+            U::Allocation,
+            U::View,
+            U::Rendering,
+        ];
+        let items = [&[U::Item, U::Metadata][..], &parts[..]].concat();
+        for (marked, preferred) in [
+            ("part frontWheels : Wheel [2] :> wh|", parts.clone()),
+            ("attribute :>> |", vec![U::Attribute, U::Enum]),
+            ("attribute redefines ma|", vec![U::Attribute, U::Enum]),
+            ("part :>> e|", parts.clone()),
+            ("individual item :>> |", items.clone()),
+            (
+                "message :>> |",
+                vec![U::Flow, U::Message, U::SuccessionFlow],
+            ),
+            (":>> co|", vec![]),
+            ("ref r subsets |", vec![]),
+            ("ref :>> st|", vec![]),
+            ("ref part p :>> |", parts),
+        ] {
+            let Some(Names::Features { preferred: p, .. }) = want(marked).names else {
+                panic!("{marked:?}");
+            };
+            assert_eq!(p, preferred, "{marked:?}");
+        }
+        // The kinds specializing the statement's own rank after it: a
+        // part after an item, a succession flow after a message, which
+        // is a flow.
+        for (marked, specific, kind) in [
+            ("individual item :>> |", &items[1..], U::Metadata),
+            ("message :>> |", &[U::SuccessionFlow][..], U::SuccessionFlow),
+            ("attribute :>> |", &[U::Enum], U::Enum),
+        ] {
+            let w = want(marked);
+            let Some(Names::Features { specific: s, .. }) = &w.names else {
+                panic!("{marked:?}");
+            };
+            assert_eq!(s, specific, "{marked:?}");
+            assert_eq!(w.tier(Decl::Usage(kind)), 1, "{marked:?}");
+        }
+        assert_eq!(want("item :> |").tier(Decl::Usage(U::Item)), 0);
+        // An individual, a snapshot, or a time slice naming no kind of its
+        // own: every occurrence alike.
+        assert_eq!(want("snapshot s :> |").tier(Decl::Usage(U::Part)), 0);
+        assert_eq!(want("individual :>> |").tier(Decl::Usage(U::Action)), 0);
+        assert_eq!(
+            want("snapshot part s :> |").tier(Decl::Usage(U::Connection)),
+            1
+        );
+        assert_eq!(want("occurrence :>> |").tier(Decl::Usage(U::Part)), 1);
+        // A compound keyword declares the more specific kind it spells,
+        // ranked ahead of the other kinds its kind word takes; a bare
+        // `perform` names none.
+        for (marked, declared, word) in [
+            ("perform action :>> |", U::Perform, U::Action),
+            ("exhibit state :>> |", U::Exhibit, U::State),
+            ("include use case u :>> |", U::Include, U::UseCase),
+            ("satisfy requirement :>> |", U::Satisfy, U::Requirement),
+            (
+                "assert not constraint :>> |",
+                U::AssertConstraint,
+                U::Constraint,
+            ),
+            ("event occurrence :>> |", U::Event, U::Occurrence),
+        ] {
+            let w = want(marked);
+            assert_eq!(w.tier(Decl::Usage(declared)), 0, "{marked:?}");
+            assert_eq!(w.tier(Decl::Usage(word)), 1, "{marked:?}");
+            assert_eq!(w.group(Decl::Usage(word), true), Some(1), "{marked:?}");
+        }
+        // A subsetting or a reference ranks its kind word's own first.
+        for (marked, declared, word) in [
+            ("include use case u :> |", U::Include, U::UseCase),
+            ("perform action p ::> |", U::Perform, U::Action),
+        ] {
+            let w = want(marked);
+            assert_eq!(w.tier(Decl::Usage(word)), 0, "{marked:?}");
+            assert_eq!(w.tier(Decl::Usage(declared)), 1, "{marked:?}");
+        }
+        let Some(Names::Features { preferred, .. }) = want("perform :>> |").names else {
+            panic!("perform");
+        };
+        assert!(preferred.is_empty(), "{preferred:?}");
+        assert_eq!(want("ref :>> |").tier(Decl::Usage(U::Part)), 0);
+        assert_eq!(want("perform |").tier(Decl::Usage(U::State)), 0);
+        let Some(Names::Features { preferred, .. }) =
+            want_in(Dialect::Kerml, "feature f subsets |").names
+        else {
+            panic!("feature");
+        };
+        assert_eq!(preferred, vec![]);
+    }
+
+    /// After `=`, `:=`, an operator, `(`, or a condition keyword:
+    /// operands and the keywords that start an expression, `true` and
+    /// `false` first where the statement declares a `Boolean`; after an
+    /// operand, only the keyword operators.
+    #[test]
+    fn expression_positions() {
+        use super::{FIRST, Names, WITH_WORKSPACE};
+        for marked in [
+            "attribute w = |",
+            "attribute w = mass * |",
+            "attribute ke = KineticEnergy(|",
+            "attribute ke = KineticEnergy(m, |",
+            "assign level := |",
+            "if lev|",
+            "attribute ok = a and |",
+            "for i in |",
+        ] {
+            let w = want(marked);
+            assert!(
+                matches!(w.names, Some(Names::Operands { .. })),
+                "{marked:?}"
+            );
+            assert!(w.keywords.contains(&("true", WITH_WORKSPACE)), "{marked:?}");
+        }
+        let w = want("attribute b : Boolean = t|");
+        assert!(w.keywords.contains(&("true", FIRST)) && w.keywords.contains(&("false", FIRST)));
+        assert!(w.keywords.contains(&("null", WITH_WORKSPACE)));
+        let w = want("attribute b : ScalarValues::Boolean = |");
+        assert!(w.keywords.contains(&("true", FIRST)));
+        for marked in [
+            "attribute w = mass |",
+            "attribute w = f(x) |",
+            "attribute w = 5 [kg] |",
+            "constraint def C {\n    mass <= limit |",
+            "state def S {\n    attribute w = if c ? 1 else 2 |",
+        ] {
+            let w = want(marked);
+            assert_eq!(w.names, None, "{marked:?}");
+            assert!(keywords(&w).contains(&"and"), "{marked:?}");
+            assert!(!keywords(&w).contains(&"then"), "{marked:?}");
+        }
+        // Where the grammar goes on with `then`: after an action's `if`
+        // condition, and after a transition's trigger.
+        for marked in [
+            "action def A {\n    if level > 0 |",
+            "state def S {\n    transition first off accept after 5 [s] |",
+            "state def S {\n    accept after 5 [s] |",
+            "state def S {\n    transition first off if x > 0 |",
+            "state def S {\n    if x > 0 |",
+            "action def A {\n    first a1 if x > 0 |",
+            "action def A {\n    accept after 5 [s] |",
+            "action def A {\n    accept at t0 |",
+            "action def A {\n    accept when ready |",
+        ] {
+            let w = want(marked);
+            assert!(keywords(&w).contains(&"then"), "{marked:?}");
+            assert!(keywords(&w).contains(&"and"), "{marked:?}");
+        }
+        // After an accept's payload type no operator follows: `then`, the
+        // port it arrives through, and a transition's guard and effect.
+        for (marked, expected) in [
+            ("action def A {\n    accept Sig |", &["then", "via"][..]),
+            ("action def A {\n    accept sig : Sig |", &["then", "via"]),
+            (
+                "state def S {\n    accept Sig |",
+                &["then", "via", "if", "do"],
+            ),
+            (
+                "state def S {\n    transition first off accept Sig |",
+                &["then", "via", "if", "do"],
+            ),
+            ("state def S {\n    accept Sig do a |", &["then"]),
+        ] {
+            assert_eq!(keywords(&want(marked)), expected, "{marked:?}");
+        }
+        // Past a declaration's name, outside an expression, or inside a
+        // bracket the statement leaves open: unclassified.
+        for marked in [
+            "part def Car |",
+            "attribute mass |",
+            "attribute g = 9.8 [metre per|",
+            "attribute g = 9.8 [m / |",
+            "part w : Wheel [|",
+        ] {
+            assert_eq!(slot(marked), Slot::Open, "{marked:?}");
+        }
+    }
+
+    /// Which positions name the enclosing element's features besides
+    /// the symbol tables': its inherited ones at a redefinition, its own
+    /// and inherited ones at a succession or a subsetting.
+    #[test]
+    fn positions_name_the_enclosing_members() {
+        use super::Members;
+        for (marked, members) in [
+            ("attribute :>> |", Members::Inherited),
+            ("attribute :>> m|", Members::Inherited),
+            (":>> co|", Members::Inherited),
+            ("part :>> e|", Members::Inherited),
+            ("attribute redefines ma|", Members::Inherited),
+            ("attribute :>> a, |", Members::Inherited),
+            ("@Safety {\n    |", Members::Inherited),
+            ("@Safety {\n    ref c|", Members::Inherited),
+            ("first st|", Members::Scope),
+            ("then |", Members::Scope),
+            ("part fw : Wheel [2] :> wh|", Members::Scope),
+            ("part fw subsets wh|", Members::Scope),
+            ("part def Sedan :> C|", Members::None),
+            ("part p : |", Members::None),
+            ("attribute w = |", Members::None),
+            ("perform |", Members::None),
+        ] {
+            assert_eq!(want(marked).members(), members, "{marked:?}");
+        }
+    }
+
+    /// An expression position knows the type its statement declares,
+    /// and ranks measurement units after every other name — or first
+    /// where that type is a unit type.
+    #[test]
+    fn units_rank_by_the_declared_type() {
+        use super::{Names, UNITS};
+        let unit_types: std::collections::HashSet<String> =
+            ["ForceUnit", "MeasurementUnit"].map(String::from).into();
+        for (marked, typed, group) in [
+            ("attribute <N> newton : ForceUnit = |", Some("ForceUnit"), 0),
+            (
+                "attribute f : ISQ::ForceUnit = kg * |",
+                Some("ForceUnit"),
+                0,
+            ),
+            ("attribute m : MassValue = |", Some("MassValue"), UNITS),
+            ("attribute w = |", None, UNITS),
+        ] {
+            let w = want(marked);
+            let Some(Names::Operands { typed: t }) = &w.names else {
+                panic!("{marked:?}: {:?}", w.names);
+            };
+            assert_eq!(t.as_deref(), typed, "{marked:?}");
+            assert_eq!(w.unit_group(&unit_types), Some(group), "{marked:?}");
+        }
+        // Units rank by kind alone elsewhere.
+        assert_eq!(want("part p : |").unit_group(&unit_types), None);
+    }
+
+    /// After a keyword that references an element of a kind: that kind
+    /// of name, with the keyword declaring one instead ranked first.
+    #[test]
+    fn reference_keywords() {
+        use super::{AFTER, FIRST, Names};
+        use sysmlv2_parser::ast::UsageKind as U;
+        for (marked, kind, keyword) in [
+            ("perform |", U::Perform, "action"),
+            ("exhibit st|", U::Exhibit, "state"),
+            ("include |", U::Include, "use"),
+            ("satisfy Max|", U::Satisfy, "requirement"),
+            ("verify |", U::Requirement, "requirement"),
+            ("frame |", U::Concern, "concern"),
+            ("assert |", U::AssertConstraint, "constraint"),
+            ("require |", U::Constraint, "constraint"),
+            ("entry |", U::Action, "action"),
+            ("render |", U::Rendering, "rendering"),
+        ] {
+            let w = want(marked);
+            let Some(Names::Features { preferred, .. }) = &w.names else {
+                panic!("{marked:?}: {:?}", w.names);
+            };
+            assert!(preferred.contains(&kind), "{marked:?}: {preferred:?}");
+            assert!(w.keywords.contains(&(keyword, FIRST)), "{marked:?}");
+        }
+        // A successor is named more often than declared.
+        let w = want("then a|");
+        assert!(matches!(w.names, Some(Names::Features { .. })));
+        assert!(w.keywords.contains(&("action", AFTER)));
+        for marked in ["#Saf|", "@Saf|", "metadata Saf|"] {
+            let Some(Names::Types { exact, .. }) = want(marked).names else {
+                panic!("{marked:?}");
+            };
+            assert!(exact.contains(&sysmlv2_parser::ast::DefKind::Metadata));
+        }
+        for marked in [
+            "alias A for B|",
+            "expose |",
+            "comment about |",
+            "dependency d from a to |",
+        ] {
+            assert_eq!(want(marked).names, Some(Names::All), "{marked:?}");
+        }
+        for (marked, only) in [
+            ("part p defined |", "by"),
+            ("use |", "case"),
+            ("standard |", "library"),
+            ("library |", "package"),
+        ] {
+            let w = want(marked);
+            assert_eq!(keywords(&w), vec![only], "{marked:?}");
+            assert_eq!(w.names, None, "{marked:?}");
+        }
+        for marked in ["new Sig|", "x as |", "accept Sig|"] {
+            assert!(
+                matches!(want(marked).names, Some(Names::Types { .. })),
+                "{marked:?}"
+            );
+        }
+        for marked in [
+            "connect a to |",
+            "bind a = |",
+            "connect (a, |",
+            "satisfy R by v|",
+        ] {
+            assert!(
+                matches!(want(marked).names, Some(Names::Features { .. })),
+                "{marked:?}"
+            );
+        }
+    }
+
+    /// A statement's first word: the keywords its body takes — and
+    /// names only where the body ends in a result expression.
+    #[test]
+    fn statement_starts_take_their_bodys_keywords() {
+        use super::{FIRST, Names};
+        for (marked, has, lacks) in [
+            (
+                "package P {\n    |",
+                &["package", "part", "filter", "import"][..],
+                &["entry", "fork", "and"][..],
+            ),
+            (
+                "part def P {\n    |",
+                &["part", "attribute", "then", "private"],
+                &["entry", "fork", "filter"],
+            ),
+            (
+                "action def A {\n    |",
+                &["fork", "for", "merge", "first", "then"],
+                &["entry", "subject"],
+            ),
+            (
+                "state def S {\n    ent|",
+                &["entry", "exit", "do", "transition"],
+                &["fork"],
+            ),
+            (
+                "requirement def R {\n    |",
+                &["subject", "require", "assume", "frame"],
+                &["fork", "entry"],
+            ),
+            (
+                "view def V {\n    |",
+                &["expose", "render", "filter"],
+                &["entry"],
+            ),
+            (
+                "package P {\n    private |",
+                &["import", "part"],
+                &["private", "public"],
+            ),
+            ("|", &["package", "part"], &["fork"]),
+        ] {
+            let w = want(marked);
+            assert_eq!(w.names, None, "{marked:?}");
+            let kws = keywords(&w);
+            for k in has {
+                assert!(kws.contains(k), "{marked:?}: {k}");
+            }
+            for k in lacks {
+                assert!(!kws.contains(k), "{marked:?}: {k}");
+            }
+            assert!(
+                w.keywords.iter().all(|&(_, key)| key == FIRST),
+                "{marked:?}"
+            );
+        }
+        // Bodies ending in a result expression also take operands.
+        for marked in [
+            "constraint def C {\n    |",
+            "calc def K {\n    |",
+            "part def P {\n    assert constraint {\n        |",
+            "use case def U {\n    |",
+        ] {
+            let w = want(marked);
+            assert!(
+                matches!(w.names, Some(Names::Operands { .. })),
+                "{marked:?}"
+            );
+            let kws = keywords(&w);
+            assert!(
+                kws.contains(&"return") && kws.contains(&"true"),
+                "{marked:?}"
+            );
+        }
+        assert!(keywords(&want("use case def U {\n    |")).contains(&"objective"));
+        // A metadata body redefines features by name.
+        assert!(matches!(
+            want("@Safety {\n    |").names,
+            Some(Names::Features { .. })
+        ));
+        // KerML bodies take KerML's words.
+        let w = want_in(Dialect::Kerml, "package P {\n    |");
+        let kws = keywords(&w);
+        assert!(kws.contains(&"class") && kws.contains(&"feature") && !kws.contains(&"part"));
+        let w = want_in(Dialect::Kerml, "function F {\n    |");
+        assert!(matches!(w.names, Some(Names::Operands { .. })));
+        assert!(keywords(&w).contains(&"return"));
+    }
+
+    /// The keywords offered are the document's dialect's.
+    #[test]
+    fn keywords_are_the_dialects() {
+        let sysml = keywords(&want("part def P {\n    cons|"));
+        assert!(sysml.contains(&"constant") && sysml.contains(&"constraint"));
+        assert!(!sysml.contains(&"const"));
+        let kerml = keywords(&want_in(Dialect::Kerml, "package P {\n    cla|"));
+        assert!(kerml.contains(&"class") && !kerml.contains(&"part") && !kerml.contains(&"calc"));
+    }
+}
diff --git a/crates/sysmlv2-lsp/src/tokens.rs b/crates/sysmlv2-lsp/src/tokens.rs
index 409b316..56d15ae 100644
--- a/crates/sysmlv2-lsp/src/tokens.rs
+++ b/crates/sysmlv2-lsp/src/tokens.rs
@@ -18,8 +18,8 @@ use crate::position::{Mapper, offset32};
 use lsp_types::{SemanticToken, SemanticTokenModifier, SemanticTokenType};
 use std::collections::HashMap;
 use sysmlv2_parser::ast::{
-    DefKind, FeatureSpecialization, Identification, Member, MemberKind, QualifiedName, SourceUnit,
-    TargetRef, UsageKind,
+    DefKind, Dialect, FeatureSpecialization, Identification, Member, MemberKind, QualifiedName,
+    SourceUnit, TargetRef, UsageKind,
 };
 use sysmlv2_parser::span::Span;
 use sysmlv2_parser::token::{Token, TokenKind};
@@ -204,6 +204,18 @@ pub const VOCABULARY: &[&str] = &[
     "xor",
 ];
 
+/// The keywords of one dialect: the words of its own grammar and the
+/// shared expression grammar, in [`VOCABULARY`] order — exactly the
+/// words the dialect reserves (`const` and `datatype` are KerML's, `part`
+/// and `calc` SysML's). The `keywords_split_by_grammar` gate
+/// regenerates each dialect's set from its grammars.
+pub fn keywords(dialect: Dialect) -> impl Iterator<Item = &'static str> {
+    VOCABULARY
+        .iter()
+        .copied()
+        .filter(move |w| sysmlv2_parser::parser::is_reserved(dialect, w))
+}
+
 /// Legend indices — the order is the wire protocol; append only.
 #[must_use]
 pub fn legend_types() -> Vec<SemanticTokenType> {
diff --git a/crates/sysmlv2-lsp/src/units.rs b/crates/sysmlv2-lsp/src/units.rs
new file mode 100644
index 0000000..39c725d
--- /dev/null
+++ b/crates/sysmlv2-lsp/src/units.rs
@@ -0,0 +1,993 @@
+//! Units in quantity brackets. A `[` after a value opens the value's
+//! unit (`5.5 [s]`, `mass [kg]`); after a declared name or type it opens
+//! a multiplicity (`wheels : Wheel [4]`) — the two are told apart on
+//! the tokens before the bracket. When a unit bracket annotates a
+//! declaration's whole value, the declaration's type names the quantity
+//! the unit measures, and the units of the same dimension are the ones
+//! it takes; when it annotates the right operand of a comparison or a
+//! sum, the left operand names it, and when it annotates an argument,
+//! the parameter the argument binds.
+
+use crate::nav::CompletionCx;
+use std::collections::{HashMap, HashSet, VecDeque};
+use sysmlv2_parser::ast::{
+    Dialect, ExprKind, FeatureSpecialization, MemberKind, Name, QualifiedName,
+};
+use sysmlv2_parser::json::{ElementRef, ResolvedModel};
+use sysmlv2_parser::quantity::QuantityDims;
+use sysmlv2_parser::span::Span;
+use sysmlv2_parser::token::{Token, TokenKind};
+
+/// What the `[` around the cursor opens.
+#[derive(Debug, PartialEq)]
+pub(crate) enum Bracket {
+    /// A quantity's unit. `open` is the bracket's offset; `header` the
+    /// declaration the value belongs to (`attribute g : DurationValue`,
+    /// up to its `=`) when the bracket annotates that whole value, so
+    /// the declaration's type is the quantity the unit measures.
+    Unit { open: u32, header: Option<Span> },
+    /// Any other bracket — above all a multiplicity (`wheels : Wheel [`,
+    /// `[0..`), where no unit is written.
+    Other,
+}
+
+/// The bracket the cursor sits in, `None` outside one (the context's
+/// `in_bracket`, read once per request). The tokens of the statement
+/// ahead of the bracket decide: a number, a closing `)`, or — in an
+/// expression — a name before it opens a unit; anything else, a
+/// declared name or type above all, opens a multiplicity.
+pub(crate) fn bracket_at(text: &str, cx: &CompletionCx, dialect: Dialect) -> Option<Bracket> {
+    let (tokens, at) = bracketed_statement(text, cx)?;
+    let ahead = &tokens[..at];
+    let word = |t: &Token| &text[t.span.start as usize..t.span.end as usize];
+    let unit = match ahead.last() {
+        Some(t)
+            if matches!(
+                t.kind,
+                TokenKind::Decimal | TokenKind::Exp | TokenKind::RParen
+            ) =>
+        {
+            true
+        }
+        Some(t) if t.kind == TokenKind::UnrestrictedName => in_expression(text, ahead),
+        Some(t) if t.kind == TokenKind::Ident => {
+            !sysmlv2_parser::parser::is_reserved(dialect, word(t)) && in_expression(text, ahead)
+        }
+        _ => false,
+    };
+    if !unit {
+        return Some(Bracket::Other);
+    }
+    // The declaration whose whole value the bracket annotates: one
+    // primary between its `=` and the bracket.
+    let header = value_start(text, ahead)
+        .filter(|&(_, value)| single_primary(&ahead[value..]))
+        .and_then(|(marker, _)| {
+            let start = ahead.first()?.span.start;
+            let end = ahead[marker].span.start;
+            (start < end).then(|| Span::new(start, end))
+        });
+    Some(Bracket::Unit {
+        open: tokens[at].span.start,
+        header,
+    })
+}
+
+/// The statement the cursor is in, when it leaves a `[` open there:
+/// its significant tokens up to the word being completed, and the index
+/// of the innermost `[` it leaves open. The statement begins where
+/// completion reads it to ([`CompletionCx::stmt_start`]): after a `;`,
+/// a `{`, a `}`, or a comment body, an expression's body passed within
+/// a `(` or `[` (`f({ in z; z }, 5 [`) part of it, and on the cursor's
+/// line when a quote left open above runs into it. `None` outside a
+/// bracket (the context's `in_bracket`, read once per request).
+fn bracketed_statement(text: &str, cx: &CompletionCx) -> Option<(Vec<Token>, usize)> {
+    if !cx.in_bracket {
+        return None;
+    }
+    let start = cx.stmt_start.min(cx.partial_start);
+    let tokens: Vec<Token> =
+        sysmlv2_parser::lexer::tokenize(text.get(start as usize..cx.partial_start as usize)?)
+            .0
+            .into_iter()
+            .filter(|t| !t.kind.is_trivia() && t.kind != TokenKind::Eof)
+            .map(|t| Token::new(t.kind, Span::new(t.span.start + start, t.span.end + start)))
+            .collect();
+    let mut open: Vec<usize> = Vec::new();
+    for (i, t) in tokens.iter().enumerate() {
+        match t.kind {
+            TokenKind::LBracket => open.push(i),
+            TokenKind::RBracket => {
+                open.pop();
+            }
+            _ => {}
+        }
+    }
+    let at = *open.last()?;
+    Some((tokens, at))
+}
+
+/// The untyped attribute whose value's bracket the cursor sits in
+/// (`attribute m = 5 [k`): where its declared name ends — where a
+/// typing goes — and where the bracket opens. Read on the statement's
+/// tokens, so the words of a comment ahead of the declaration never
+/// count. `None` when the declaration types or specializes the feature
+/// (`:`, `:>`, `:>>`, `::>`, or their keyword forms) before its `=` — a
+/// keyword form may stand where the name would (`attribute redefines
+/// mass`) — declares no name, or the bracket does not annotate its whole
+/// value: the unit of an operand or an argument (`= v * 2 [`,
+/// `= f(5 [`) says nothing of the value's type.
+pub(crate) fn untyped_attribute(text: &str, cx: &CompletionCx) -> Option<(u32, u32)> {
+    use TokenKind as K;
+    let (tokens, at) = bracketed_statement(text, cx)?;
+    let statement = &tokens[..at];
+    let word = |t: &Token| &text[t.span.start as usize..t.span.end as usize];
+    let keyword = statement
+        .iter()
+        .position(|t| t.kind == K::Ident && word(t) == "attribute")?;
+    let mut name = keyword + 1;
+    // A short name `<m>` ahead of the name.
+    if statement.get(name).is_some_and(|t| t.kind == K::Lt) {
+        name += statement[name..].iter().position(|t| t.kind == K::Gt)? + 1;
+    }
+    // `attribute` is a SysML word, so SysML's reserved words are the ones
+    // that cannot name the feature: `attribute redefines mass` names none.
+    let declared = statement.get(name).filter(|t| {
+        t.kind == K::UnrestrictedName
+            || (t.kind == K::Ident && !sysmlv2_parser::parser::is_reserved(Dialect::Sysml, word(t)))
+    })?;
+    let eq = name + 1 + statement[name + 1..].iter().position(|t| t.kind == K::Eq)?;
+    let specialized = statement[name + 1..eq].iter().any(|t| {
+        matches!(
+            t.kind,
+            K::Colon | K::ColonGt | K::ColonGtGt | K::ColonColonGt
+        ) || (t.kind == K::Ident
+            && matches!(
+                word(t),
+                "typed" | "defined" | "subsets" | "redefines" | "references" | "crosses"
+            ))
+    });
+    (!specialized && single_primary(&statement[eq + 1..]))
+        .then(|| (declared.span.end, tokens[at].span.start))
+}
+
+/// Whether `ahead` — a statement's tokens before a bracket — puts the
+/// bracket in an expression (a value, an operand, an argument) rather
+/// than in a declaration's header, where a bracket after a name is its
+/// multiplicity. What closed brackets hold does not count, nor does a
+/// short name's `<` `>`.
+fn in_expression(text: &str, ahead: &[Token]) -> bool {
+    use TokenKind as K;
+    let mut depth = 0usize;
+    let mut i = 0;
+    while i < ahead.len() {
+        let t = &ahead[i];
+        match t.kind {
+            K::LBracket => depth += 1,
+            K::RBracket => depth = depth.saturating_sub(1),
+            _ if depth > 0 => {}
+            K::Lt if ahead.get(i + 2).is_some_and(|t| t.kind == K::Gt) => {
+                i += 3;
+                continue;
+            }
+            K::Eq
+            | K::ColonEq
+            | K::LParen
+            | K::Plus
+            | K::Minus
+            | K::Star
+            | K::StarStar
+            | K::Slash
+            | K::Percent
+            | K::Caret
+            | K::Lt
+            | K::Gt
+            | K::LtEq
+            | K::GtEq
+            | K::EqEq
+            | K::BangEq
+            | K::EqEqEq
+            | K::BangEqEq
+            | K::Question
+            | K::QuestionQuestion
+            | K::Pipe
+            | K::Amp
+            | K::Arrow => return true,
+            K::Ident
+                if matches!(
+                    &text[t.span.start as usize..t.span.end as usize],
+                    "default" | "and" | "or" | "xor" | "implies" | "not"
+                ) =>
+            {
+                return true;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    false
+}
+
+/// Where a declared value starts in `ahead`, a statement's tokens
+/// before a bracket: the index of its `=`, `:=`, or `default` outside
+/// any group, and the index the value itself starts at (past a `=` or
+/// `:=` behind `default`). `None` when the statement declares no value
+/// there.
+fn value_start(text: &str, ahead: &[Token]) -> Option<(usize, usize)> {
+    use TokenKind as K;
+    let mut depth = 0usize;
+    for (i, t) in ahead.iter().enumerate() {
+        match t.kind {
+            K::LBracket | K::LParen | K::LBrace => depth += 1,
+            K::RBracket | K::RParen | K::RBrace => depth = depth.saturating_sub(1),
+            K::Eq | K::ColonEq if depth == 0 => return Some((i, i + 1)),
+            K::Ident
+                if depth == 0 && &text[t.span.start as usize..t.span.end as usize] == "default" =>
+            {
+                let assigned = ahead
+                    .get(i + 1)
+                    .is_some_and(|t| matches!(t.kind, K::Eq | K::ColonEq));
+                return Some((i, i + 1 + usize::from(assigned)));
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// Whether `tokens` spell one primary — a number (`5`, `5.5`, `1.5e3`,
+/// signed), a parenthesized expression, or a name chain (`a.b`,
+/// `P::c`) — so a bracket behind them annotates all of it.
+fn single_primary(tokens: &[Token]) -> bool {
+    use TokenKind as K;
+    let tokens = match tokens.first().map(|t| t.kind) {
+        Some(K::Minus | K::Plus) => &tokens[1..],
+        _ => tokens,
+    };
+    let kinds: Vec<K> = tokens.iter().map(|t| t.kind).collect();
+    match kinds.as_slice() {
+        [K::Decimal | K::Exp]
+        | [K::Decimal, K::Dot, K::Decimal | K::Exp]
+        | [K::Dot, K::Decimal] => true,
+        [K::LParen, .., K::RParen] => {
+            // One group: the opening `(` closes only at the end.
+            let mut depth = 0usize;
+            kinds.iter().enumerate().all(|(i, k)| {
+                match k {
+                    K::LParen | K::LBracket => depth += 1,
+                    K::RParen | K::RBracket => depth = depth.saturating_sub(1),
+                    _ => {}
+                }
+                depth > 0 || i + 1 == kinds.len()
+            })
+        }
+        [] => false,
+        names => {
+            names.iter().enumerate().all(|(i, k)| match i % 2 {
+                0 => matches!(k, K::Ident | K::UnrestrictedName),
+                _ => matches!(k, K::Dot | K::ColonColon),
+            }) && names.len() % 2 == 1
+        }
+    }
+}
+
+/// Where a unit bracket that annotates no declaration's whole value
+/// finds the quantity its unit measures (see [`unit_context`]).
+#[derive(Debug, PartialEq)]
+pub(crate) enum Context {
+    /// The bracket's value is the right operand of a comparison, a sum
+    /// or a difference (`mass <= 1500 [`), which measures what the left
+    /// operand measures: that operand's span.
+    Operand(Span),
+    /// The bracket's value is a whole argument of an invocation
+    /// (`KineticEnergy(1500 [`), which measures what the parameter it
+    /// binds measures: the invoked name's span, the argument's position,
+    /// and the parameter it names (`v = 20 [`), when it names one.
+    Argument {
+        callee: Span,
+        position: usize,
+        named: Option<String>,
+    },
+}
+
+/// The context of the unit bracket the cursor sits in, read on the
+/// statement's tokens (see [`Context`]). `None` when the bracket's value
+/// is a declaration's, a factor's (`mass * 2 [`) — whose quantity is
+/// not the product's — or an operand whose left operand is a factor
+/// (`2 * mass <= 1500 [`), and outside an argument list.
+pub(crate) fn unit_context(text: &str, cx: &CompletionCx) -> Option<Context> {
+    use TokenKind as K;
+    let (tokens, at) = bracketed_statement(text, cx)?;
+    let ahead = &tokens[..at];
+    let mut value = operand_start(ahead, ahead.len())?;
+    // A sign, where no operand ends before it.
+    if value > 0
+        && matches!(ahead[value - 1].kind, K::Plus | K::Minus)
+        && !(value > 1 && ends_operand(text, &ahead[value - 2]))
+    {
+        value -= 1;
+    }
+    let span = |from: usize, to: usize| Span::new(ahead[from].span.start, ahead[to - 1].span.end);
+    let before = &ahead[value.checked_sub(1)?];
+    match before.kind {
+        K::Lt
+        | K::Gt
+        | K::LtEq
+        | K::GtEq
+        | K::EqEq
+        | K::BangEq
+        | K::EqEqEq
+        | K::BangEqEq
+        | K::Plus
+        | K::Minus => {
+            let op = value - 1;
+            let left = operand_start(ahead, op)?;
+            let factor = left.checked_sub(1).is_some_and(|i| {
+                matches!(
+                    ahead[i].kind,
+                    K::Star | K::StarStar | K::Slash | K::Percent | K::Caret
+                )
+            });
+            (!factor).then(|| Context::Operand(span(left, op)))
+        }
+        K::LParen | K::Comma | K::Eq => {
+            let (named, start) = if before.kind == K::Eq {
+                let name = &ahead[value.checked_sub(2)?];
+                if !matches!(name.kind, K::Ident | K::UnrestrictedName) {
+                    return None;
+                }
+                let name = sysmlv2_parser::lexer::unescape(name.text(text));
+                (Some(name), value - 2)
+            } else {
+                (None, value)
+            };
+            // Back to the `(` the argument list opens, counting the
+            // arguments before this one.
+            let mut depth = 0usize;
+            let mut position = 0;
+            for i in (0..start).rev() {
+                match ahead[i].kind {
+                    K::RParen | K::RBracket | K::RBrace => depth += 1,
+                    K::LParen | K::LBracket | K::LBrace if depth > 0 => depth -= 1,
+                    K::LParen => {
+                        // The name invoked, not an index (`xs#(`), a
+                        // group, or a step after `->`, whose first
+                        // parameter the target binds.
+                        if !matches!(
+                            i.checked_sub(1).map(|j| ahead[j].kind),
+                            Some(K::Ident | K::UnrestrictedName)
+                        ) {
+                            return None;
+                        }
+                        let callee = operand_start(ahead, i)?;
+                        let arrow = callee
+                            .checked_sub(1)
+                            .is_some_and(|j| ahead[j].kind == K::Arrow);
+                        return (!arrow).then(|| Context::Argument {
+                            callee: span(callee, i),
+                            position,
+                            named,
+                        });
+                    }
+                    K::LBracket | K::LBrace => return None,
+                    K::Comma if depth == 0 => position += 1,
+                    _ => {}
+                }
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+/// Where the operand ending with `tokens[..end]` starts: a number
+/// (`5`, `5.5`, `.5`, `1.5e3`), a name chain (`a.b`, `P::c`), or a
+/// parenthesized expression, with what follows one — an invocation's or
+/// an index's arguments (`f(x)`, `xs#(1)`), a unit (`5 [kg]`), a chain
+/// step after those (`f(x).y`). `None` when no operand ends there.
+fn operand_start(tokens: &[Token], end: usize) -> Option<usize> {
+    use TokenKind as K;
+    let name = |i: usize| matches!(tokens[i].kind, K::Ident | K::UnrestrictedName);
+    let mut i = end;
+    loop {
+        match tokens[..i].last()?.kind {
+            K::Decimal | K::Exp => {
+                i -= 1;
+                if i > 0 && tokens[i - 1].kind == K::Dot {
+                    i -= 1;
+                    if i > 0 && tokens[i - 1].kind == K::Decimal {
+                        i -= 1;
+                    }
+                }
+                return Some(i);
+            }
+            K::Ident | K::UnrestrictedName => {
+                i -= 1;
+                let step = i > 1
+                    && matches!(tokens[i - 1].kind, K::Dot | K::ColonColon)
+                    && (name(i - 2) || tokens[i - 2].kind == K::RParen);
+                if !step {
+                    return Some(i);
+                }
+                i -= 1;
+            }
+            K::RParen | K::RBracket => {
+                i = opener(tokens, i - 1)?;
+                // An invocation's or an index's arguments, or a unit:
+                // the operand they follow.
+                if tokens[i].kind == K::LParen {
+                    if i > 1 && tokens[i - 1].kind == K::Hash {
+                        i -= 1;
+                    } else if !(i > 0 && name(i - 1)) {
+                        return Some(i);
+                    }
+                }
+            }
+            _ => return None,
+        }
+    }
+}
+
+/// The index of the opener matching the closer at `tokens[close]`.
+fn opener(tokens: &[Token], close: usize) -> Option<usize> {
+    use TokenKind as K;
+    let mut depth = 0usize;
+    for i in (0..=close).rev() {
+        match tokens[i].kind {
+            K::RParen | K::RBracket | K::RBrace => depth += 1,
+            K::LParen | K::LBracket | K::LBrace => {
+                depth = depth.checked_sub(1)?;
+                if depth == 0 {
+                    return Some(i);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// Can an operand end with `t` — a `+` or `-` after it a binary
+/// operator, not a sign?
+fn ends_operand(text: &str, t: &Token) -> bool {
+    use TokenKind as K;
+    match t.kind {
+        K::Decimal | K::Exp | K::String | K::UnrestrictedName | K::RParen | K::RBracket => true,
+        K::Ident => !matches!(
+            t.text(text),
+            "and" | "or" | "xor" | "implies" | "not" | "if" | "else" | "default"
+        ),
+        _ => false,
+    }
+}
+
+/// The quantity a unit bracket's context gives its value (see
+/// [`unit_context`]): an operand's — the quantity its type measures, or
+/// the dimension of the unit it carries (`1200 [kg] + 300 [`) — or the
+/// quantity of the parameter an argument binds. `enclosing` are the
+/// declarations the statement sits in, innermost first, which names
+/// resolve from. `None` when that names no quantity.
+pub(crate) fn context_measure(
+    resolved: &mut ResolvedModel,
+    enclosing: &[ElementRef],
+    text: &str,
+    context: &Context,
+    dialect: Dialect,
+) -> Option<Measured> {
+    let spelled = |span: &Span| {
+        crate::receiver::parse_receiver(text.get(span.start as usize..span.end as usize)?, dialect)
+    };
+    match context {
+        Context::Operand(operand) => {
+            let operand = spelled(operand)?;
+            let measured = match &operand.kind {
+                // The unit the operand carries (`1200 [kg]`): its
+                // dimension, and the references it is typed by, which a
+                // unit with no dimension the library can compute fits by
+                // (`5 ['$']`), as a declared quantity's do — but the
+                // library's general references, the definitions
+                // `MeasurementReferences` declares: a unit, a simple or a
+                // derived unit, a scale, a frame of any kind, which every
+                // unit of the kind is (the units of its dimension-one unit
+                // fit by their dimension anyway).
+                ExprKind::Bracket { arg, .. } => {
+                    let unit = crate::receiver::receiver_element(resolved, enclosing, arg)?;
+                    let dims = Units::new(resolved).dims_of(resolved, unit)?;
+                    let general = resolved.resolve_qualified("MeasurementReferences");
+                    let refs = resolved
+                        .typings(unit)
+                        .into_iter()
+                        .filter(|&r| {
+                            general.is_none_or(|general| resolved.owner(r) != Some(general))
+                        })
+                        .collect();
+                    Measured {
+                        dims: dims.into_iter().next(),
+                        refs,
+                    }
+                }
+                _ => {
+                    let operand = crate::receiver::receiver_element(resolved, enclosing, &operand)?;
+                    measured_by(resolved, operand)?
+                }
+            };
+            // A reading on a scale — a time instant — is compared with,
+            // or moved by, a difference, which the scale's unit measures
+            // and not the scale (`TimeOf(a) - TimeOf(b) < 2 [s]`, `t + 5
+            // [h]`): such an operand names no quantity for the bracket.
+            (!on_a_scale(resolved, &measured)).then_some(measured)
+        }
+        Context::Argument {
+            callee,
+            position,
+            named,
+        } => {
+            let callee = spelled(callee)?;
+            let callee = crate::receiver::receiver_element(resolved, enclosing, &callee)?;
+            // The inputs signature help shows, in its order: arguments
+            // bind no output.
+            let mut inputs = crate::receiver::parameters(resolved, callee)
+                .into_iter()
+                .filter(|&(p, _)| crate::receiver::binds_argument(resolved, p));
+            let (parameter, _) = match named {
+                Some(name) => inputs.find(|(_, n)| n.as_deref() == Some(name.as_str()))?,
+                None => inputs.nth(*position)?,
+            };
+            measured_by(resolved, parameter)
+        }
+    }
+}
+
+/// The quantity a declaration's value measures, as the units that fit
+/// it are told apart: its dimension, and the measurement-reference
+/// definitions its `mRef` is typed by. A unit typed by one of those
+/// fits even when it has no dimension the library can compute — a unit
+/// of a quantity the model itself defines on a base quantity of its
+/// own (`'$' : CurrencyUnit`), a vector's coordinate frame.
+pub(crate) struct Measured {
+    dims: Option<QuantityDims>,
+    refs: Vec<ElementRef>,
+}
+
+/// The quantity a declaration's value measures (see [`Measured`]), read
+/// from its `header` (`attribute g : ISQ::DurationValue`): the declared
+/// type's, else — `attribute :>> mass`, `in limit` — that of the
+/// feature it redefines or subsets, a directed parameter's being the
+/// same-named one it redefines implicitly. `enclosing` are the
+/// declarations the header sits in, innermost first; names resolve from
+/// the innermost's body. `None` when the header names no quantity.
+pub(crate) fn declared_measure(
+    resolved: &mut ResolvedModel,
+    enclosing: &[ElementRef],
+    header: &str,
+    dialect: Dialect,
+) -> Option<Measured> {
+    let source = format!("{header};");
+    let parse = match dialect {
+        Dialect::Kerml => sysmlv2_parser::parser::parse_kerml_source(&source),
+        Dialect::Sysml => sysmlv2_parser::parser::parse_source(&source),
+    };
+    let usage = match &parse.unit.members.first()?.kind {
+        MemberKind::Usage(u) | MemberKind::Return(u) => u,
+        _ => return None,
+    };
+    let name_of = |t: &sysmlv2_parser::ast::TargetRef| match t {
+        sysmlv2_parser::ast::TargetRef::Name(qn) => Some(qn.clone()),
+        sysmlv2_parser::ast::TargetRef::Chain(_) => None,
+    };
+    // Types first, then the features the declaration specializes.
+    let mut names: Vec<QualifiedName> = Vec::new();
+    let mut features: Vec<QualifiedName> = Vec::new();
+    for spec in &usage.declaration.specializations {
+        match spec {
+            FeatureSpecialization::TypedBy(types) => {
+                names.extend(types.iter().filter_map(|t| name_of(&t.target)));
+            }
+            FeatureSpecialization::Redefines(targets) | FeatureSpecialization::Subsets(targets) => {
+                features.extend(targets.iter().filter_map(name_of));
+            }
+            _ => {}
+        }
+    }
+    names.append(&mut features);
+    let scope = enclosing
+        .first()
+        .and_then(|&e| resolved.element_scope(e))
+        .unwrap_or_else(|| resolved.root_scope());
+    let mut found: Vec<ElementRef> = names
+        .iter()
+        .filter_map(|qn| resolved.resolve_in(scope, qn))
+        .collect();
+    if found.is_empty() && usage.prefix.direction.is_some() {
+        if let (Some(&owner), Some(name)) = (enclosing.first(), &usage.declaration.id.name) {
+            found.extend(
+                resolved
+                    .member_of(owner, &simple_name(&name.value))
+                    .map(|(hit, _)| hit),
+            );
+        }
+    }
+    found.into_iter().find_map(|e| measured_by(resolved, e))
+}
+
+/// Whether `measured` is read on measurement scales alone (a time
+/// instant's `TimeScale`), with no dimension of its own.
+fn on_a_scale(resolved: &mut ResolvedModel, measured: &Measured) -> bool {
+    let Some(scale) = resolved.resolve_qualified("MeasurementReferences::MeasurementScale") else {
+        return false;
+    };
+    measured.dims.is_none()
+        && !measured.refs.is_empty()
+        && measured.refs.iter().all(|&r| resolved.conforms(r, scale))
+}
+
+/// The quantity a type — or a feature, through its types — measures;
+/// `None` when it is no quantity.
+fn measured_by(resolved: &mut ResolvedModel, e: ElementRef) -> Option<Measured> {
+    let dims = resolved.quantity_dims_of_type(e);
+    let refs = resolved
+        .member_of(e, &simple_name("mRef"))
+        .map(|(mref, _)| resolved.typings(mref))
+        .unwrap_or_default();
+    (dims.is_some() || !refs.is_empty()).then_some(Measured { dims, refs })
+}
+
+/// `name` as a one-segment reference.
+fn simple_name(name: &str) -> QualifiedName {
+    QualifiedName {
+        is_global: false,
+        segments: vec![Name {
+            value: name.to_string(),
+            span: Span::new(0, 0),
+        }],
+        span: Span::new(0, 0),
+    }
+}
+
+/// A unit a completion can offer, as [`Units::entry`] classifies it.
+pub(crate) struct UnitEntry {
+    element: ElementRef,
+    /// The dimensions it measures (see [`Units::dims_of`]).
+    dims: Vec<QuantityDims>,
+    /// Named by its short name (`kg`), not its declared one.
+    pub(crate) short: bool,
+}
+
+/// Which elements are units, and the dimensions they measure. An
+/// element typed by a measurement reference — a unit, a measurement
+/// scale, a coordinate frame — is one, measuring the dimension of the
+/// quantity types its definition is the unit of (failing that, those of
+/// the nearest definition it specializes). Memoized per definition:
+/// hundreds of units share a few dozen.
+pub(crate) struct Units {
+    /// The library's most general measurement reference; `None`
+    /// without one, when nothing is a unit.
+    reference: Option<ElementRef>,
+    /// Per definition: `None` when it is no measurement reference,
+    /// else the dimension it measures, when known.
+    defs: HashMap<ElementRef, Option<Option<QuantityDims>>>,
+}
+
+impl Units {
+    pub(crate) fn new(resolved: &mut ResolvedModel) -> Units {
+        Units {
+            reference: resolved
+                .resolve_qualified("MeasurementReferences::TensorMeasurementReference"),
+            defs: HashMap::new(),
+        }
+    }
+
+    /// The unit the symbol `name` (`qualified` from the root) names, or
+    /// `None` when it names no unit.
+    pub(crate) fn entry(
+        &mut self,
+        resolved: &mut ResolvedModel,
+        qualified: &str,
+        name: &str,
+    ) -> Option<UnitEntry> {
+        let element = resolved.resolve_qualified(qualified)?;
+        self.entry_of(resolved, element, name)
+    }
+
+    /// The unit `element`, named `name`, is, or `None` when it is no
+    /// unit.
+    pub(crate) fn entry_of(
+        &mut self,
+        resolved: &mut ResolvedModel,
+        element: ElementRef,
+        name: &str,
+    ) -> Option<UnitEntry> {
+        let dims = self.dims_of(resolved, element)?;
+        let short = resolved.element_declared_short_name(element) == Some(name);
+        Some(UnitEntry {
+            element,
+            dims,
+            short,
+        })
+    }
+
+    /// `None` when `e` is not a unit; else the dimensions it measures,
+    /// empty when none is known (a scale, an opaque unit).
+    fn dims_of(
+        &mut self,
+        resolved: &mut ResolvedModel,
+        e: ElementRef,
+    ) -> Option<Vec<QuantityDims>> {
+        let reference = self.reference?;
+        let mut unit = false;
+        let mut dims = Vec::new();
+        for def in resolved.typings(e) {
+            let class = match self.defs.get(&def) {
+                Some(class) => class.clone(),
+                None => {
+                    let class = Self::classify(resolved, reference, def);
+                    self.defs.insert(def, class.clone());
+                    class
+                }
+            };
+            if let Some(measured) = class {
+                unit = true;
+                dims.extend(measured);
+            }
+        }
+        unit.then_some(dims)
+    }
+
+    /// Whether `unit` fits the quantity `measured`: the same dimension,
+    /// or typed by one of its measurement-reference definitions.
+    pub(crate) fn fits(
+        resolved: &mut ResolvedModel,
+        unit: &UnitEntry,
+        measured: &Measured,
+    ) -> bool {
+        measured
+            .dims
+            .as_ref()
+            .is_some_and(|d| unit.dims.contains(d))
+            || resolved
+                .typings(unit.element)
+                .into_iter()
+                .any(|t| measured.refs.iter().any(|&r| resolved.conforms(t, r)))
+    }
+
+    /// A definition's entry in [`Units::defs`].
+    fn classify(
+        resolved: &mut ResolvedModel,
+        reference: ElementRef,
+        def: ElementRef,
+    ) -> Option<Option<QuantityDims>> {
+        if !resolved.conforms(def, reference) {
+            return None;
+        }
+        // The quantity types this definition, or the nearest definition
+        // it specializes, is the unit of.
+        let mut visited = HashSet::new();
+        let mut frontier = VecDeque::from([def]);
+        while let Some(d) = frontier.pop_front() {
+            if !visited.insert(d) {
+                continue;
+            }
+            let measured = resolved
+                .quantity_types_for_unit_def(d)
+                .into_iter()
+                .find_map(|q| resolved.quantity_dims_of_type(q));
+            if measured.is_some() {
+                return Some(measured);
+            }
+            frontier.extend(resolved.explicit_supertypes(d));
+        }
+        Some(None)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Bracket, bracket_at};
+    use crate::nav::completion_context;
+    use crate::position::offset32;
+    use sysmlv2_parser::ast::Dialect;
+
+    /// What [`bracket_at`] makes of the bracket before the end of
+    /// `text`, with the unit's declaration header spelled out.
+    fn classify(text: &str) -> Option<Result<Option<&str>, ()>> {
+        let cx = completion_context(text, offset32(text.len()), Dialect::Sysml);
+        Some(match bracket_at(text, &cx, Dialect::Sysml)? {
+            Bracket::Unit { header, .. } => {
+                Ok(header.map(|h| &text[h.start as usize..h.end as usize]))
+            }
+            Bracket::Other => Err(()),
+        })
+    }
+
+    #[test]
+    fn a_bracket_after_a_value_opens_a_unit() {
+        for (text, header) in [
+            (
+                "attribute g : DurationValue = 5.5 [",
+                Some("attribute g : DurationValue "),
+            ),
+            (
+                "attribute g : DurationValue = 5.5 [mi",
+                Some("attribute g : DurationValue "),
+            ),
+            (
+                "part def P { attribute :>> mass = -1500 [k",
+                Some("attribute :>> mass "),
+            ),
+            (
+                "attribute x : Real default = 1e3 [",
+                Some("attribute x : Real "),
+            ),
+            ("attribute x := (a + b) [", Some("attribute x ")),
+            ("attribute m = mass [", Some("attribute m ")),
+            (
+                "attribute <m> mass : MassValue = 5 [",
+                Some("attribute <m> mass : MassValue "),
+            ),
+            // a factor of a larger value, or an argument
+            ("attribute d : LengthValue = v * 2 [", None),
+            ("attribute e = f(1 [", None),
+            ("attribute e = f(x [", None),
+            ("attribute m = 5 [kg] + 3 [", None),
+            // an expression statement: a constraint's operands
+            ("assert constraint { mass <= 2000 [", None),
+            ("assert constraint { mass <= limit [", None),
+            // the statement goes on past a body passed as an argument
+            ("attribute e = f({ in z; z }, x [", None),
+            // and starts on its own line below a quote left open
+            (
+                "attribute s = \"open\nattribute g : DurationValue = 5 [",
+                Some("attribute g : DurationValue "),
+            ),
+        ] {
+            assert_eq!(classify(text), Some(Ok(header)), "{text:?}");
+        }
+    }
+
+    #[test]
+    fn a_bracket_after_a_declaration_opens_a_multiplicity() {
+        for text in [
+            "part wheels : Wheel[",
+            "part wheels : Wheel [0..",
+            "part wheels [",
+            "attribute <m> mass [",
+            "attribute x : Real[0..1] = 5; part w : W [",
+            "connect [",
+            "first a then [",
+            "end [",
+            "attribute x = [",
+            // a declaration in a body passed as an argument
+            "attribute e = f({ in z : Real [",
+        ] {
+            assert_eq!(classify(text), Some(Err(())), "{text:?}");
+        }
+    }
+
+    /// Where [`super::untyped_attribute`] puts the typing of the
+    /// declaration before the end of `text`, spelled as what precedes it.
+    fn untyped(text: &str) -> Option<&str> {
+        let cx = completion_context(text, offset32(text.len()), Dialect::Sysml);
+        let (name_end, _) = super::untyped_attribute(text, &cx)?;
+        Some(&text[..name_end as usize])
+    }
+
+    #[test]
+    fn an_untyped_attribute_is_read_on_tokens() {
+        for (text, before) in [
+            ("attribute m = 5 [k", Some("attribute m")),
+            (
+                "attribute <m> 'the mass' [1] = 5 [",
+                Some("attribute <m> 'the mass'"),
+            ),
+            (
+                "doc /* the attribute of it */ attribute m = 5 [",
+                Some("doc /* the attribute of it */ attribute m"),
+            ),
+            ("attribute m : MassValue = 5 [", None),
+            ("attribute m :>> mass = 5 [", None),
+            ("attribute m redefines mass = 5 [", None),
+            ("attribute :>> mass = 5 [", None),
+            ("attribute redefines mass = 5 [", None),
+            ("attribute subsets mass = 5 [", None),
+            ("part p = 5 [", None),
+            ("attribute m [", None),
+            // the unit of an operand or an argument, not of the value
+            ("attribute m = -5 [", Some("attribute m")),
+            ("attribute d = v * 2 [", None),
+            ("attribute m = f(5 [", None),
+            ("attribute m = f({ in z; z }, 5 [", None),
+            // on its own line below a quote left open
+            (
+                "attribute s = \"open\nattribute m = 5 [",
+                Some("attribute s = \"open\nattribute m"),
+            ),
+        ] {
+            assert_eq!(untyped(text), before, "{text:?}");
+        }
+    }
+
+    /// A context spelled out: the operand, or the invoked name with the
+    /// argument's position and the parameter it names.
+    type Spelled<'a> = (&'a str, Option<(usize, Option<String>)>);
+
+    /// What [`super::unit_context`] reads before the end of `text`.
+    fn context(text: &str) -> Option<Spelled<'_>> {
+        let cx = completion_context(text, offset32(text.len()), Dialect::Sysml);
+        let spelled = |s: sysmlv2_parser::span::Span| &text[s.start as usize..s.end as usize];
+        Some(match super::unit_context(text, &cx)? {
+            super::Context::Operand(operand) => (spelled(operand), None),
+            super::Context::Argument {
+                callee,
+                position,
+                named,
+            } => (spelled(callee), Some((position, named))),
+        })
+    }
+
+    #[test]
+    fn a_unit_brackets_context_is_read_on_tokens() {
+        for (text, operand) in [
+            ("assert constraint { mass <= 1500 [", "mass"),
+            ("assert constraint { mass <= -1500 [", "mass"),
+            ("assert constraint { v.mass > 1.5e3 [", "v.mass"),
+            ("assert constraint { P::m == .5 [", "P::m"),
+            ("attribute w = 1200 [kg] + 300 [", "1200 [kg]"),
+            ("attribute t = total(parts).mass - 5 [", "total(parts).mass"),
+            ("attribute t = xs#(1) - 5 [", "xs#(1)"),
+            ("attribute t = (a + b) - 5 [", "(a + b)"),
+            ("assert constraint { m <= 5 [kg] and s < 30 [", "s"),
+        ] {
+            assert_eq!(context(text), Some((operand, None)), "{text:?}");
+        }
+        for (text, callee, position, named) in [
+            (
+                "attribute e = KineticEnergy(1500 [",
+                "KineticEnergy",
+                0,
+                None,
+            ),
+            (
+                "attribute e = Calcs::KineticEnergy(1500 [kg], 20 [",
+                "Calcs::KineticEnergy",
+                1,
+                None,
+            ),
+            ("attribute e = f(g(1, 2), (3), -4 [", "f", 2, None),
+            ("attribute e = v.energy(v = 20 [", "v.energy", 0, Some("v")),
+            ("attribute e = f(1, 'the v' = 20 [", "f", 1, Some("the v")),
+            ("attribute e = f({ in z; z }, 20 [", "f", 1, None),
+        ] {
+            let named = named.map(str::to_string);
+            assert_eq!(
+                context(text),
+                Some((callee, Some((position, named)))),
+                "{text:?}"
+            );
+        }
+        for text in [
+            // a declaration's value, a factor, an operand beside a factor
+            "attribute m : MassValue = 5 [",
+            "attribute p = mass * 2 [",
+            "assert constraint { 2 * mass <= 1500 [",
+            // an index, a group, a step after `->`, a sequence
+            "attribute e = xs#(3 [",
+            "attribute e = (1500 [",
+            "attribute e = xs->f(3 [",
+            "attribute e = (1, 2 [",
+        ] {
+            assert_eq!(context(text), None, "{text:?}");
+        }
+    }
+
+    #[test]
+    fn no_bracket_outside_one() {
+        for text in [
+            "attribute g = 9.8 [m] + ",
+            "attribute s = \"[",
+            "doc /* see [",
+            "attribute g = 9.8 [m;\n part p : ",
+        ] {
+            assert_eq!(classify(text), None, "{text:?}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-lsp/tests/extras.rs b/crates/sysmlv2-lsp/tests/extras.rs
index 49ff5f5..4f07171 100644
--- a/crates/sysmlv2-lsp/tests/extras.rs
+++ b/crates/sysmlv2-lsp/tests/extras.rs
@@ -112,39 +112,54 @@ impl Client {
     }
 }
 
+/// A statement's start takes keywords, a type position names: the
+/// part definition declared in another document.
 #[test]
-fn completion_offers_keywords_and_workspace_names() {
+fn completion_offers_keywords_and_names_by_position() {
     let mut client = Client::start();
     let defs = uri("defs.sysml");
     let u = uri("u.sysml");
     client.open(&defs, "package Defs { part def Wheel; }\n");
-    client.open(&u, "package U {\n    part w : \n}\n");
-
-    let resp = client.request_ok::<Completion>(CompletionParams {
-        text_document_position: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri: u },
-            position: Position {
-                line: 1,
-                character: 13,
+    client.open(&u, "package U {\n    part w : ;\n    \n}\n");
+    let mut complete = |line: u32, character: u32| {
+        let resp = client.request_ok::<Completion>(CompletionParams {
+            text_document_position: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri: u.clone() },
+                position: Position { line, character },
             },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-        partial_result_params: PartialResultParams::default(),
-        context: None,
-    });
-    let Some(CompletionResponse::Array(items)) = resp else {
-        panic!("expected items: {resp:?}");
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+            context: None,
+        });
+        let Some(CompletionResponse::Array(items)) = resp else {
+            panic!("expected items: {resp:?}");
+        };
+        items
     };
-    let part = items
-        .iter()
-        .find(|i| i.label == "part")
-        .expect("keyword `part`");
-    assert_eq!(part.kind, Some(CompletionItemKind::KEYWORD));
-    let wheel = items
+
+    let typed = complete(1, 13);
+    let wheel = typed
         .iter()
         .find(|i| i.label == "Wheel")
         .expect("cross-document name `Wheel`");
     assert_eq!(wheel.kind, Some(CompletionItemKind::CLASS));
+    assert!(
+        typed
+            .iter()
+            .all(|i| i.kind != Some(CompletionItemKind::KEYWORD)),
+        "no keyword at a type"
+    );
+
+    let start = complete(2, 4);
+    let part = start
+        .iter()
+        .find(|i| i.label == "part")
+        .expect("keyword `part`");
+    assert_eq!(part.kind, Some(CompletionItemKind::KEYWORD));
+    assert!(
+        start.iter().all(|i| i.label != "Wheel"),
+        "a statement's first word declares, it names nothing"
+    );
     client.shutdown();
 }
 
diff --git a/crates/sysmlv2-lsp/tests/library_signatures.rs b/crates/sysmlv2-lsp/tests/library_signatures.rs
new file mode 100644
index 0000000..6f0aa39
--- /dev/null
+++ b/crates/sysmlv2-lsp/tests/library_signatures.rs
@@ -0,0 +1,198 @@
+#![allow(clippy::mutable_key_type)] // lsp-types Uri map keys
+
+//! Signatures of the standard library's callables — in signature help
+//! and in hover — against the library itself.
+
+use lsp_server::{Connection, Message, Notification, Request, RequestId, Response};
+use lsp_types::notification::{DidOpenTextDocument, Exit, Initialized};
+use lsp_types::request::{HoverRequest, Initialize, Shutdown, SignatureHelpRequest};
+use lsp_types::{
+    DidOpenTextDocumentParams, HoverParams, InitializeParams, Position, SignatureHelpParams,
+    TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams, Uri,
+    WorkDoneProgressParams,
+};
+use std::str::FromStr;
+use std::thread::JoinHandle;
+
+struct Client {
+    conn: Connection,
+    server: Option<JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>>>,
+    next_id: i32,
+}
+
+fn uri(name: &str) -> Uri {
+    Uri::from_str(&format!("file:///w/{name}")).unwrap()
+}
+
+impl Client {
+    fn start() -> Client {
+        let (server_side, client_side) = Connection::memory();
+        let lib = sysmlv2_testkit::library_dir();
+        let server =
+            std::thread::spawn(move || sysmlv2_lsp::run_with_library(server_side, Some(lib)));
+        let mut c = Client {
+            conn: client_side,
+            server: Some(server),
+            next_id: 0,
+        };
+        let _: lsp_types::InitializeResult =
+            c.request_ok::<Initialize>(InitializeParams::default());
+        c.notify::<Initialized>(lsp_types::InitializedParams {});
+        c
+    }
+
+    fn request_ok<R: lsp_types::request::Request>(&mut self, params: R::Params) -> R::Result {
+        self.next_id += 1;
+        let id = RequestId::from(self.next_id);
+        self.conn
+            .sender
+            .send(Message::Request(Request::new(
+                id.clone(),
+                R::METHOD.to_string(),
+                params,
+            )))
+            .unwrap();
+        loop {
+            match self.conn.receiver.recv().unwrap() {
+                Message::Response(Response {
+                    id: rid,
+                    response_result,
+                }) if rid == id => {
+                    let (result, error) = match response_result {
+                        Ok(v) => (Some(v), None),
+                        Err(e) => (None, Some(e)),
+                    };
+                    assert!(error.is_none(), "{error:?}");
+                    return serde_json::from_value(result.unwrap_or_default()).unwrap();
+                }
+                _ => {}
+            }
+        }
+    }
+
+    fn notify<N: lsp_types::notification::Notification>(&self, params: N::Params) {
+        self.conn
+            .sender
+            .send(Message::Notification(Notification::new(
+                N::METHOD.to_string(),
+                params,
+            )))
+            .unwrap();
+    }
+
+    fn open(&self, uri: &Uri, text: &str) {
+        self.notify::<DidOpenTextDocument>(DidOpenTextDocumentParams {
+            text_document: TextDocumentItem {
+                uri: uri.clone(),
+                language_id: "sysml".to_string(),
+                version: 1,
+                text: text.to_string(),
+            },
+        });
+    }
+
+    fn shutdown(mut self) {
+        self.request_ok::<Shutdown>(());
+        self.notify::<Exit>(());
+        self.server
+            .take()
+            .unwrap()
+            .join()
+            .expect("server thread panicked")
+            .expect("server main loop errored");
+    }
+
+    /// The signature label signature help answers at the end of `line`
+    /// (0-based) of `uri`.
+    fn signature(&mut self, uri: &Uri, line: u32, character: u32) -> Option<String> {
+        let help = self.request_ok::<SignatureHelpRequest>(SignatureHelpParams {
+            context: None,
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri: uri.clone() },
+                position: Position { line, character },
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        });
+        help.map(|h| h.signatures[0].label.clone())
+    }
+
+    /// The signature line a hover at `line`/`character` leads with.
+    fn hover_signature(&mut self, uri: &Uri, line: u32, character: u32) -> Option<String> {
+        let hover = self.request_ok::<HoverRequest>(HoverParams {
+            text_document_position_params: TextDocumentPositionParams {
+                text_document: TextDocumentIdentifier { uri: uri.clone() },
+                position: Position { line, character },
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+        })?;
+        let lsp_types::HoverContents::Markup(m) = hover.contents else {
+            panic!("markup hover")
+        };
+        let body = m.value.strip_prefix("```sysml-signature\n")?;
+        Some(body[..body.find('\n')?].to_string())
+    }
+}
+
+/// A library callable's signature spells its types from the model —
+/// the library's text is not at hand to slice them from — the shortest
+/// way that resolves where the signature is read, with a multiplicity
+/// other than one: in signature help and hover alike.
+#[test]
+fn library_callables_spell_their_types_from_the_model() {
+    let mut client = Client::start();
+    let used = uri("used.sysml");
+    client.open(
+        &used,
+        "package P {\n    private import RealFunctions::*;\n    attribute a = sqrt(2.0);\n    \
+         attribute b = max(1.0, 2.0);\n    attribute c = RealFunctions::sum((1.0, 2.0));\n}\n",
+    );
+    // `Real` is visible through `RealFunctions`, which re-exports it.
+    for (line, character, label) in [
+        (2u32, 19u32, "sqrt(x: Real) → Real"),
+        (3, 19, "max(x: Real, y: Real) → Real"),
+        (4, 34, "sum(collection: Real[0..*]) → Real"),
+    ] {
+        assert_eq!(
+            client.hover_signature(&used, line, character).as_deref(),
+            Some(label)
+        );
+    }
+    let typed = uri("typed.sysml");
+    client.open(
+        &typed,
+        "package Q {\n    private import RealFunctions::*;\n    attribute d = sqrt(\n    \
+         attribute f = max(1.0, \n    attribute g = RealFunctions::sum(\n}\n",
+    );
+    for (line, character, label) in [
+        (2u32, 23u32, "sqrt(x: Real) → Real"),
+        (3, 27, "max(x: Real, y: Real) → Real"),
+        (4, 37, "sum(collection: Real[0..*]) → Real"),
+    ] {
+        assert_eq!(
+            client.signature(&typed, line, character).as_deref(),
+            Some(label)
+        );
+    }
+    // Where nothing makes `Real` visible, its package qualifies it.
+    for (name, text, character) in [
+        (
+            "bare.sysml",
+            "package R {\n    attribute d = RealFunctions::sqrt(\n}\n",
+            38u32,
+        ),
+        (
+            "bare.kerml",
+            "package S {\n    feature d = RealFunctions::sqrt(\n}\n",
+            36,
+        ),
+    ] {
+        let u = uri(name);
+        client.open(&u, text);
+        assert_eq!(
+            client.signature(&u, 1, character).as_deref(),
+            Some("sqrt(x: ScalarValues::Real) → ScalarValues::Real"),
+            "{name}"
+        );
+    }
+    client.shutdown();
+}
diff --git a/crates/sysmlv2-lsp/tests/nav.rs b/crates/sysmlv2-lsp/tests/nav.rs
index fb4b20f..462dac3 100644
--- a/crates/sysmlv2-lsp/tests/nav.rs
+++ b/crates/sysmlv2-lsp/tests/nav.rs
@@ -302,7 +302,7 @@ fn hover_chain_member_uses_the_receiver_context() {
     let u = uri("chain.sysml");
     client.open(
         &u,
-        "package T {\n    part def Vehicle {\n        attribute baseMass = 1000;\n        attribute total = baseMass + 100;\n    }\n    part car : Vehicle { attribute :>> baseMass = 1200; }\n    part garage { part slot : Vehicle { attribute :>> baseMass = 2000; } }\n    attribute carTotal = car.total;\n    attribute deep = garage.slot.total;\n}\n",
+        "package T {\n    part def Vehicle {\n        attribute baseMass = 1000;\n        attribute total = baseMass + 100;\n    }\n    part car : Vehicle[1] { attribute :>> baseMass = 1200; }\n    part garage[1] { part slot : Vehicle { attribute :>> baseMass = 2000; } }\n    attribute carTotal = car.total;\n    attribute deep = garage.slot.total;\n}\n",
     );
     let hover_value = |client: &mut Client, line: u32, character: u32| {
         let hover: Option<Hover> = client.request_ok::<HoverRequest>(HoverParams {
@@ -368,6 +368,36 @@ fn hover_shows_calc_def_signature() {
     client.shutdown();
 }
 
+/// A callable's hover signature lists the parameters it inherits after
+/// its own: a definition specializing another, a usage typed by one.
+#[test]
+fn hover_signature_lists_inherited_parameters() {
+    let mut client = Client::start();
+    let u = uri("i.sysml");
+    client.open(
+        &u,
+        "package P {\n    attribute def Mass;\n    attribute def Speed;\n    attribute def Energy;\n    calc def KineticEnergy { in m : Mass; in v : Speed; return : Energy; }\n    calc def KE2 :> KineticEnergy;\n    calc ke2 : KE2;\n}\n",
+    );
+    for (line, character, sig) in [
+        (5, 13, "KE2(m: Mass, v: Speed) → Energy"),
+        (6, 9, "ke2(m: Mass, v: Speed) → Energy"),
+    ] {
+        let hover: Option<Hover> = client.request_ok::<HoverRequest>(HoverParams {
+            text_document_position_params: Client::pos_params(&u, line, character),
+            work_done_progress_params: Default::default(),
+        });
+        let lsp_types::HoverContents::Markup(m) = hover.expect("hover").contents else {
+            panic!("expected markup");
+        };
+        assert!(
+            m.value.contains(&format!("```sysml-signature\n{sig}\n```")),
+            "{}",
+            m.value
+        );
+    }
+    client.shutdown();
+}
+
 /// Parameters declared by subsetting/redefinition (`in g0 :>
 /// ISQ::acceleration` — the common quantity-parameter spelling) type
 /// the signature by their subsetted feature; same for the return side.
diff --git a/crates/sysmlv2-lsp/tests/tokens_corpus.rs b/crates/sysmlv2-lsp/tests/tokens_corpus.rs
index dab3502..900d542 100644
--- a/crates/sysmlv2-lsp/tests/tokens_corpus.rs
+++ b/crates/sysmlv2-lsp/tests/tokens_corpus.rs
@@ -2,7 +2,8 @@
 //!
 //! 1. The keyword vocabulary is *generated* from the vendored normative
 //!    grammars — this test regenerates it and compares, so grammar bumps
-//!    cannot silently drift the highlighting.
+//!    cannot silently drift the highlighting — and each dialect's share
+//!    of it is its own grammar's words, which completion offers.
 //! 2. The corpus sweep is the completeness oracle: in a clean-parsing
 //!    file every `Ident` token is either a recorded name or a keyword,
 //!    so an unclassified `Ident` means a vocabulary gap or a name span
@@ -12,13 +13,14 @@
 use std::collections::BTreeSet;
 use sysmlv2_lsp::tokens;
 use sysmlv2_lsp::{Encoding, Mapper};
+use sysmlv2_parser::ast::Dialect;
 use sysmlv2_parser::parser::{parse_kerml_source, parse_source};
 
-#[test]
-fn vocabulary_matches_the_grammars() {
+/// The word-shaped terminals of the named vendored grammars.
+fn grammar_words(grammars: &[&str]) -> BTreeSet<String> {
     let specs = sysmlv2_testkit::workspace_root().join("spec-refs");
     let mut words = BTreeSet::new();
-    for grammar in ["KerML.xtext", "SysML.xtext", "KerMLExpressions.xtext"] {
+    for grammar in grammars {
         let text = std::fs::read_to_string(specs.join(grammar))
             .unwrap_or_else(|e| panic!("{grammar}: {e} (vendored grammar missing?)"));
         let bytes = text.as_bytes();
@@ -40,6 +42,12 @@ fn vocabulary_matches_the_grammars() {
             i += 1;
         }
     }
+    words
+}
+
+#[test]
+fn vocabulary_matches_the_grammars() {
+    let words = grammar_words(&["KerML.xtext", "SysML.xtext", "KerMLExpressions.xtext"]);
     let generated: Vec<&str> = words.iter().map(|s| s.as_str()).collect();
     assert_eq!(
         tokens::VOCABULARY,
@@ -48,6 +56,33 @@ fn vocabulary_matches_the_grammars() {
     );
 }
 
+/// Each dialect's keywords are its own grammar's words and the shared
+/// expression grammar's — no more: completion offers a `.sysml` file
+/// no KerML-only word and a `.kerml` file no SysML-only one.
+#[test]
+fn keywords_split_by_grammar() {
+    for (dialect, grammar) in [
+        (Dialect::Sysml, "SysML.xtext"),
+        (Dialect::Kerml, "KerML.xtext"),
+    ] {
+        let words = grammar_words(&[grammar, "KerMLExpressions.xtext"]);
+        let generated: Vec<&str> = words.iter().map(|s| s.as_str()).collect();
+        let split: Vec<&str> = tokens::keywords(dialect).collect();
+        assert_eq!(
+            split, generated,
+            "{dialect:?} keywords drifted from {grammar}"
+        );
+    }
+    let sysml: Vec<&str> = tokens::keywords(Dialect::Sysml).collect();
+    let kerml: Vec<&str> = tokens::keywords(Dialect::Kerml).collect();
+    for word in ["const", "datatype", "featuring"] {
+        assert!(!sysml.contains(&word) && kerml.contains(&word), "{word}");
+    }
+    for word in ["part", "parallel", "calc"] {
+        assert!(sysml.contains(&word) && !kerml.contains(&word), "{word}");
+    }
+}
+
 #[test]
 fn corpus_idents_all_classify() {
     let mut files = 0usize;
diff --git a/crates/sysmlv2-lsp/tests/unit_typing.rs b/crates/sysmlv2-lsp/tests/unit_typing.rs
index 452e4a8..2343e50 100644
--- a/crates/sysmlv2-lsp/tests/unit_typing.rs
+++ b/crates/sysmlv2-lsp/tests/unit_typing.rs
@@ -1,9 +1,13 @@
 #![allow(clippy::mutable_key_type)] // lsp-types Uri map keys
 
-//! Unit-completion typing (the `inferUnitTypes` behavior): accepting a
-//! unit completion inside an untyped attribute's quantity bracket also
-//! declares the type the unit determines — exactly one, spelled
-//! shortest-that-resolves — and the initialization option turns it off.
+//! Completions against the standard library. Typing (the
+//! `inferUnitTypes` behavior): accepting a unit completion inside an
+//! untyped attribute's quantity bracket also declares the type the unit
+//! determines — exactly one, spelled shortest-that-resolves — and the
+//! initialization option turns it off. Placement: multi-word unit names
+//! are offered inside a bracket and nowhere else. Names: the library's
+//! own imports and its operator functions are never offered as bare
+//! names.
 
 use lsp_server::{Connection, Message, Notification, Request, RequestId, Response};
 use lsp_types::notification::{DidOpenTextDocument, Exit, Initialized};
@@ -110,7 +114,20 @@ fn complete(
     line: u32,
     character: u32,
 ) -> Vec<lsp_types::CompletionItem> {
-    let resp = client.request_ok::<Completion>(CompletionParams {
+    match completion(client, uri, line, character) {
+        Some(CompletionResponse::Array(items)) => items,
+        Some(CompletionResponse::List(list)) => list.items,
+        None => panic!("expected items"),
+    }
+}
+
+fn completion(
+    client: &mut Client,
+    uri: &Uri,
+    line: u32,
+    character: u32,
+) -> Option<CompletionResponse> {
+    client.request_ok::<Completion>(CompletionParams {
         text_document_position: TextDocumentPositionParams {
             text_document: TextDocumentIdentifier { uri: uri.clone() },
             position: Position { line, character },
@@ -118,11 +135,934 @@ fn complete(
         work_done_progress_params: WorkDoneProgressParams::default(),
         partial_result_params: PartialResultParams::default(),
         context: None,
-    });
-    match resp {
-        Some(CompletionResponse::Array(items)) => items,
-        other => panic!("expected items: {other:?}"),
+    })
+}
+
+/// Multi-word unit names (`'atomic mass unit'`) complete inside a
+/// quantity bracket and nowhere else: at a type position they would be
+/// noise, some 380 labels in every response.
+#[test]
+fn multiword_unit_names_only_inside_brackets() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("m.sysml");
+    client.open(
+        &u,
+        "package M {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         attribute x : \n    attribute y = 5 [\n}\n",
+    );
+    // After `attribute x : ` on line 3.
+    let typed = complete(&mut client, &u, 3, 18);
+    assert!(
+        typed.iter().any(|i| i.label == "MassValue"),
+        "types offered"
+    );
+    let spaced: Vec<&str> = typed
+        .iter()
+        .map(|i| i.label.as_str())
+        .filter(|l| l.chars().any(char::is_whitespace))
+        .collect();
+    assert!(spaced.is_empty(), "multi-word labels at a type: {spaced:?}");
+    // After `attribute y = 5 [` on line 4.
+    let bracket = complete(&mut client, &u, 4, 21);
+    let labels: Vec<&str> = bracket.iter().map(|i| i.label.as_str()).collect();
+    assert!(
+        labels.contains(&"atomic mass unit"),
+        "long name in a bracket"
+    );
+    assert!(labels.contains(&"u"), "its short symbol too");
+    client.shutdown();
+}
+
+/// The library's own imports (`private import SI::m;` in a shape
+/// package) declare nothing: no label is an import path, an import is
+/// no member of the importing package, and a document's own
+/// `import ISQ::*` does not stand in for the package it names.
+#[test]
+fn library_imports_are_not_names() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("n.sysml");
+    client.open(
+        &u,
+        "package N {\n    private import ISQ::*;\n    attribute x : \n    attribute y : ISQ::\n}\n",
+    );
+    // After `attribute x : ` on line 2.
+    let flat = complete(&mut client, &u, 2, 18);
+    let paths: Vec<&str> = flat
+        .iter()
+        .map(|i| i.label.as_str())
+        .filter(|l| l.contains("::"))
+        .collect();
+    assert!(paths.is_empty(), "import paths offered as names: {paths:?}");
+    let isq = flat.iter().find(|i| i.label == "ISQ").expect("ISQ offered");
+    assert_eq!(isq.detail.as_deref(), Some("standard library"));
+    // After `attribute y : ISQ::` on line 3: members of ISQ, and none
+    // of the packages it imports.
+    let members = complete(&mut client, &u, 3, 23);
+    let labels: Vec<&str> = members.iter().map(|i| i.label.as_str()).collect();
+    assert!(labels.contains(&"TemperatureDifferenceValue"), "{labels:?}");
+    for import in [
+        "ScalarValues::Real",
+        "Quantities",
+        "ISQBase",
+        "ISQMechanics",
+    ] {
+        assert!(
+            !labels.contains(&import),
+            "import `{import}` listed as a member"
+        );
     }
+    client.shutdown();
+}
+
+/// Operator functions are written as operators, not names: the flat
+/// list offers none of the library's (`'+'`, `'['`, `'..'`, `'not'`),
+/// while functions with plain names stay, and the units and aliases
+/// spelled with symbols (`'°C'`, `'m/s²'`) are no operators: a unit
+/// bracket offers them, though an operand outside one does not.
+#[test]
+fn library_operator_functions_are_not_names() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("o.sysml");
+    client.open(
+        &u,
+        "package O {\n    attribute x = \n    attribute y = 5 [\n}\n",
+    );
+    // After `attribute x = ` on line 1.
+    let flat = complete(&mut client, &u, 1, 18);
+    // Names only: the word operators are keywords too.
+    let labels: Vec<&str> = flat
+        .iter()
+        .filter(|i| i.kind != Some(lsp_types::CompletionItemKind::KEYWORD))
+        .map(|i| i.label.as_str())
+        .collect();
+    for op in [
+        "!=", "!==", "#", "%", "&", "*", "**", "+", ",", "-", ".", "..", "/", "<", "<=", "==",
+        "===", ">", ">=", "??", "@", "@@", "[", "^", "|", "~", "all", "and", "as", "hastype", "if",
+        "implies", "istype", "meta", "not", "or", "xor",
+    ] {
+        assert!(!labels.contains(&op), "operator `{op}` offered");
+    }
+    assert!(labels.contains(&"sqrt"), "`sqrt` missing");
+    // After `attribute y = 5 [` on line 2.
+    let bracket = complete(&mut client, &u, 2, 21);
+    let labels: Vec<&str> = bracket.iter().map(|i| i.label.as_str()).collect();
+    for name in ["°C", "m/s", "m/s²"] {
+        assert!(labels.contains(&name), "`{name}` missing");
+    }
+    client.shutdown();
+}
+
+/// The labels in the order a client lists them: by sort text.
+fn listed(mut items: Vec<lsp_types::CompletionItem>) -> Vec<String> {
+    items.sort_by(|a, b| a.sort_text.cmp(&b.sort_text));
+    items.into_iter().map(|i| i.label).collect()
+}
+
+/// In a quantity's unit bracket the units of the quantity the value is
+/// declared as come first, short symbols ahead of long names, and the
+/// list holds units only: narrowing a duration to `mi` meets the minute
+/// before the mile, a mass narrowed to `k` meets the kilogram before
+/// the kelvin.
+#[test]
+fn unit_brackets_offer_the_declared_quantitys_units_first() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("d.sysml");
+    client.open(
+        &u,
+        "package D {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         attribute g : ISQ::DurationValue = 5.5 [\n}\n",
+    );
+    // After `= 5.5 [` on line 3.
+    let labels = listed(complete(&mut client, &u, 3, 44));
+    assert_eq!(
+        labels[..8],
+        ["s", "d", "h", "min", "second", "day", "hour", "minute"],
+        "{labels:?}"
+    );
+    let mi: Vec<&str> = labels
+        .iter()
+        .map(String::as_str)
+        .filter(|l| l.starts_with("mi"))
+        .collect();
+    assert_eq!(mi[..2], ["min", "minute"], "{mi:?}");
+    assert!(mi.contains(&"mi"), "the mile stays reachable: {mi:?}");
+    for other in ["part", "attribute", "MassValue", "DurationValue"] {
+        assert!(!labels.iter().any(|l| l == other), "{other} offered");
+    }
+    let u = uri("m.sysml");
+    client.open(
+        &u,
+        "package M {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         attribute m : MassValue = 5 [k\n}\n",
+    );
+    // After `= 5 [k` on line 3.
+    let labels = listed(complete(&mut client, &u, 3, 34));
+    let k: Vec<&str> = labels
+        .iter()
+        .map(String::as_str)
+        .filter(|l| l.to_lowercase().starts_with('k'))
+        .collect();
+    assert_eq!(k[..2], ["kg", "kilogram"], "{k:?}");
+    client.shutdown();
+}
+
+/// A redefinition's value measures the quantity of the feature it
+/// redefines; a multiplicity offers nothing.
+#[test]
+fn redefinitions_take_their_features_units_and_multiplicities_none() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("v.sysml");
+    client.open(
+        &u,
+        "package V {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         part def Vehicle { attribute mass : MassValue; }\n    part v : Vehicle {\n        \
+         attribute :>> mass = 1500 [\n    }\n    part def Wheel;\n    part wheels : Wheel [\n}\n",
+    );
+    // After `= 1500 [` on line 5.
+    let labels = listed(complete(&mut client, &u, 5, 35));
+    let at = |label: &str| {
+        labels
+            .iter()
+            .position(|l| l == label)
+            .unwrap_or_else(|| panic!("{label} not offered: {labels:?}"))
+    };
+    assert!(at("kg") < at("s") && at("kg") < at("K"), "{labels:?}");
+    assert!(at("kilogram") < at("s"), "{labels:?}");
+    // After `part wheels : Wheel [` on line 8.
+    let items = complete(&mut client, &u, 8, 25);
+    assert!(items.is_empty(), "{:?}", listed(items));
+    client.shutdown();
+}
+
+/// The declared quantity also comes from the parameter a directed
+/// usage redefines by name and from a type the model specializes from a
+/// quantity; a factor of a compound unit is not ordered by it.
+#[test]
+fn parameters_user_types_and_factors() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("p.sysml");
+    client.open(
+        &u,
+        "package P {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         constraint def MassLimit { in mass : MassValue; in limit : MassValue; mass <= limit }\n    \
+         attribute def Speed :> SpeedValue;\n    part def V {\n        \
+         assert constraint c : MassLimit { in limit = 2000 [kg]; }\n        \
+         attribute s : Speed = 5 [m/s];\n        \
+         attribute f : SpeedValue = 5 [m*s];\n    }\n}\n",
+    );
+    let at = |labels: &[String], label: &str| {
+        labels
+            .iter()
+            .position(|l| l == label)
+            .unwrap_or_else(|| panic!("{label} not offered: {labels:?}"))
+    };
+    // After `in limit = 2000 [` on line 6: mass first.
+    let labels = listed(complete(&mut client, &u, 6, 59));
+    assert!(at(&labels, "kg") < at(&labels, "m"), "{labels:?}");
+    // After `s : Speed = 5 [` on line 7: speed first.
+    let labels = listed(complete(&mut client, &u, 7, 33));
+    assert!(at(&labels, "m/s") < at(&labels, "g"), "{labels:?}");
+    // After `[m*` on line 8: a factor, in the library's order.
+    let labels = listed(complete(&mut client, &u, 8, 40));
+    assert!(at(&labels, "g") < at(&labels, "m/s"), "{labels:?}");
+    client.shutdown();
+}
+
+/// Where the bracket annotates no declaration's whole value, the
+/// quantity comes from its context: the left operand of a comparison or
+/// a sum it is the right operand of — a feature, or a value carrying a
+/// unit — or the parameter an argument binds, by its position among the
+/// inputs or by name, of a calculation definition, one it specializes, or
+/// a usage it types.
+/// A factor's quantity is not the product's: it takes the list a
+/// bracket without a quantity takes.
+#[test]
+fn unit_brackets_take_the_quantity_of_their_context() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let prelude = "package K {\n    private import ISQ::*;\n    private import SI::*;\n    \
+                   calc def KineticEnergy { in m : MassValue; in v : SpeedValue; return : EnergyValue; }\n    \
+                   calc def KE2 :> KineticEnergy; calc def KE3 :> KineticEnergy { in speed redefines v; } \
+                   calc def KE5 :> KineticEnergy { in mass : MassValue; } \
+                   calc def KE8 :> KineticEnergy { in :>> m; } \
+                   calc def Mixed { out o : EnergyValue; in m : MassValue; in v : SpeedValue; }\n    \
+                   part def Vehicle {\n        attribute mass : MassValue;\n        \
+                   calc ke : KineticEnergy;\n        calc ke2 : KE2;\n        ";
+    let labels = |client: &mut Client, i: usize, statement: &str| {
+        let u = uri(&format!("c{i}.sysml"));
+        client.open(&u, &format!("{prelude}{statement}\n    }}\n}}\n"));
+        // After the statement on line 9.
+        let at = u32::try_from(8 + statement.len()).unwrap();
+        listed(complete(client, &u, 9, at))
+    };
+    let at = |labels: &[String], label: &str| {
+        labels
+            .iter()
+            .position(|l| l == label)
+            .unwrap_or_else(|| panic!("{label} not offered: {labels:?}"))
+    };
+    for (i, (statement, first, then)) in [
+        ("assert constraint { mass <= 1500 [", "kg", "m"),
+        ("assert constraint { mass <= -1500 [", "kg", "m"),
+        ("attribute e = KineticEnergy(1500 [", "kg", "m"),
+        ("attribute e = KineticEnergy(1500 [kg], 20 [", "m/s", "g"),
+        ("attribute e = KineticEnergy(v = 20 [", "m/s", "g"),
+        ("attribute e = ke(1500 [", "kg", "m"),
+        ("attribute e = KE2(1500 [", "kg", "m"),
+        ("attribute e = KE2(v = 20 [", "m/s", "g"),
+        ("attribute e = ke2(1500 [kg], 20 [", "m/s", "g"),
+        // Its own first, then the inherited, but for what they redefine:
+        // explicitly, and by position.
+        ("attribute e = KE3(1500 [", "m/s", "g"),
+        ("attribute e = KE5(1500 [kg], 20 [", "m/s", "g"),
+        // Only redefining, it measures what it redefines.
+        ("attribute e = KE8(1500 [", "kg", "m"),
+        // Arguments bind inputs: the output declared first takes none.
+        ("attribute e = Mixed(1500 [", "kg", "J"),
+        ("attribute e = Mixed(1500 [kg], 20 [", "m/s", "kg"),
+        ("attribute w = 1200 [kg] + 300 [", "kg", "m"),
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let labels = labels(&mut client, i, statement);
+        let head = &labels[..labels.len().min(12)];
+        assert!(
+            at(&labels, first) < at(&labels, then),
+            "{statement}: {head:?}"
+        );
+    }
+    let plain = labels(&mut client, 100, "attribute x = 1500 [");
+    for (i, statement) in [
+        "assert constraint { 2 * mass <= 1500 [",
+        "attribute p = mass * 2 [",
+        // no parameter left to bind: the result is none
+        "attribute e = KineticEnergy(1500 [kg], 20 [m/s], 3 [",
+        "attribute e = KE5(1500 [kg], 20 [m/s], 3 [",
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        assert_eq!(
+            labels(&mut client, 200 + i, statement),
+            plain,
+            "{statement}"
+        );
+    }
+    client.shutdown();
+}
+
+/// A KerML function specializing another binds each argument to one
+/// parameter: its own take the place of the same-named ones it
+/// inherits, so an argument past them binds none.
+#[test]
+fn a_kerml_functions_arguments_bind_its_parameters_once() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let labels = |client: &mut Client, name: &str, statement: &str| {
+        let u = uri(name);
+        client.open(
+            &u,
+            &format!(
+                "package F {{\n    private import ISQ::*;\n    private import SI::*;\n    \
+                 function Energy {{ in m : MassValue; in v : SpeedValue; return : EnergyValue; }}\n    \
+                 function Again specializes Energy {{ in m : MassValue; in v : SpeedValue; }}\n    \
+                 {statement}\n}}\n"
+            ),
+        );
+        // After the statement on line 5.
+        let at = u32::try_from(4 + statement.len()).unwrap();
+        listed(complete(client, &u, 5, at))
+    };
+    let at = |labels: &[String], label: &str| {
+        labels
+            .iter()
+            .position(|l| l == label)
+            .unwrap_or_else(|| panic!("{label} not offered: {labels:?}"))
+    };
+    let second = labels(
+        &mut client,
+        "second.kerml",
+        "feature e = Again(1500 [kg], 20 [",
+    );
+    assert!(at(&second, "m/s") < at(&second, "g"), "{:?}", &second[..8]);
+    let plain = labels(&mut client, "plain.kerml", "feature x = 1500 [");
+    assert_eq!(
+        labels(
+            &mut client,
+            "third.kerml",
+            "feature e = Again(1500 [kg], 20 [m/s], 3 ["
+        ),
+        plain
+    );
+    client.shutdown();
+}
+
+/// A reading on a scale — a time instant — is compared with or moved by
+/// a difference, which the scale's unit measures: the scale's own
+/// references (`UTC`) do not lead the list, and a unit's symbol typed
+/// whole keeps its whole match (`d` is the day, not the decibel's `dB`).
+#[test]
+fn a_scale_reading_names_no_quantity_for_its_difference() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("t.sysml");
+    client.open(
+        &u,
+        "package T {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         private import Time::*;\n    part def P {\n        attribute t1 : TimeInstantValue;\n        \
+         attribute t2 = t1 + 5 [\n    }\n}\n",
+    );
+    // After `t1 + 5 [` on line 6.
+    let items = complete(&mut client, &u, 6, 31);
+    let d = items.iter().find(|i| i.label == "d").expect("`d` offered");
+    assert_eq!(d.filter_text, None, "{d:?}");
+    let labels = listed(items);
+    let at = |label: &str| labels.iter().position(|l| l == label).unwrap_or(usize::MAX);
+    assert!(at("s") < at("UTC"), "{:?}", &labels[..8]);
+    // A reading written on the scale itself.
+    let u = uri("t2.sysml");
+    client.open(
+        &u,
+        "package T {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         private import Time::*;\n    attribute t = 5 [UTC] + 3 [\n}\n",
+    );
+    // After `5 [UTC] + 3 [` on line 4.
+    let labels = listed(complete(&mut client, &u, 4, 31));
+    let at = |label: &str| labels.iter().position(|l| l == label).unwrap_or(usize::MAX);
+    assert!(at("s") < at("UTC"), "{:?}", &labels[..8]);
+    client.shutdown();
+}
+
+/// A unit an operand carries that is typed by one of the library's
+/// general references alone — any simple unit — names no quantity: the
+/// units of that kind do not all fit it, and the newton's `N`, a derived
+/// unit, keeps its place and its whole match.
+#[test]
+fn a_unit_typed_by_a_general_reference_names_no_quantity() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("g.sysml");
+    client.open(
+        &u,
+        "package G {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         private import MeasurementReferences::*;\n    attribute <gp> genericUnit : SimpleUnit;\n    \
+         attribute x = 5 [gp] + 3 [\n}\n",
+    );
+    // After `5 [gp] + 3 [` on line 5.
+    let items = complete(&mut client, &u, 5, 30);
+    let n = items.iter().find(|i| i.label == "N").expect("`N` offered");
+    assert_eq!(n.filter_text, None, "{n:?}");
+    let labels = listed(items);
+    let at = |label: &str| labels.iter().position(|l| l == label).unwrap_or(usize::MAX);
+    assert!(at("N") < at("nm"), "{:?}", &labels[..8]);
+    client.shutdown();
+}
+
+/// A unit fits the declared quantity when it is typed by the quantity's
+/// measurement reference, even where no dimension can be computed for
+/// it: a unit of a quantity the model defines on a base quantity of its
+/// own, a vector's coordinate frame — and so does the quantity of a unit
+/// an operand carries.
+#[test]
+fn units_typed_by_the_quantitys_reference_fit_it() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let currency = |i: usize, value: &str| {
+        format!(
+            "package C{i} {{\n    private import ISQ::*;\n    private import SI::*;\n    \
+             private import Quantities::*;\n    private import MeasurementReferences::*;\n    \
+             attribute def CurrencyUnit :> SimpleUnit {{\n        \
+             private attribute pf : QuantityPowerFactor[1] {{ :>> quantity = Currency; :>> exponent = 1; }}\n        \
+             attribute :>> quantityDimension {{ :>> quantityPowerFactors = pf; }}\n    }}\n    \
+             attribute def CurrencyValue :> ScalarQuantityValue {{ attribute :>> num : Real; attribute :>> mRef : CurrencyUnit[1]; }}\n    \
+             attribute Currency : CurrencyValue[1];\n    \
+             attribute <km2> kilometreSquared : AreaUnit;\n    \
+             attribute <'$'> dollar : CurrencyUnit;\n    \
+             {value}\n}}\n"
+        )
+    };
+    for (i, value) in [
+        "attribute cost : CurrencyValue = 5 [",
+        "attribute total = 5 ['$'] + 3 [",
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let u = uri(&format!("c{i}.sysml"));
+        client.open(&u, &currency(i, value));
+        // After the value on line 13.
+        let at = u32::try_from(4 + value.len()).unwrap();
+        let labels = listed(complete(&mut client, &u, 13, at));
+        assert_eq!(
+            labels.first().map(String::as_str),
+            Some("$"),
+            "{value}: {labels:?}"
+        );
+    }
+    let u = uri("v.sysml");
+    client.open(
+        &u,
+        "package V {\n    private import ISQ::*;\n    private import ISQSpaceTime::*;\n    \
+         attribute p : CartesianPosition3dVector = (1, 2, 3) [\n}\n",
+    );
+    // After `(1, 2, 3) [` on line 3.
+    let labels = listed(complete(&mut client, &u, 3, 57));
+    assert_eq!(
+        labels.first().map(String::as_str),
+        Some("universalCartesianSpatial3dCoordinateFrame"),
+        "{labels:?}"
+    );
+    // A frame an operand carries: a library frame of its own kind, not
+    // one of the general references.
+    let u = uri("w.sysml");
+    let value =
+        "attribute p = (1, 2, 3) [universalCartesianSpatial3dCoordinateFrame] + (4, 5, 6) [";
+    client.open(
+        &u,
+        &format!(
+            "package W {{\n    private import ISQ::*;\n    private import ISQSpaceTime::*;\n    {value}\n}}\n"
+        ),
+    );
+    // After the value on line 3.
+    let at = u32::try_from(4 + value.len()).unwrap();
+    let labels = listed(complete(&mut client, &u, 3, at));
+    assert_eq!(
+        labels.first().map(String::as_str),
+        Some("universalCartesianSpatial3dCoordinateFrame"),
+        "{:?}",
+        &labels[..labels.len().min(8)]
+    );
+    client.shutdown();
+}
+
+/// A `doc` or a comment ahead of the declaration — it ends with no
+/// `;`, so the statement's tokens start with it — does not hide the
+/// declared quantity.
+#[test]
+fn a_comment_ahead_of_the_declaration_keeps_its_quantity() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("d.sysml");
+    client.open(
+        &u,
+        "package D {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         part def V {\n        doc /* A vehicle. */\n        attribute m : MassValue = 5 [kg];\n    }\n    \
+         part v : V {\n        comment c /* a note */\n        attribute redefines m = 7 [kg];\n    }\n}\n",
+    );
+    // Right after `= 5 [` on line 5, then `= 7 [` on line 9.
+    for (line, character) in [(5, 37), (9, 35)] {
+        let labels = listed(complete(&mut client, &u, line, character));
+        let at = |label: &str| labels.iter().position(|l| l == label).unwrap_or(usize::MAX);
+        assert!(at("kg") < at("m") && at("kg") < at("s"), "{labels:?}");
+    }
+    client.shutdown();
+}
+
+/// The untyped attribute a unit completion declares the type of is read
+/// on the document's tokens: the words of a comment ahead of it do not
+/// count, and the typing lands after the declared name.
+#[test]
+fn the_inferred_typing_lands_after_the_declared_name() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("n.sysml");
+    client.open(
+        &u,
+        "package G {\n    private import ISQ::*;\n    private import SI::*;\n    part def P {\n        \
+         doc /* the attribute of it */\n        attribute m = 5 [k\n    }\n}\n",
+    );
+    // After `= 5 [k` on line 5.
+    let items = complete(&mut client, &u, 5, 26);
+    let kg = items.iter().find(|i| i.label == "kg").expect("`kg` item");
+    let typing = kg
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .find(|e| e.new_text == " : MassValue")
+        .unwrap_or_else(|| panic!("{:?}", kg.additional_text_edits));
+    // Right after `attribute m`, not in the comment above.
+    assert_eq!(
+        typing.range.start,
+        Position {
+            line: 5,
+            character: 19
+        }
+    );
+    client.shutdown();
+}
+
+/// A qualifier offers what the namespace re-exports: `ISQ` publicly
+/// imports its part packages (`ISQBase::*`, …), so `ISQ::MassValue` —
+/// the conventional spelling — completes, and `SI`, which re-exports
+/// `ISQ` and the unit prefixes, offers quantities and prefixes beside
+/// its own units.
+#[test]
+fn qualifiers_offer_re_exported_members() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("q.sysml");
+    client.open(
+        &u,
+        "package Q {\n    attribute x : ISQ::\n    attribute y : SI::\n}\n",
+    );
+    let detail = |items: &[lsp_types::CompletionItem], label: &str| -> Option<String> {
+        items
+            .iter()
+            .find(|i| i.label == label)
+            .and_then(|i| i.detail.clone())
+    };
+    // After `attribute x : ISQ::` on line 1.
+    let isq = complete(&mut client, &u, 1, 23);
+    assert_eq!(
+        detail(&isq, "MassValue").as_deref(),
+        Some("ISQBase::MassValue")
+    );
+    assert_eq!(
+        detail(&isq, "LengthValue").as_deref(),
+        Some("ISQBase::LengthValue")
+    );
+    assert!(detail(&isq, "TemperatureDifferenceValue").is_some());
+    // After `attribute y : SI::` on line 2.
+    let si = complete(&mut client, &u, 2, 22);
+    assert_eq!(detail(&si, "kg").as_deref(), Some("SI::kg"));
+    assert_eq!(
+        detail(&si, "MassValue").as_deref(),
+        Some("ISQBase::MassValue")
+    );
+    assert_eq!(detail(&si, "kilo").as_deref(), Some("SIPrefixes::kilo"));
+    client.shutdown();
+}
+
+/// `import ISQ::*;` makes `MassValue` visible — `ISQ` re-exports
+/// `ISQBase` — so accepting it adds no import, while `Real`, which
+/// `ISQ` imports only privately, still brings its own.
+#[test]
+fn a_facade_import_admits_what_it_re_exports() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("a.sysml");
+    client.open(
+        &u,
+        "package A {\n    private import ISQ::*;\n    attribute m : \n}\n",
+    );
+    // After `attribute m : ` on line 2.
+    let items = complete(&mut client, &u, 2, 18);
+    let edits = |label: &str| {
+        items
+            .iter()
+            .find(|i| i.label == label)
+            .unwrap_or_else(|| panic!("`{label}` offered"))
+            .additional_text_edits
+            .clone()
+    };
+    assert_eq!(edits("MassValue"), None);
+    assert_eq!(edits("TemperatureDifferenceValue"), None);
+    let real = edits("Real").expect("an import for `Real`");
+    assert!(
+        real[0].new_text.contains("import ScalarValues::Real;"),
+        "{real:?}"
+    );
+    client.shutdown();
+}
+
+/// Inside a unit bracket too, an existing import admits what the
+/// imported package re-exports: `Units` re-exports `SI`, so after
+/// `import Units::*;` accepting `kg` needs no import of its own.
+#[test]
+fn unit_brackets_admit_what_an_import_re_exports() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("u.sysml");
+    client.open(
+        &u,
+        "package Units {\n    public import SI::*;\n}\npackage P {\n    private import ISQ::*;\n    \
+         private import Units::*;\n    attribute m : MassValue = 5 [k\n}\n",
+    );
+    // After `[k` on line 6.
+    let items = complete(&mut client, &u, 6, 34);
+    let kg = items
+        .iter()
+        .find(|i| i.label == "kg")
+        .expect("`kg` offered");
+    let imports: Vec<&str> = kg
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .map(|e| e.new_text.as_str())
+        .filter(|t| t.contains("import"))
+        .collect();
+    assert!(imports.is_empty(), "{imports:?}");
+    client.shutdown();
+}
+
+/// Inserted imports name the conventional path: `ISQ::MassValue`, not
+/// the part package that declares it (`ISQBase`), while a type that
+/// only function packages re-export keeps its own (`ScalarValues::Real`).
+/// Completion's auto-import, import-path completion, and the
+/// "Add import" fix agree.
+#[test]
+fn imports_name_the_conventional_path() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("c.sysml");
+    client.open(
+        &u,
+        "package C {\n    attribute m : \n    private import MassV\n}\n",
+    );
+    // After `attribute m : ` on line 1.
+    let items = complete(&mut client, &u, 1, 18);
+    let import = |label: &str| -> String {
+        let item = items
+            .iter()
+            .find(|i| i.label == label)
+            .unwrap_or_else(|| panic!("`{label}` offered"));
+        item.additional_text_edits.as_ref().expect("an import")[0]
+            .new_text
+            .clone()
+    };
+    assert!(import("MassValue").contains("import ISQ::MassValue;"));
+    assert!(import("DurationValue").contains("import ISQ::DurationValue;"));
+    assert!(import("Real").contains("import ScalarValues::Real;"));
+    // After `private import MassV` on line 2.
+    let items = complete(&mut client, &u, 2, 24);
+    let mass = items
+        .iter()
+        .find(|i| i.label == "MassValue")
+        .expect("`MassValue` offered");
+    let Some(lsp_types::CompletionTextEdit::Edit(edit)) = &mass.text_edit else {
+        panic!("{mass:?}");
+    };
+    assert_eq!(edit.new_text, "ISQ::MassValue");
+
+    // The quick fix on an unresolved `MassValue`.
+    let v = uri("d.sysml");
+    client.open(&v, "package D {\n    attribute m : MassValue;\n}\n");
+    let range = lsp_types::Range {
+        start: Position {
+            line: 1,
+            character: 18,
+        },
+        end: Position {
+            line: 1,
+            character: 27,
+        },
+    };
+    let actions =
+        client.request_ok::<lsp_types::request::CodeActionRequest>(lsp_types::CodeActionParams {
+            text_document: TextDocumentIdentifier { uri: v },
+            range,
+            context: lsp_types::CodeActionContext {
+                diagnostics: vec![lsp_types::Diagnostic {
+                    range,
+                    message: "unresolved reference `MassValue`".to_string(),
+                    ..Default::default()
+                }],
+                ..Default::default()
+            },
+            work_done_progress_params: WorkDoneProgressParams::default(),
+            partial_result_params: PartialResultParams::default(),
+        });
+    let titles: Vec<String> = actions
+        .into_iter()
+        .flatten()
+        .filter_map(|a| match a {
+            lsp_types::CodeActionOrCommand::CodeAction(a) => Some(a.title),
+            lsp_types::CodeActionOrCommand::Command(_) => None,
+        })
+        .collect();
+    assert!(
+        titles.contains(&"Add import ISQ::MassValue".to_string()),
+        "{titles:?}"
+    );
+    client.shutdown();
+}
+
+/// Inside a unit bracket too, an inserted import names the conventional
+/// path: a unit its family's package re-exports (`Speeds` re-exports
+/// `SpeedsBase`) is imported through that package.
+#[test]
+fn unit_brackets_import_through_the_conventional_path() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("s.sysml");
+    client.open(
+        &u,
+        "package SpeedsBase {\n    private import ISQ::*;\n    \
+         attribute <furl> furlongPerFortnight : SpeedUnit;\n}\npackage Speeds {\n    \
+         public import SpeedsBase::*;\n}\npackage P {\n    private import ISQ::*;\n    \
+         attribute v : SpeedValue = 5 [fu\n}\n",
+    );
+    // After `[fu` on line 9.
+    let items = complete(&mut client, &u, 9, 35);
+    let furl = items
+        .iter()
+        .find(|i| i.label == "furl")
+        .expect("`furl` offered");
+    let imports: Vec<&str> = furl
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .map(|e| e.new_text.as_str())
+        .filter(|t| t.contains("import"))
+        .collect();
+    assert_eq!(imports, ["\n    private import Speeds::furl;"]);
+    assert_eq!(
+        furl.label_details
+            .as_ref()
+            .and_then(|d| d.description.as_deref()),
+        Some("import Speeds")
+    );
+    client.shutdown();
+}
+
+/// A unit alias completes as the unit it names, also when it names
+/// the unit by its short symbol (`alias arcmin for '′';`).
+#[test]
+fn unit_aliases_complete_as_units() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("s.sysml");
+    client.open(&u, "package S {\n    attribute a : SI::\n}\n");
+    // After `attribute a : SI::` on line 1.
+    let items = complete(&mut client, &u, 1, 22);
+    let kind = |label: &str| {
+        items
+            .iter()
+            .find(|i| i.label == label)
+            .unwrap_or_else(|| panic!("`{label}` offered"))
+            .kind
+    };
+    let unit = kind("kg");
+    assert_eq!(unit, Some(lsp_types::CompletionItemKind::PROPERTY));
+    assert_eq!(kind("arcmin"), unit);
+    assert_eq!(kind("m/s²"), unit);
+    client.shutdown();
+}
+
+/// A name two of a package's re-exported packages both declare denotes
+/// neither there: `ISQ::MagneticDipoleMomentValue` is an ambiguous
+/// reference (`ISQElectromagnetism` and `ISQAtomicNuclear` each declare
+/// one). `ISQ::` does not offer it, `import ISQ::*;` does not count as
+/// providing it, and no inserted import runs through `ISQ`, while its
+/// unambiguous neighbours are unaffected.
+#[test]
+fn ambiguous_library_names_are_not_imported_through() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let q = uri("q.sysml");
+    client.open(&q, "package Q {\n    attribute y : ISQ::\n}\n");
+    // After `attribute y : ISQ::` on line 1.
+    let labels: Vec<String> = complete(&mut client, &q, 1, 23)
+        .into_iter()
+        .map(|i| i.label)
+        .collect();
+    assert!(labels.iter().any(|l| l == "MassValue"));
+    assert!(!labels.iter().any(|l| l == "MagneticDipoleMomentValue"));
+
+    let a = uri("a.sysml");
+    for (text, line) in [
+        ("package A {\n    attribute m : \n}\n", 1),
+        (
+            "package A {\n    private import ISQ::*;\n    attribute m : \n}\n",
+            2,
+        ),
+    ] {
+        client.open(&a, text);
+        let items = complete(&mut client, &a, line, 18);
+        let dipole = items
+            .iter()
+            .find(|i| i.label == "MagneticDipoleMomentValue")
+            .expect("offered");
+        let import = &dipole.additional_text_edits.as_ref().expect("an import")[0].new_text;
+        assert!(
+            import.contains("import ISQAtomicNuclear::MagneticDipoleMomentValue;")
+                || import.contains("import ISQElectromagnetism::MagneticDipoleMomentValue;"),
+            "{text:?}: {import}"
+        );
+    }
+    client.shutdown();
+}
+
+/// The library's private members are no names for a model: `Triggers`
+/// publicly imports `Clocks` and `Observation`, but not their private
+/// `UniversalClockLife` or `ObserveChange`, which neither `Triggers::`
+/// nor their own packages' qualifiers offer, and neither does the flat
+/// list.
+#[test]
+fn private_library_members_are_not_offered() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("p.sysml");
+    client.open(
+        &u,
+        "package P {\n    part a : Triggers::\n    part b : Clocks::\n    part c : \n}\n",
+    );
+    let labels = |items: Vec<lsp_types::CompletionItem>| -> Vec<String> {
+        items.into_iter().map(|i| i.label).collect()
+    };
+    // After `part a : Triggers::` on line 1.
+    let triggers = labels(complete(&mut client, &u, 1, 23));
+    assert!(triggers.iter().any(|l| l == "Clock"), "{triggers:?}");
+    let clocks = labels(complete(&mut client, &u, 2, 21));
+    assert!(clocks.iter().any(|l| l == "Clock"), "{clocks:?}");
+    let flat = labels(complete(&mut client, &u, 3, 13));
+    for private in ["UniversalClockLife", "ObserveChange", "DefaultMonitorLife"] {
+        for (list, labels) in [
+            ("Triggers::", &triggers),
+            ("Clocks::", &clocks),
+            ("flat", &flat),
+        ] {
+            assert!(!labels.iter().any(|l| l == private), "{private} in {list}");
+        }
+    }
+    client.shutdown();
+}
+
+/// After a qualifier, a member the namespace re-exports is offered
+/// without its documentation — `ISQ::` re-exports some two thousand —
+/// while the namespace's own members, and every member under its own
+/// namespace's qualifier (`ISQBase::MassValue`), keep theirs.
+#[test]
+fn re_exported_members_complete_without_documentation() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("d.sysml");
+    client.open(
+        &u,
+        "package D {\n    attribute a : ISQ::\n    attribute b : ISQBase::\n}\n",
+    );
+    let documented = |items: &[lsp_types::CompletionItem], label: &str| {
+        items
+            .iter()
+            .find(|i| i.label == label)
+            .unwrap_or_else(|| panic!("`{label}` offered"))
+            .documentation
+            .is_some()
+    };
+    // After `ISQ::` on line 1, and `ISQBase::` on line 2.
+    let isq = complete(&mut client, &u, 1, 23);
+    assert!(!documented(&isq, "MassValue"));
+    assert!(documented(&isq, "TemperatureDifferenceValue"));
+    let base = complete(&mut client, &u, 2, 27);
+    assert!(documented(&base, "MassValue"));
+    client.shutdown();
+}
+
+/// A private unit is offered in a unit bracket only inside its own
+/// package, where it needs no import; outside it no import could make
+/// it visible, and the library's unit of the same name is offered
+/// instead.
+#[test]
+fn unit_brackets_offer_private_units_only_where_visible() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("h.sysml");
+    client.open(
+        &u,
+        "package Speeds {\n    private import ISQ::*;\n    \
+         private attribute <furl> furlongPerFortnight : SpeedUnit;\n    \
+         private attribute <m> surveyMetre : LengthUnit;\n    \
+         attribute inside : SpeedValue = 5 [fu\n}\npackage P {\n    private import ISQ::*;\n    \
+         attribute outside : SpeedValue = 5 [fu\n}\n",
+    );
+    let unit = |items: &[lsp_types::CompletionItem], label: &str| {
+        items
+            .iter()
+            .find(|i| i.label == label)
+            .map(|i| i.detail.clone().unwrap_or_default())
+    };
+    // After `[fu` inside `Speeds` (line 4), then inside `P` (line 8).
+    let inside = complete(&mut client, &u, 4, 42);
+    assert!(unit(&inside, "furl").is_some());
+    assert_eq!(unit(&inside, "m").as_deref(), Some("Speeds::m"));
+    let outside = complete(&mut client, &u, 8, 43);
+    assert_eq!(unit(&outside, "furl"), None);
+    assert_eq!(unit(&outside, "m").as_deref(), Some("SI::m"));
+    client.shutdown();
 }
 
 const DOC: &str = "package G {\n    private import ISQ::*;\n    private import SI::*;\n    attribute gravity = 9.8 [k\n}\n";
@@ -161,6 +1101,59 @@ fn accepting_a_unit_completion_declares_the_inferred_type() {
     client.shutdown();
 }
 
+/// A comment above the declaration is not part of its statement: a `;`
+/// inside it does not start the statement early, so the words after
+/// that `;` are not read as the declaration and the typing lands after
+/// the declared name, not inside the comment.
+#[test]
+fn a_comment_above_the_declaration_is_not_read_as_it() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("c.sysml");
+    client.open(
+        &u,
+        "package G {\n    private import ISQ::*;\n    private import SI::*;\n    \
+         /* measured; see attribute below */\n    attribute gravity = 9.8 [k\n}\n",
+    );
+    // Cursor after `[k` on line 4.
+    let items = complete(&mut client, &u, 4, 30);
+    let kg = items.iter().find(|i| i.label == "kg").expect("`kg` item");
+    let edits = kg.additional_text_edits.as_ref().expect("typing edit");
+    let typing = edits
+        .iter()
+        .find(|e| e.new_text == " : MassValue")
+        .unwrap_or_else(|| panic!("expected ` : MassValue` insert: {edits:?}"));
+    // Right after the declared name `gravity`.
+    assert_eq!(
+        typing.range.start,
+        Position {
+            line: 4,
+            character: 21
+        }
+    );
+    client.shutdown();
+}
+
+#[test]
+fn a_unit_that_does_not_parse_leaves_typing_on() {
+    // Another open unit ends mid-declaration: no `;`, no closing brace.
+    let mut client = Client::start_with(InitializeParams::default());
+    client.open(
+        &uri("k.kerml"),
+        "package K {\n    private import ScalarValues::*;\n    feature m : Real\n",
+    );
+    let u = uri("g.sysml");
+    client.open(&u, DOC);
+    let items = complete(&mut client, &u, 3, 30);
+    let kg = items.iter().find(|i| i.label == "kg").expect("`kg` item");
+    let typing = kg
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .any(|e| e.new_text == " : MassValue");
+    assert!(typing, "{:?}", kg.additional_text_edits);
+    client.shutdown();
+}
+
 #[test]
 fn compound_spelled_units_type_through_their_alias() {
     // The motivating flow: `= 9.8 [m/s` completing to the quoted
@@ -186,6 +1179,45 @@ fn compound_spelled_units_type_through_their_alias() {
     client.shutdown();
 }
 
+#[test]
+fn quoted_multiword_units_replace_the_typed_name_and_type_through() {
+    // A multi-word unit typed quoted, word by word: the accept replaces
+    // the whole typed spelling from its opening quote (not just `h`),
+    // the bracket closes, and the quantity type is declared — the
+    // accepted name is the whole bracket content.
+    let mut client = Client::start_with(InitializeParams::default());
+    let u = uri("s.sysml");
+    client.open(
+        &u,
+        "package G {\n    private import ISQ::*;\n    private import SI::*;\n    attribute speed = 90 ['kilometre per h\n}\n",
+    );
+    let items = complete(&mut client, &u, 3, 42);
+    let kph = items
+        .iter()
+        .find(|i| i.label == "kilometre per hour")
+        .expect("`kilometre per hour` item");
+    let Some(lsp_types::CompletionTextEdit::Edit(edit)) = &kph.text_edit else {
+        panic!("quoted insert text needs an edit: {kph:?}");
+    };
+    assert_eq!(edit.new_text, "'kilometre per hour']");
+    assert_eq!(
+        edit.range.start,
+        Position {
+            line: 3,
+            character: 26
+        },
+        "from the opening quote"
+    );
+    assert_eq!(kph.filter_text.as_deref(), Some("'kilometre per hour'"));
+    let typing = kph
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .any(|e| e.new_text == " : SpeedValue");
+    assert!(typing, "{:?}", kph.additional_text_edits);
+    client.shutdown();
+}
+
 #[test]
 fn typed_declarations_and_opt_out_insert_nothing() {
     // Already typed: no insert.
@@ -222,3 +1254,271 @@ fn typed_declarations_and_opt_out_insert_nothing() {
     assert!(!typing, "{:?}", kg.additional_text_edits);
     client.shutdown();
 }
+
+/// `text` with `item` accepted: its main edit — the snippet stop dropped
+/// — and its additional edits applied (the text is ASCII, so a position's
+/// character is its byte on the line).
+fn accepted(text: &str, item: &lsp_types::CompletionItem) -> String {
+    let offset = |p: Position| {
+        let line: usize = text
+            .split_inclusive('\n')
+            .take(p.line as usize)
+            .map(str::len)
+            .sum();
+        line + p.character as usize
+    };
+    let mut edits: Vec<(usize, usize, String)> = item
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .map(|e| {
+            (
+                offset(e.range.start),
+                offset(e.range.end),
+                e.new_text.clone(),
+            )
+        })
+        .collect();
+    match &item.text_edit {
+        Some(lsp_types::CompletionTextEdit::Edit(e)) => edits.push((
+            offset(e.range.start),
+            offset(e.range.end),
+            e.new_text.replace("$0", ""),
+        )),
+        other => panic!("expected a main edit: {other:?}"),
+    }
+    edits.sort_by_key(|&(start, _, _)| std::cmp::Reverse(start));
+    let mut out = text.to_string();
+    for (start, end, new_text) in edits {
+        out.replace_range(start..end, &new_text);
+    }
+    out
+}
+
+/// A unit accepted in a bracket left open before the statement's `;`
+/// closes the bracket right behind it, and — being then the whole
+/// bracket — declares the type an untyped attribute's value takes.
+#[test]
+fn a_unit_accepted_before_the_terminator_closes_its_bracket() {
+    for (line, expected) in [
+        (
+            "attribute d = 3 [h;",
+            "attribute d : DurationValue = 3 [h];",
+        ),
+        (
+            "attribute d : DurationValue = 3 [h;",
+            "attribute d : DurationValue = 3 [h];",
+        ),
+    ] {
+        for snippets in [false, true] {
+            let mut client = Client::start_with(InitializeParams {
+                capabilities: serde_json::from_value(serde_json::json!({
+                    "textDocument": {"completion": {"completionItem": {"snippetSupport": snippets}}}
+                }))
+                .unwrap(),
+                ..InitializeParams::default()
+            });
+            let u = uri("d.sysml");
+            let text = format!(
+                "package G {{\n    private import ISQ::*;\n    private import SI::*;\n    {line}\n}}\n"
+            );
+            client.open(&u, &text);
+            let character = 4 + line.find('[').unwrap() as u32 + 2;
+            let items = complete(&mut client, &u, 3, character);
+            let h = items.iter().find(|i| i.label == "h").expect("`h` item");
+            let out = accepted(&text, h);
+            assert_eq!(
+                out.lines().nth(3),
+                Some(format!("    {expected}").as_str()),
+                "{h:?}"
+            );
+            client.shutdown();
+        }
+    }
+}
+
+/// A list read with a `]` right after the cursor — the one an editor
+/// adds with the `[` — is sent incomplete: its accepts count on that
+/// `]` (a unit's carries no `]` of its own, and declares the type as
+/// the bracket's whole content), and the user may delete it and type
+/// on, so the list is to be asked for again. With no `]` there, the
+/// accepts close the bracket themselves, and the list is complete.
+#[test]
+fn a_list_read_before_the_added_closer_is_asked_for_again() {
+    let mut client = Client::start_with(InitializeParams::default());
+    for (line, character, incomplete) in [
+        ("attribute d = 3 [];", 21, true),
+        ("attribute d = 3 [h];", 22, true),
+        ("attribute d = 3 [h;", 22, false),
+        ("attribute d = 3 [h", 22, false),
+        // a multiplicity's bound takes names, and asks for no list again
+        ("part w [0..n];", 16, false),
+    ] {
+        let u = uri(&format!("i{character}{incomplete}.sysml"));
+        let text = format!(
+            "package G {{\n    private import ISQ::*;\n    private import SI::*;\n    {line}\n}}\n"
+        );
+        client.open(&u, &text);
+        let sent = match completion(&mut client, &u, 3, character) {
+            Some(CompletionResponse::List(list)) => list.is_incomplete,
+            Some(CompletionResponse::Array(_)) => false,
+            None => panic!("expected items: {line}"),
+        };
+        assert_eq!(sent, incomplete, "{line}");
+    }
+    client.shutdown();
+}
+
+/// A unit accepted before the statement's `;` declares the type only
+/// where the accept also writes the bracket's `]`: nothing but blanks
+/// may follow that `;` on the line. Before a `}` or a comment the
+/// bracket stays open, and no typing is added to a value that does not
+/// parse.
+#[test]
+fn a_unit_accepted_where_its_bracket_stays_open_declares_no_type() {
+    let mut client = Client::start_with(InitializeParams::default());
+    for (n, (line, typed)) in [
+        ("attribute d = 3 [h;   ", true),
+        ("part def Q { attribute d = 3 [h; }", false),
+        ("attribute d = 3 [h; attribute e = 4;", false),
+        ("attribute d = 3 [h;  // note", false),
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let u = uri(&format!("o{n}.sysml"));
+        let text = format!(
+            "package G {{\n    private import ISQ::*;\n    private import SI::*;\n    {line}\n}}\n"
+        );
+        client.open(&u, &text);
+        let character = 4 + line.find('[').unwrap() as u32 + 2;
+        let items = complete(&mut client, &u, 3, character);
+        let h = items.iter().find(|i| i.label == "h").expect("`h` item");
+        let typing = h
+            .additional_text_edits
+            .iter()
+            .flatten()
+            .any(|e| e.new_text == " : DurationValue");
+        assert_eq!(typing, typed, "{line}: {h:?}");
+        if typed {
+            let out = accepted(&text, h);
+            assert!(out.contains("[h];"), "{out}");
+        }
+    }
+    client.shutdown();
+}
+
+/// A list sent incomplete is asked for again at every keystroke, so it
+/// carries only the items the word typed can still match; with no word
+/// typed yet it carries them all.
+#[test]
+fn an_incomplete_list_carries_what_the_typed_word_matches() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let mut all = 0;
+    for (n, (line, character)) in [
+        ("attribute m : MassValue = 5 [];", 33),
+        ("attribute m : MassValue = 5 [kg];", 35),
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let u = uri(&format!("f{n}.sysml"));
+        let text = format!(
+            "package G {{\n    private import ISQ::*;\n    private import SI::*;\n    {line}\n}}\n"
+        );
+        client.open(&u, &text);
+        let Some(CompletionResponse::List(list)) = completion(&mut client, &u, 3, character) else {
+            panic!("an incomplete list: {line}");
+        };
+        if n == 0 {
+            all = list.items.len();
+            continue;
+        }
+        let labels: Vec<&str> = list.items.iter().map(|i| i.label.as_str()).collect();
+        assert!(
+            labels.contains(&"kg") && labels.contains(&"kilogram"),
+            "{labels:?}"
+        );
+        assert!(labels.len() < all, "{} of {all}", labels.len());
+        // Every item holds `k` then `g`, case aside.
+        for item in &list.items {
+            let spelled = item
+                .filter_text
+                .as_deref()
+                .unwrap_or(&item.label)
+                .to_lowercase();
+            let k = spelled.find('k').unwrap_or_else(|| panic!("{spelled}"));
+            assert!(spelled[k..].contains('g'), "{spelled}");
+        }
+    }
+    client.shutdown();
+}
+
+/// Accepting a document's own unit declares its quantity type when
+/// another open document declares a package of the same name: the unit
+/// is found where it is declared, not by a path the other package
+/// answers.
+#[test]
+fn a_unit_of_a_package_two_documents_declare_declares_its_type() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let a = uri("a.sysml");
+    let b = uri("b.sysml");
+    client.open(
+        &a,
+        "package Money {\n    private import ISQ::*;\n    \
+         attribute <fur> furlong : LengthUnit;\n}\n",
+    );
+    client.open(
+        &b,
+        "package Money {\n    private import ISQ::*;\n    \
+         attribute <lea> league : LengthUnit;\n    attribute trip = 3 [\n}\n",
+    );
+    // After `[` on line 3.
+    let items = complete(&mut client, &b, 3, 24);
+    let lea = items.iter().find(|i| i.label == "lea").expect("`lea` item");
+    let typing = lea
+        .additional_text_edits
+        .iter()
+        .flatten()
+        .find(|e| e.new_text == " : LengthValue")
+        .unwrap_or_else(|| panic!("expected ` : LengthValue`: {:?}", lea.additional_text_edits));
+    // Right after the declared name `trip`.
+    assert_eq!(
+        typing.range.start,
+        Position {
+            line: 3,
+            character: 18
+        }
+    );
+    client.shutdown();
+}
+
+/// A document's own units stay in its unit brackets when another open
+/// document declares a package of the same name: the units are found
+/// where they are declared, not by a path the other package answers.
+#[test]
+fn units_of_a_package_two_documents_declare_stay_offered() {
+    let mut client = Client::start_with(InitializeParams::default());
+    let a = uri("a.sysml");
+    let b = uri("b.sysml");
+    client.open(
+        &a,
+        "package Money {\n    attribute def CurrencyUnit :> MeasurementReferences::SimpleUnit;\n    \
+         attribute <'€'> euro : CurrencyUnit;\n}\n",
+    );
+    client.open(
+        &b,
+        "package Money {\n    attribute def CurrencyUnit :> MeasurementReferences::SimpleUnit;\n    \
+         attribute <'$'> dollar : CurrencyUnit;\n    attribute price = 5 [\n}\n",
+    );
+    let items = complete(&mut client, &b, 3, 25);
+    for label in ["$", "dollar"] {
+        assert!(
+            items.iter().any(
+                |i| i.label == label && i.detail.as_deref() == Some(&format!("Money::{label}"))
+            ),
+            "{label} offered"
+        );
+    }
+    client.shutdown();
+}
diff --git a/crates/sysmlv2-model/Cargo.toml b/crates/sysmlv2-model/Cargo.toml
index f774125..709e5a7 100644
--- a/crates/sysmlv2-model/Cargo.toml
+++ b/crates/sysmlv2-model/Cargo.toml
@@ -12,10 +12,11 @@ repository.workspace = true
 include = ["src/**", "build.rs", "Cargo.toml"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1", features = ["serde"] }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0", features = ["serde"] }
 serde = { workspace = true, features = ["rc"] }
 serde_json.workspace = true
 uuid = { workspace = true, features = ["serde"] }
+sha1_smol.workspace = true
 num-bigint.workspace = true
 num-integer.workspace = true
 num-rational.workspace = true
diff --git a/crates/sysmlv2-model/src/ambient.rs b/crates/sysmlv2-model/src/ambient.rs
index b64f912..cb49294 100644
--- a/crates/sysmlv2-model/src/ambient.rs
+++ b/crates/sysmlv2-model/src/ambient.rs
@@ -1,10 +1,11 @@
-//! Ambient libraries: generated SysML libraries compiled into the toolkit
-//! and added to every model that loads a library (`--lib`, a session
-//! library, the browser bundle), so models can reference `Web::DOM`,
-//! `Web::HTML::Elements`, `Template`, `Svelte` and `TransformMeta` without
-//! naming the files. The sources of truth are `local-packages/*.sysml`
-//! at the repository root, regenerated by the sibling `websysml` generator (see
-//! `local-packages/README.md`); this module is their build-time mirror.
+//! Ambient libraries: SysML libraries compiled into the toolkit and added
+//! to every model that loads a library (`--lib`, a session library, the
+//! browser bundle), so models can reference them without naming the
+//! files. There is one: `TransformMeta`, the metadata vocabulary that
+//! generated elements and their provenance records are annotated with.
+//! Its source of truth is `local-packages/TransformMeta.sysml` at the
+//! repository root (see `local-packages/README.md`); this module is its
+//! build-time mirror.
 //!
 //! Interim mechanism: once the SysML package manager can install these
 //! as published library packages, project installation provides them
@@ -13,41 +14,15 @@
 
 use crate::model::Model;
 
-/// `(unit name, source text)` in load order: `TransformMeta` (no
-/// dependencies), `Web` (the standard library only), `Template` (`Web`),
-/// then the engine overlays (`Template`), the application layer
-/// `WebApp` (`Template`) and the route/SSR overlay `SvelteKit`
-/// (`Template`).
-pub const LIBRARIES: &[(&str, &str)] = &[
-    (
-        "local-packages/TransformMeta.sysml",
-        include_str!("../../../local-packages/TransformMeta.sysml"),
-    ),
-    (
-        "local-packages/Web.sysml",
-        include_str!("../../../local-packages/Web.sysml"),
-    ),
-    (
-        "local-packages/Template.sysml",
-        include_str!("../../../local-packages/Template.sysml"),
-    ),
-    (
-        "local-packages/Svelte.sysml",
-        include_str!("../../../local-packages/Svelte.sysml"),
-    ),
-    (
-        "local-packages/WebApp.sysml",
-        include_str!("../../../local-packages/WebApp.sysml"),
-    ),
-    (
-        "local-packages/SvelteKit.sysml",
-        include_str!("../../../local-packages/SvelteKit.sysml"),
-    ),
-];
+/// `(unit name, source text)` in load order.
+pub const LIBRARIES: &[(&str, &str)] = &[(
+    "local-packages/TransformMeta.sysml",
+    include_str!("../../../local-packages/TransformMeta.sysml"),
+)];
 
 /// Are the ambient libraries enabled? `SYSMLV2_AMBIENT=off` keeps them
-/// out — to validate a regenerated file as a candidate without its
-/// built-in copy colliding, or to run against a bare standard library.
+/// out — to check an edited copy as a candidate without its built-in
+/// copy colliding, or to run against a bare standard library.
 /// Always on where there is no environment (the browser target).
 #[must_use]
 pub fn enabled() -> bool {
@@ -66,9 +41,8 @@ pub fn units() -> Vec<(String, String)> {
         .collect()
 }
 
-/// Add every ambient library to `model` as library content (after the
-/// standard library, whose `ScalarValues` they import). A no-op when
-/// disabled.
+/// Add every ambient library to `model` as library content, after the
+/// standard library. A no-op when disabled.
 pub fn add_to(model: &mut Model) {
     if !enabled() {
         return;
@@ -79,8 +53,8 @@ pub fn add_to(model: &mut Model) {
 }
 
 /// A content hash over the ambient sources (and whether they are
-/// enabled), mixed into library cache keys so a regenerated library
-/// never replays a stale recording.
+/// enabled), mixed into library cache keys so an edited library never
+/// replays a stale recording.
 #[must_use]
 pub fn content_hash() -> u64 {
     if !enabled() {
@@ -115,7 +89,8 @@ mod tests {
 
     #[test]
     fn ambient_sources_parse_and_are_stable() {
-        assert_eq!(LIBRARIES.len(), 6);
+        let names: Vec<&str> = LIBRARIES.iter().map(|(name, _)| *name).collect();
+        assert_eq!(names, ["local-packages/TransformMeta.sysml"]);
         for (name, text) in LIBRARIES {
             assert!(name.starts_with("local-packages/"), "{name}");
             assert!(
diff --git a/crates/sysmlv2-model/src/cache_codec.rs b/crates/sysmlv2-model/src/cache_codec.rs
index d0a5a89..ebb47b9 100644
--- a/crates/sysmlv2-model/src/cache_codec.rs
+++ b/crates/sysmlv2-model/src/cache_codec.rs
@@ -61,9 +61,158 @@ pub(crate) fn encode(value: &impl Serialize) -> Result<Vec<u8>> {
     Ok(out.0)
 }
 pub(crate) fn decode<T: DeserializeOwned>(bytes: &[u8]) -> Result<T> {
+    decode_from(Slice(bytes))
+}
+
+/// Where a decoder's bytes come from. A slice serves them in place; a
+/// chunked source serves them through a window it refills from a feed, so
+/// a payload a host holds elsewhere (a browser's heap) is never copied into
+/// this memory whole. `take` yields bytes valid until the next call.
+pub(crate) trait Source {
+    /// Bytes not yet taken.
+    fn remaining(&self) -> usize;
+    /// The next byte, left in place; `None` at the end.
+    fn peek(&mut self) -> Option<u8>;
+    /// The next `n` bytes, consumed.
+    fn take(&mut self, n: usize) -> Result<&[u8]>;
+}
+
+/// The bytes in place.
+pub(crate) struct Slice<'a>(pub(crate) &'a [u8]);
+
+impl Source for Slice<'_> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.0.len()
+    }
+    #[inline]
+    fn peek(&mut self) -> Option<u8> {
+        self.0.first().copied()
+    }
+    #[inline]
+    fn take(&mut self, n: usize) -> Result<&[u8]> {
+        if n > self.0.len() {
+            return Err(bad());
+        }
+        let (v, rest) = self.0.split_at(n);
+        self.0 = rest;
+        Ok(v)
+    }
+}
+
+/// A window over a feed: `fill` copies the next bytes of the payload into
+/// the buffer it is given and answers how many (0 at the end). Everything
+/// taken is folded into a checksum the caller reads back at the end, so a
+/// payload is verified once it has been consumed whole.
+pub(crate) struct Chunked<F: FnMut(&mut [u8]) -> usize> {
+    fill: F,
+    buf: Vec<u8>,
+    start: usize,
+    end: usize,
+    remaining: usize,
+    hash: crate::libcache::Fnv,
+}
+
+impl<F: FnMut(&mut [u8]) -> usize> Chunked<F> {
+    /// A window of `window` bytes over a payload of `len` bytes.
+    pub(crate) fn new(len: usize, window: usize, fill: F) -> Self {
+        Self {
+            fill,
+            buf: vec![0; window.max(16)],
+            start: 0,
+            end: 0,
+            remaining: len,
+            hash: crate::libcache::Fnv::new(),
+        }
+    }
+
+    /// Checksum of every byte taken since the last reset.
+    pub(crate) fn checksum(&self) -> u64 {
+        self.hash.finish()
+    }
+
+    /// Start the checksum over (after a header the checksum does not cover).
+    pub(crate) fn reset_checksum(&mut self) {
+        self.hash = crate::libcache::Fnv::new();
+    }
+
+    /// Make at least `n` contiguous bytes available at `start`.
+    fn ensure(&mut self, n: usize) -> Result<()> {
+        if self.end - self.start >= n {
+            return Ok(());
+        }
+        if n > self.remaining {
+            return Err(bad());
+        }
+        // compact, then grow for a single item wider than the window
+        self.buf.copy_within(self.start..self.end, 0);
+        self.end -= self.start;
+        self.start = 0;
+        if self.buf.len() < n {
+            self.buf.resize(n, 0);
+        }
+        while self.end < n {
+            // what the buffer can hold, bounded by what the payload still has beyond the buffered bytes
+            let room = (self.buf.len() - self.end).min(self.remaining - self.end);
+            if room == 0 {
+                return Err(bad());
+            }
+            let got = (self.fill)(&mut self.buf[self.end..self.end + room]);
+            if got == 0 || got > room {
+                return Err(bad());
+            }
+            self.end += got;
+        }
+        Ok(())
+    }
+}
+
+impl<F: FnMut(&mut [u8]) -> usize> Source for Chunked<F> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.remaining
+    }
+    #[inline]
+    fn peek(&mut self) -> Option<u8> {
+        if self.remaining == 0 {
+            return None;
+        }
+        self.ensure(1).ok()?;
+        Some(self.buf[self.start])
+    }
+    #[inline]
+    fn take(&mut self, n: usize) -> Result<&[u8]> {
+        self.ensure(n)?;
+        let v = &self.buf[self.start..self.start + n];
+        self.hash.update(v);
+        self.start += n;
+        self.remaining -= n;
+        Ok(v)
+    }
+}
+
+impl<S: Source> Source for &mut S {
+    #[inline]
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+    #[inline]
+    fn peek(&mut self) -> Option<u8> {
+        (**self).peek()
+    }
+    #[inline]
+    fn take(&mut self, n: usize) -> Result<&[u8]> {
+        (**self).take(n)
+    }
+}
+
+/// Decode from any source. The string table at the front is copied into
+/// an arena the decoded strings borrow from while decoding (a table entry's
+/// address identifies it to `shared_string`); the rest streams.
+pub(crate) fn decode_from<T: DeserializeOwned, S: Source>(src: S) -> Result<T> {
     let _strings = SharedStrings::enter();
     let mut r = Reader {
-        bytes,
+        src,
         depth: 0,
         strings: Vec::new(),
     };
@@ -71,13 +220,29 @@ pub(crate) fn decode<T: DeserializeOwned>(bytes: &[u8]) -> Result<T> {
     if count > 1_048_576 {
         return Err(bad());
     }
+    let mut arena = Vec::new();
+    let mut spans = Vec::with_capacity(count);
     for _ in 0..count {
         let len = r.length()?;
-        let text = std::str::from_utf8(r.take(len)?).map_err(|_| bad())?;
-        r.strings.push(text);
+        let text = r.src.take(len)?;
+        std::str::from_utf8(text).map_err(|_| bad())?;
+        spans.push((arena.len(), len));
+        arena.extend_from_slice(text);
     }
+    // the arena is complete; the table borrows it for the rest of the decode
+    let mut r = Reader {
+        src: r.src,
+        depth: 0,
+        strings: spans
+            .iter()
+            .map(|&(at, len)| {
+                // validated above
+                std::str::from_utf8(&arena[at..at + len]).map_err(|_| bad())
+            })
+            .collect::<Result<Vec<&str>>>()?,
+    };
     let value = T::deserialize(&mut r)?;
-    if !r.bytes.is_empty() {
+    if r.src.remaining() != 0 {
         return Err(bad());
     }
     Ok(value)
@@ -286,24 +451,19 @@ macro_rules! compound_struct {
 }
 compound_struct!(SerializeStruct);
 compound_struct!(SerializeStructVariant);
-struct Reader<'de> {
-    bytes: &'de [u8],
+struct Reader<'de, S: Source> {
+    src: S,
     depth: usize,
     strings: Vec<&'de str>,
 }
-impl<'de> Reader<'de> {
+impl<S: Source> Reader<'_, S> {
     #[inline]
-    fn take(&mut self, n: usize) -> Result<&'de [u8]> {
-        if n > self.bytes.len() {
-            return Err(bad());
-        }
-        let (v, rest) = self.bytes.split_at(n);
-        self.bytes = rest;
-        Ok(v)
+    fn tag(&mut self) -> Result<u8> {
+        Ok(self.src.take(1)?[0])
     }
     #[inline]
-    fn tag(&mut self) -> Result<u8> {
-        Ok(self.take(1)?[0])
+    fn skip(&mut self) -> Result<()> {
+        self.src.take(1).map(|_| ())
     }
     #[inline]
     fn count(&mut self) -> Result<u64> {
@@ -323,17 +483,17 @@ impl<'de> Reader<'de> {
     #[inline]
     fn length(&mut self) -> Result<usize> {
         let n = usize::try_from(self.count()?).map_err(|_| bad())?;
-        if n > self.bytes.len() {
+        if n > self.src.remaining() {
             return Err(bad());
         }
         Ok(n)
     }
 }
-struct Access<'a, 'de> {
-    r: &'a mut Reader<'de>,
+struct Access<'a, 'de, S: Source> {
+    r: &'a mut Reader<'de, S>,
     remaining: usize,
 }
-impl<'de> SeqAccess<'de> for Access<'_, 'de> {
+impl<'de, S: Source> SeqAccess<'de> for Access<'_, 'de, S> {
     type Error = Error;
     fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>> {
         if self.remaining == 0 {
@@ -346,7 +506,7 @@ impl<'de> SeqAccess<'de> for Access<'_, 'de> {
         Some(self.remaining.min(1_048_576))
     }
 }
-impl<'de> MapAccess<'de> for Access<'_, 'de> {
+impl<'de, S: Source> MapAccess<'de> for Access<'_, 'de, S> {
     type Error = Error;
     fn next_key_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>> {
         self.next_element_seed(seed)
@@ -358,15 +518,15 @@ impl<'de> MapAccess<'de> for Access<'_, 'de> {
         Some(self.remaining.min(1_048_576))
     }
 }
-impl<'de> de::Deserializer<'de> for &mut Reader<'de> {
+impl<'de, S: Source> de::Deserializer<'de> for &mut Reader<'de, S> {
     type Error = Error;
     fn is_human_readable(&self) -> bool {
         false
     }
     fn deserialize_any<V: Visitor<'de>>(self, v: V) -> Result<V::Value> {
-        match self.bytes.first() {
-            Some(&SEQ) => return self.collection(v, false),
-            Some(&MAP) => return self.collection(v, true),
+        match self.src.peek() {
+            Some(SEQ) => return self.collection(v, false),
+            Some(MAP) => return self.collection(v, true),
             _ => {}
         }
         if self.depth >= 256 {
@@ -383,7 +543,7 @@ impl<'de> de::Deserializer<'de> for &mut Reader<'de> {
                 v.visit_i64(((n >> 1) as i64) ^ -((n & 1) as i64))
             }
             FLOAT => v.visit_f64(f64::from_le_bytes(
-                self.take(8)?.try_into().map_err(|_| bad())?,
+                self.src.take(8)?.try_into().map_err(|_| bad())?,
             )),
             STR => {
                 let index = usize::try_from(self.count()?).map_err(|_| bad())?;
@@ -391,7 +551,7 @@ impl<'de> de::Deserializer<'de> for &mut Reader<'de> {
             }
             BYTES => {
                 let n = self.length()?;
-                v.visit_borrowed_bytes(self.take(n)?)
+                v.visit_bytes(self.src.take(n)?)
             }
             _ => Err(bad()),
         };
@@ -459,35 +619,34 @@ impl<'de> de::Deserializer<'de> for &mut Reader<'de> {
         result
     }
     fn deserialize_u64<V: Visitor<'de>>(self, v: V) -> Result<V::Value> {
-        if self.bytes.first() != Some(&UINT) {
+        if self.src.peek() != Some(UINT) {
             return self.deserialize_any(v);
         }
-        self.bytes = &self.bytes[1..];
+        self.skip()?;
         v.visit_u64(self.count()?)
     }
     fn deserialize_i64<V: Visitor<'de>>(self, v: V) -> Result<V::Value> {
-        if self.bytes.first() != Some(&INT) {
+        if self.src.peek() != Some(INT) {
             return self.deserialize_any(v);
         }
-        self.bytes = &self.bytes[1..];
+        self.skip()?;
         let n = self.count()?;
         v.visit_i64(((n >> 1) as i64) ^ -((n & 1) as i64))
     }
     fn deserialize_bool<V: Visitor<'de>>(self, v: V) -> Result<V::Value> {
-        match self.bytes.first() {
-            Some(&TRUE) | Some(&FALSE) => {
-                let b = self.bytes[0] == TRUE;
-                self.bytes = &self.bytes[1..];
-                v.visit_bool(b)
+        match self.src.peek() {
+            Some(b @ (TRUE | FALSE)) => {
+                self.skip()?;
+                v.visit_bool(b == TRUE)
             }
             _ => self.deserialize_any(v),
         }
     }
     fn deserialize_str<V: Visitor<'de>>(self, v: V) -> Result<V::Value> {
-        if self.bytes.first() != Some(&STR) {
+        if self.src.peek() != Some(STR) {
             return self.deserialize_any(v);
         }
-        self.bytes = &self.bytes[1..];
+        self.skip()?;
         let i = usize::try_from(self.count()?).map_err(|_| bad())?;
         v.visit_borrowed_str(self.strings.get(i).copied().ok_or_else(bad)?)
     }
@@ -514,7 +673,7 @@ impl<'de> de::Deserializer<'de> for &mut Reader<'de> {
     }
     serde::forward_to_deserialize_any! { f32 f64 char bytes byte_buf unit unit_struct identifier ignored_any }
 }
-impl<'de> Reader<'de> {
+impl<'de, S: Source> Reader<'de, S> {
     fn fixed<V: Visitor<'de>>(&mut self, v: V, n: usize) -> Result<V::Value> {
         if self.depth >= 256 {
             return Err(bad());
@@ -560,18 +719,18 @@ impl<'de> Reader<'de> {
         result
     }
 }
-struct Variant<'a, 'de> {
-    r: &'a mut Reader<'de>,
+struct Variant<'a, 'de, S: Source> {
+    r: &'a mut Reader<'de, S>,
     index: u32,
 }
-impl<'a, 'de> EnumAccess<'de> for Variant<'a, 'de> {
+impl<'a, 'de, S: Source> EnumAccess<'de> for Variant<'a, 'de, S> {
     type Error = Error;
     type Variant = Self;
     fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
         Ok((seed.deserialize(self.index.into_deserializer())?, self))
     }
 }
-impl<'de> VariantAccess<'de> for Variant<'_, 'de> {
+impl<'de, S: Source> VariantAccess<'de> for Variant<'_, 'de, S> {
     type Error = Error;
     fn unit_variant(self) -> Result<()> {
         Ok(())
@@ -639,6 +798,39 @@ mod tests {
     }
 }
 
+#[cfg(test)]
+mod chunked_tests {
+    use super::*;
+    /// A feed over a slice that hands out at most `step` bytes per call.
+    fn feed(bytes: &[u8], step: usize) -> impl FnMut(&mut [u8]) -> usize + '_ {
+        let mut at = 0;
+        move |buf: &mut [u8]| {
+            let n = buf.len().min(step).min(bytes.len() - at);
+            buf[..n].copy_from_slice(&bytes[at..at + n]);
+            at += n;
+            n
+        }
+    }
+    #[test]
+    fn chunked_sources_decode_like_slices_and_checksum_what_they_took() {
+        let value = serde_json::json!({"signed":i64::MIN,"text":"a long repeated property and qualified name","nested":[[1.5,true,null],{"k":"a long repeated property and qualified name"}],"bytes":[0,255,128]});
+        let bytes = encode(&value).unwrap();
+        for (window, step) in [(16, 1), (16, 5), (7, 7), (64 * 1024, 64 * 1024), (3, 1000)] {
+            let mut src = Chunked::new(bytes.len(), window, feed(&bytes, step));
+            let decoded: serde_json::Value = decode_from(&mut src).unwrap();
+            assert_eq!(decoded, value, "window {window}, step {step}");
+            let mut hash = crate::libcache::Fnv::new();
+            hash.update(&bytes);
+            assert_eq!(src.checksum(), hash.finish(), "every byte was taken once");
+        }
+        // a feed that ends early is a truncation, and a payload length past the feed too
+        let mut short = Chunked::new(bytes.len(), 16, feed(&bytes[..bytes.len() / 2], 16));
+        assert!(decode_from::<serde_json::Value, _>(&mut short).is_err());
+        let mut long = Chunked::new(bytes.len() + 1, 16, feed(&bytes, 16));
+        assert!(decode_from::<serde_json::Value, _>(&mut long).is_err());
+    }
+}
+
 #[cfg(test)]
 mod string_table_tests {
     use super::*;
diff --git a/crates/sysmlv2-model/src/check.rs b/crates/sysmlv2-model/src/check.rs
index b4935fe..efc9afa 100644
--- a/crates/sysmlv2-model/src/check.rs
+++ b/crates/sysmlv2-model/src/check.rs
@@ -6,12 +6,14 @@ mod actions;
 mod chains;
 mod connectors;
 mod dimensions;
+mod directions;
 mod distinguishability;
 mod endpoints;
 mod expressions;
 pub(crate) mod facts;
 mod invocations;
 mod multiplicities;
+mod multiplicity_domains;
 mod relationships;
 mod scalars;
 mod specialization;
@@ -319,17 +321,6 @@ fn normative_rule(rule: &'static str) -> &'static str {
     }
 }
 
-/// The number an evaluated value is, as `f64` — the reading the bound
-/// checks share. `None` for anything that is not a scalar number.
-pub(crate) fn scalar_f64(v: &crate::eval::Value) -> Option<f64> {
-    match v {
-        crate::eval::Value::Integer(i) => Some(*i as f64),
-        crate::eval::Value::Rational(r) => Some(r.to_f64()),
-        crate::eval::Value::Real(f) => Some(*f),
-        _ => None,
-    }
-}
-
 /// [`user_rows`] over a table keyed by owning element.
 pub(crate) fn user_entries<'a, V: Clone + 'a>(
     b: &crate::json::Builder,
@@ -349,6 +340,19 @@ pub(crate) fn user_entries<'a, V: Clone + 'a>(
 /// - **Multiplicity sanity** (errors): bounds that *provably* evaluate to a
 ///   negative number or to `lower > upper`. Bounds that reference unbound
 ///   features or fail to evaluate are left undecided (no diagnostic).
+/// - **Explicit multiplicity containment** (warnings): supported header, body
+///   and named domains are compared exactly in the specializing receiver.
+///   Redefinition checks both ends; subsetting checks only the upper end.
+///   Both features must have a unique explicit local domain. Incomplete,
+///   cyclic, invalid or unevaluable domains cannot establish containment; a
+///   bound referring to a member inside the constrained feature may be unsupported.
+/// - **Contextual multiplicity validity** (errors): an explicit subsetting or
+///   redefinition can make an authored valid range invalid in its receiver.
+///   Each side is checked independently, even if the other has no local domain.
+///   A finding requires a complete supported domain and a provably valid lexical
+///   baseline; unknown baselines stay undecided. Shared named ranges are reported
+///   once per specialization. Reporting is bounded to the first invalid range
+///   on each side, so it is not an exhaustive validation of inherited ranges.
 /// - **Self / circular subclassification** (errors): a definition that
 ///   (transitively) specializes itself. Feature subsetting/redefinition is
 ///   exempt — resolving a feature's own name to an inherited feature is the
@@ -391,6 +395,7 @@ pub fn validate_semantics_with(
     let facts = facts::Facts::new(&mut r.b);
     out.extend(connectors::validate(r, model, &facts));
     out.extend(structural::validate(r, model, &facts));
+    out.extend(structural::validate_directions(r, model, &facts));
     out.extend(endpoints::validate(r, model, &facts));
     out.extend(values::validate(r, model, &facts));
     out.extend(relationships::validate(r, model, &facts));
@@ -421,8 +426,7 @@ fn collect_feature_refs<'a>(
         | ExprKind::Null
         | ExprKind::Extent { .. }
         | ExprKind::MetadataAccess { .. }
-        | ExprKind::Body { .. }
-        | ExprKind::BodyTerminator => {}
+        | ExprKind::Body { .. } => {}
         ExprKind::Conditional {
             cond,
             then_branch,
@@ -730,4 +734,47 @@ mod tests {
         assert!(ResolvedModel::build(&warm).b.library_facts.is_some());
         assert_eq!(findings(&warm), cold_findings);
     }
+
+    /// Reporting spans cost at most one ownership step per element,
+    /// however deep the ownership nests. Measured in steps rather than in
+    /// wall-clock time: the count is the work the walk does, and does not
+    /// depend on the machine.
+    ///
+    /// An operator chain lowers four ownership levels per operator, so the
+    /// longest chain the parser admits nests its first operand over four
+    /// thousand levels deep. Walking up from each element separately took
+    /// over seventy million steps over its seventeen thousand elements.
+    #[test]
+    fn span_resolution_is_linear_in_the_ownership_depth() {
+        // Lowering the chain recurses once per operator, so the probe runs
+        // on a thread with room for it; the count is kept per thread, so
+        // the checks run there too.
+        std::thread::Builder::new()
+            .stack_size(64 << 20)
+            .spawn(|| {
+                let terms = sysmlv2_syntax::parser::MAX_EXPR_OPERATORS as usize;
+                let chain = (0..terms)
+                    .map(|i| format!("a{i} > 0"))
+                    .collect::<Vec<_>>()
+                    .join(" and ");
+                let mut model = Model::new();
+                model.add_source(
+                    "chain.sysml",
+                    &format!("package P {{ part x {{ attribute v = {chain}; }} }}"),
+                );
+                assert!(!model.has_errors());
+                let mut r = ResolvedModel::build(&model);
+                let elements = r.b.explicit_len();
+                let before = super::facts::span_steps();
+                super::validate_semantics_with(&mut r, &model);
+                let steps = super::facts::span_steps() - before;
+                assert!(
+                    steps <= elements,
+                    "{steps} ownership steps resolving spans over {elements} elements"
+                );
+            })
+            .unwrap()
+            .join()
+            .unwrap();
+    }
 }
diff --git a/crates/sysmlv2-model/src/check/actions.rs b/crates/sysmlv2-model/src/check/actions.rs
index 334cec2..4be7ddb 100644
--- a/crates/sysmlv2-model/src/check/actions.rs
+++ b/crates/sysmlv2-model/src/check/actions.rs
@@ -190,7 +190,10 @@ pub(super) fn validate(
                 .and_then(|p| r.b.contract_exprs.get(p))
                 .cloned()
             {
-                if let Some(t) = expressions::referent(&mut r.b, scope, &expr) {
+                let origin = r.b.set_identity_origin(e);
+                let target = expressions::referent(&mut r.b, scope, &expr);
+                r.b.identity_origin_unit = origin;
+                if let Some(t) = target {
                     let rule = if !is(&r.b, t, "Feature") {
                         Some((
                             "validateAssignmentActionUsageReferent",
@@ -227,9 +230,10 @@ pub(super) fn validate(
                 .and_then(|p| r.b.contract_exprs.get(p))
                 .cloned()
             {
-                if expressions::referent(&mut r.b, scope, &expr)
-                    .is_some_and(|t| g.effective_kind(&r.b, t, "PortUsage"))
-                {
+                let origin = r.b.set_identity_origin(e);
+                let target = expressions::referent(&mut r.b, scope, &expr);
+                r.b.identity_origin_unit = origin;
+                if target.is_some_and(|t| g.effective_kind(&r.b, t, "PortUsage")) {
                     out.push((
                         unit,
                         super::rule_warning(
@@ -266,6 +270,7 @@ pub(super) fn validate(
                 ),
                 _ => continue,
             };
+            let origin = r.b.set_identity_origin(e);
             let mut bad = expressions::wrong_type(&mut r.b, g, scope, &expr, required);
             if kind == "after" {
                 if let Some(t) = expressions::library_type(&mut r.b, required) {
@@ -277,6 +282,7 @@ pub(super) fn validate(
                     }
                 }
             }
+            r.b.identity_origin_unit = origin;
             if bad {
                 out.push((
                     unit,
@@ -291,12 +297,14 @@ pub(super) fn validate(
     }
     for (e, (scope, expr)) in super::user_entries(&r.b, model, r.b.transition_guards.iter()) {
         let unit = r.b.unit_of_elem(e);
+        let origin = r.b.set_identity_origin(e);
         let mut bad = expressions::wrong_type(&mut r.b, g, scope, &expr, "ScalarValues::Boolean");
         if let Some(t) = expressions::referent(&mut r.b, scope, &expr) {
             bad |= r
                 .declared_multiplicity(ElementRef(t))
                 .is_some_and(|m| m != (1.0, 1.0));
         }
+        r.b.identity_origin_unit = origin;
         if bad {
             out.push((
                 unit,
diff --git a/crates/sysmlv2-model/src/check/chains.rs b/crates/sysmlv2-model/src/check/chains.rs
index fc9b84a..893eeef 100644
--- a/crates/sysmlv2-model/src/check/chains.rs
+++ b/crates/sysmlv2-model/src/check/chains.rs
@@ -62,7 +62,10 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
             if model.is_library_unit(unit) {
                 continue;
             }
-            let Some(root) = r.b.resolve(scope, &links[0], 0) else {
+            let origin = r.b.set_identity_origin(owner);
+            let root = r.b.resolve(scope, &links[0], 0);
+            r.b.identity_origin_unit = origin;
+            let Some(root) = root else {
                 continue;
             };
             let Some(root_type) = owning_type(r, root) else {
diff --git a/crates/sysmlv2-model/src/check/dimensions.rs b/crates/sysmlv2-model/src/check/dimensions.rs
index 517fd07..d7a9315 100644
--- a/crates/sysmlv2-model/src/check/dimensions.rs
+++ b/crates/sysmlv2-model/src/check/dimensions.rs
@@ -89,7 +89,9 @@ impl Inference<'_> {
                 // Diagnostics belong to the value's own traversal, not every
                 // reference to it in a different file.
                 let before = self.findings.len();
+                let origin = self.model.b.set_identity_origin(e);
                 let d = self.expr(scope, &expr);
+                self.model.b.identity_origin_unit = origin;
                 self.findings.truncate(before);
                 result = d;
             }
@@ -299,7 +301,9 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
         if model.is_library_unit(unit) {
             continue;
         }
+        let origin = infer.model.b.set_identity_origin(owner);
         infer.expr(scope, &expr);
+        infer.model.b.identity_origin_unit = origin;
         out.extend(
             infer
                 .findings
@@ -309,3 +313,41 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::check::facts::Facts;
+
+    #[test]
+    fn checker_tail_restores_active_origin_on_errors_unknowns_and_cycles() {
+        let mut model = Model::new();
+        model.add_library_source("lib.kerml", "package Quantities { datatype QuantityValue; } package ScalarValues { datatype Boolean; datatype Integer; }");
+        model.add_source("user.kerml", "package P { feature Actual=1; feature '88888888-8888-4888-8888-888888888888'=true; feature value='88888888-8888-4888-8888-888888888888'; feature unknown=missing; feature cyclic=loop; feature loop=cyclic; class Holder { feature n; } metaclass M { feature x; } metadata m:M { feature x=Holder::n; } class C { feature n=Holder::n; feature a { feature leaf; } } feature chain subsets C::a.leaf; datatype T; datatype U; feature t:T; function f { return r:U; t } }");
+        model.add_source("actions.sysml", "package Actions { attribute x:ScalarValues::Integer; part def D; part p; action def Work { assign D := 1; send 1 to p; accept when x; accept after missing; } state def S { state a; state b; transition first a if x then b; } }");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let actual = r.resolve_qualified("P::Actual").unwrap();
+        let value = r.resolve_qualified("P::value").unwrap();
+        let id = "88888888-8888-4888-8888-888888888888".parse().unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(actual), id)]));
+        let expr = r.members_via(value, "FeatureValue")[0];
+        let edge = r.owned_relationships(expr)[0];
+        let mut hints = HashMap::from([((r.element_id(edge), "memberElement".into()), id)]);
+        assert!(r.bind_id_spelled_references_with(&mut hints).contains(&id));
+        let g = Facts::new(&mut r.b);
+        for origin in [None, Some(0)] {
+            r.b.identity_origin_unit = origin;
+            validate(&mut r, &model);
+            assert_eq!(r.b.identity_origin_unit, origin);
+            super::super::actions::validate(&mut r, &model, &g);
+            assert_eq!(r.b.identity_origin_unit, origin);
+            super::super::relationships::validate(&mut r, &model, &g);
+            assert_eq!(r.b.identity_origin_unit, origin);
+            super::super::values::validate(&mut r, &model, &g);
+            assert_eq!(r.b.identity_origin_unit, origin);
+            super::super::chains::validate(&mut r, &model);
+            assert_eq!(r.b.identity_origin_unit, origin);
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/directions.rs b/crates/sysmlv2-model/src/check/directions.rs
new file mode 100644
index 0000000..7e3bc9e
--- /dev/null
+++ b/crates/sysmlv2-model/src/check/directions.rs
@@ -0,0 +1,443 @@
+//! Shared conformance policy for validation and proposed redefinition repairs.
+use super::facts::{Facts, is};
+use crate::json::{Builder, DirectionFact, DirectionProof, authored_direction};
+use std::collections::HashMap;
+
+#[derive(Default)]
+pub(super) struct RedefinitionDirections {
+    proof: DirectionProof,
+    ownership: OwnershipProof,
+    steps: usize,
+}
+
+// Query-local ownership validation. Wide types index their relationship counts
+// once instead of rescanning the whole owner for every directed feature.
+#[derive(Default)]
+struct OwnershipProof {
+    owners: HashMap<usize, HashMap<usize, usize>>,
+    features: HashMap<usize, Option<Option<usize>>>,
+}
+impl OwnershipProof {
+    fn relationship_counts(
+        &mut self,
+        b: &Builder,
+        owner: usize,
+        steps: &mut usize,
+    ) -> Option<&HashMap<usize, usize>> {
+        if let std::collections::hash_map::Entry::Vacant(entry) = self.owners.entry(owner) {
+            let relationships = &b.elements.get(owner)?.owned_relationships;
+            *steps = steps.saturating_add(relationships.len());
+            if *steps > crate::eval::MAX_STEPS {
+                return None;
+            }
+            let mut counts = HashMap::new();
+            for &relationship in relationships {
+                *counts.entry(relationship).or_insert(0) += 1;
+            }
+            entry.insert(counts);
+        }
+        self.owners.get(&owner)
+    }
+    // Nested Option distinguishes proven absence from broken ownership.
+    fn owning_type(
+        &mut self,
+        b: &Builder,
+        g: &Facts,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        *steps = steps.saturating_add(1);
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        if let Some(&value) = self.features.get(&e) {
+            return value;
+        }
+        let result = self.inspect(b, g, e, steps);
+        if *steps <= crate::eval::MAX_STEPS {
+            self.features.insert(e, result);
+        }
+        result
+    }
+    fn inspect(
+        &mut self,
+        b: &Builder,
+        g: &Facts,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        let feature = b.elements.get(e)?;
+        if !is(b, e, "Feature") {
+            return None;
+        }
+        let Some(rel) = feature.owning_relationship else {
+            return Some(None);
+        };
+        b.elements.get(rel)?;
+        if !is(b, rel, "OwningMembership") {
+            return None;
+        }
+        let membership = b.elements.get(rel)?;
+        let owner = g.owner.get(e).copied().flatten()?;
+        b.elements.get(owner)?;
+        if *membership.children != [e]
+            || self.relationship_counts(b, owner, steps)?.get(&rel) != Some(&1)
+        {
+            return None;
+        }
+        for key in ["memberElement", "ownedMemberElement", "ownedMemberFeature"] {
+            if membership
+                .props
+                .get(key)
+                .is_some_and(|value| value.as_reference() != Some(b.elem_id(e)))
+            {
+                return None;
+            }
+        }
+        for key in [
+            "owningRelatedElement",
+            "membershipOwningNamespace",
+            "owningType",
+        ] {
+            if membership
+                .props
+                .get(key)
+                .is_some_and(|value| value.as_reference() != Some(b.elem_id(owner)))
+            {
+                return None;
+            }
+        }
+        if is(b, rel, "FeatureMembership") {
+            is(b, owner, "Type").then_some(Some(owner))
+        } else {
+            Some(None)
+        }
+    }
+}
+
+impl RedefinitionDirections {
+    /// Some(false) is a proven violation; None is incomplete, never absence.
+    /// A validator reports false; a repair requires true.
+    pub(super) fn conformance(
+        &mut self,
+        b: &mut Builder,
+        g: &Facts,
+        element: usize,
+        target: usize,
+    ) -> Option<bool> {
+        // A large earlier declaration must not suppress independent later checks.
+        // Completed graph proofs stay memoized, but every query and memo hit pays.
+        self.steps = 1;
+        if self.steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        let own = authored_direction(b, element);
+        if own == DirectionFact::Unknown {
+            return None;
+        }
+        let raw = authored_direction(b, target);
+        if raw == DirectionFact::Unknown {
+            return None;
+        }
+        if raw == DirectionFact::Known(None) {
+            return Some(true);
+        }
+        let target_owner = self.ownership.owning_type(b, g, target, &mut self.steps)?;
+        let owner = self.ownership.owning_type(b, g, element, &mut self.steps);
+        // Usage::mayTimeVary is derived from library specialization, portions
+        // and action/link exclusions. The static occurrence heuristic is not
+        // an identity proof. Unknown variability must satisfy both the owner-
+        // only and all-featuring interpretations before a repair is offered.
+        let variable = if is(b, element, "Usage") {
+            if owner == Some(None)
+                || b.elements[element]
+                    .props
+                    .get("isPortion")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+            {
+                Some(false)
+            } else {
+                None
+            }
+        } else {
+            match b.elements[element].props.get("isVariable") {
+                None => Some(false),
+                Some(value) => Some(value.as_bool()?),
+            }
+        };
+        let mut complete = owner.is_some();
+        let mut contexts: Vec<usize> = owner.flatten().into_iter().collect();
+        let mut seen_contexts: std::collections::HashSet<_> = contexts.iter().copied().collect();
+        if variable == Some(true) {
+            // Invalid/missing variable ownership is not a vacuous proof.
+            complete &= !contexts.is_empty();
+        } else {
+            let relations = g.outgoing_relationships(element);
+            self.steps = self.steps.saturating_add(relations.len());
+            if self.steps > crate::eval::MAX_STEPS {
+                return None;
+            }
+            for &rel in relations {
+                if is(b, rel, "FeatureChaining") {
+                    // Its first feature contributes further featuring contexts.
+                    complete = false;
+                } else if is(b, rel, "TypeFeaturing") {
+                    let relation = &b.elements[rel];
+                    if relation
+                        .props
+                        .get("featureOfType")
+                        .is_some_and(|source| source.as_reference() != Some(b.elem_id(element)))
+                    {
+                        complete = false;
+                        continue;
+                    }
+                    match g.target(b, rel, "featuringType") {
+                        Some(t) if is(b, t, "Type") => {
+                            if seen_contexts.insert(t) {
+                                contexts.push(t);
+                            }
+                        }
+                        _ => complete = false,
+                    }
+                }
+            }
+        }
+        for context in contexts {
+            match self
+                .proof
+                .through(
+                    b,
+                    context,
+                    target,
+                    target_owner,
+                    &|b, node, steps| {
+                        let relationships = g.outgoing_relationships(node);
+                        *steps = steps.saturating_add(relationships.len());
+                        if *steps > crate::eval::MAX_STEPS {
+                            return None;
+                        }
+                        Some(relationships.iter().any(|&r| is(b, r, "FeatureChaining")))
+                    },
+                    &mut self.steps,
+                )
+                .compatible(own)
+            {
+                Some(false) if variable.is_none() && owner != Some(Some(context)) => {
+                    // The all-featuring branch fails, but an actually variable
+                    // Usage may ignore this additional context.
+                    complete = false;
+                }
+                Some(false) => return Some(false),
+                None => complete = false,
+                Some(true) => {}
+            }
+        }
+        complete.then_some(true)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    use serde_json::json;
+    fn fixture() -> ResolvedModel {
+        let mut m = Model::new();
+        let u=m.add_source("direction.kerml","package P {classifier A {in feature p;} classifier C specializes A {in feature p;} classifier Wrong specializes A {out feature p;} feature link chains A::p;}");
+        assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+        ResolvedModel::build(&m)
+    }
+
+    #[test]
+    fn package_ownership_absence_requires_reciprocal_membership() {
+        let mut m = Model::new();
+        m.add_source(
+            "ownership.kerml",
+            "package P {in feature p; feature unrelated; classifier A {out feature q;}}",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let target = r.resolve_qualified("P::p").unwrap().0;
+        let unrelated = r.resolve_qualified("P::unrelated").unwrap().0;
+        let g = Facts::new(&mut r.b);
+        assert_eq!(
+            OwnershipProof::default().owning_type(&r.b, &g, target, &mut 0),
+            Some(None)
+        );
+        r.b.elements[target].owning_relationship = r.b.elements[unrelated].owning_relationship;
+        let g = Facts::new(&mut r.b);
+        assert_eq!(
+            OwnershipProof::default().owning_type(&r.b, &g, target, &mut 0),
+            None
+        );
+    }
+    #[test]
+    fn malformed_owning_membership_is_not_a_direction_proof() {
+        for defect in 0..5 {
+            let mut r = fixture();
+            let target = r.resolve_qualified("P::A::p").unwrap().0;
+            let own = r.resolve_qualified("P::Wrong::p").unwrap().0;
+            let owner = r.resolve_qualified("P::A").unwrap().0;
+            let unrelated = r.resolve_qualified("P::C").unwrap().0;
+            let rel = r.b.elements[target].owning_relationship.unwrap();
+            let wrong_id = r.b.elem_id(unrelated);
+            match defect {
+                0 => r.b.elements[rel]
+                    .props
+                    .insert("memberElement", json!({"@id":wrong_id})),
+                1 => r.b.elements[rel].children.make_mut().clear(),
+                2 => r.b.elements[owner]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&e| e != rel),
+                3 => r.b.elements[rel]
+                    .props
+                    .insert("owningRelatedElement", json!({"@id":wrong_id})),
+                4 => r.b.elements[owner].owned_relationships.push(rel),
+                _ => unreachable!(),
+            }
+            let g = Facts::new(&mut r.b);
+            let mut proof = RedefinitionDirections::default();
+            assert_eq!(
+                proof.conformance(&mut r.b, &g, own, target),
+                None,
+                "defect {defect}"
+            );
+        }
+    }
+    #[test]
+    fn standalone_chaining_prevents_unsafe_context_completion() {
+        let mut r = fixture();
+        let target = r.resolve_qualified("P::A::p").unwrap().0;
+        let own = r.resolve_qualified("P::C::p").unwrap().0;
+        let link = r.resolve_qualified("P::link").unwrap();
+        let rel = r
+            .owned_relationships(link)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "FeatureChaining")
+            .unwrap()
+            .0;
+        let own_id = r.b.elem_id(own);
+        // The relation is owned elsewhere, but explicitly names this feature.
+        // Facts must index its source; owning-only scans lose this uncertainty.
+        r.b.elements[rel]
+            .props
+            .insert("featureChained", json!({"@id":own_id}));
+        let g = Facts::new(&mut r.b);
+        let mut proof = RedefinitionDirections::default();
+        assert!(g.outgoing_relationships(own).contains(&rel));
+        assert_eq!(proof.conformance(&mut r.b, &g, own, target), None);
+    }
+    #[test]
+    fn explicit_null_target_direction_and_query_budget_recovery() {
+        let mut r = fixture();
+        let target = r.resolve_qualified("P::A::p").unwrap().0;
+        let own = r.resolve_qualified("P::C::p").unwrap().0;
+        let g = Facts::new(&mut r.b);
+        let mut proof = RedefinitionDirections {
+            steps: crate::eval::MAX_STEPS,
+            ..Default::default()
+        };
+        assert_eq!(proof.conformance(&mut r.b, &g, own, target), Some(true));
+        r.b.elements[target].props.insert("direction", json!(null));
+        let mut fresh = RedefinitionDirections::default();
+        assert_eq!(fresh.conformance(&mut r.b, &g, own, target), Some(true));
+    }
+    #[test]
+    fn conflicting_general_endpoint_and_wrong_source_are_unknown() {
+        for key in ["general", "specific"] {
+            let mut r = fixture();
+            let target = r.resolve_qualified("P::A::p").unwrap().0;
+            let own = r.resolve_qualified("P::C::p").unwrap().0;
+            let current = r.resolve_qualified("P::C").unwrap();
+            let other = r.resolve_qualified("P::Wrong").unwrap();
+            let edge = r
+                .owned_relationships(current)
+                .into_iter()
+                .find(|&e| r.element_type(e) == "Subclassification")
+                .unwrap()
+                .0;
+            let id = r.element_id(other);
+            r.b.elements[edge].props.insert(key, json!({"@id":id}));
+            let g = Facts::new(&mut r.b);
+            let mut proof = RedefinitionDirections::default();
+            assert_eq!(proof.conformance(&mut r.b, &g, own, target), None, "{key}");
+        }
+    }
+    fn variable_fixture() -> ResolvedModel {
+        let mut m = Model::new();
+        let u = m.add_source(
+            "variable-directions.kerml",
+            r#"
+        class A {in feature p;}
+        class Flip conjugates A;
+        package Actions {behavior Action;}
+        class C specializes A {
+            in feature p : Actions::Action featured by Flip;
+        }
+        class Bad specializes A {
+            out feature p : Actions::Action featured by missing;
+        }
+    "#,
+        );
+        assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+        ResolvedModel::build(&m)
+    }
+
+    #[test]
+    fn derived_usage_variability_does_not_drop_additional_contexts() {
+        let mut r = variable_fixture();
+        let target = r.resolve_qualified("A::p").unwrap().0;
+        let good_owner = r.resolve_qualified("C::p").unwrap().0;
+        let bad_owner = r.resolve_qualified("Bad::p").unwrap().0;
+        for e in [good_owner, bad_owner] {
+            // Graph-level SysML Usage: textual SysML does not admit the KerML
+            // `featured by` spelling, but TypeFeaturing is a metamodel relation.
+            r.b.elements[e].ty = "ActionUsage";
+            r.b.elements[e].props.insert("isComposite", json!(true));
+        }
+        let g = Facts::new(&mut r.b);
+        // This witnesses the old approximation. Composite Action usages have
+        // normative variability exclusions requiring a library identity proof;
+        // treating every owning Class as sufficient evidence is unsound.
+        assert!(super::super::structural::variable(&r.b, &g, good_owner));
+        assert_eq!(
+            RedefinitionDirections::default().conformance(&mut r.b, &g, good_owner, target),
+            None
+        );
+        // An owning-context mismatch violates both variability interpretations;
+        // unknown additional contexts must not erase this known violation.
+        assert_eq!(
+            RedefinitionDirections::default().conformance(&mut r.b, &g, bad_owner, target),
+            Some(false)
+        );
+        // A proven portion cannot vary and therefore must check the extra context.
+        r.b.elements[good_owner]
+            .props
+            .insert("isPortion", json!(true));
+        assert_eq!(
+            RedefinitionDirections::default().conformance(&mut r.b, &g, good_owner, target),
+            Some(false)
+        );
+    }
+
+    #[test]
+    fn kerml_stored_variability_selects_the_exact_context_branch() {
+        for (value, expected) in [
+            (json!(true), Some(true)),
+            (json!(false), Some(false)),
+            (json!("bad"), None),
+            (json!(null), None),
+        ] {
+            let mut r = variable_fixture();
+            let target = r.resolve_qualified("A::p").unwrap().0;
+            let own = r.resolve_qualified("C::p").unwrap().0;
+            r.b.elements[own].props.insert("isVariable", value);
+            let g = Facts::new(&mut r.b);
+            assert_eq!(
+                RedefinitionDirections::default().conformance(&mut r.b, &g, own, target),
+                expected
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/distinguishability.rs b/crates/sysmlv2-model/src/check/distinguishability.rs
index c42c16f..1bd3325 100644
--- a/crates/sysmlv2-model/src/check/distinguishability.rs
+++ b/crates/sysmlv2-model/src/check/distinguishability.rs
@@ -71,7 +71,8 @@ pub struct InheritedNameCollision {
     /// a checker rule a spelled redefinition is subject to: both are
     /// features and `hidden` is no variant; an end is redefined by an end
     /// (`validateRedefinitionEndConformance`); spelled directions agree or
-    /// `hidden`'s is `inout` (`validateRedefinitionDirectionConformance`);
+    /// the inherited direction is `inout` and this feature is directed.
+    /// Conjugation is included; incomplete direction evidence omits the repair;
     /// `element` binds no value over a bound (non-default) value of
     /// `hidden` or its redefinition chain (`validateFeatureValueOverriding`);
     /// each user type `hidden` declares admits some type `element`
@@ -118,15 +119,11 @@ fn overlapping(b: &Builder, x: usize, y: usize) -> bool {
 }
 
 /// Whether `e` reuses an inherited name through a redefinition the
-/// specification implies rather than one the modeller spells — the
-/// normative implicit redefinitions the resolver's specialization index
-/// does not record as `Redefinition` relationships:
-/// - a parameter of a behavior or step redefines the general's parameter
-///   at the same position (KerML `checkFeatureParameterRedefinition`), a
-///   result parameter the general's result (`checkFeatureResultRedefinition`);
-/// - an end feature redefines the general's end at the same position
-///   (`checkFeatureEndRedefinition`), so `end source : P;` in an interface
-///   definition legally reuses `BinaryInterface`'s end names;
+/// specification implies rather than one the modeller spells:
+/// - a parameter, result or end redefines the general's by position
+///   (`Builder::redefines_by_position`) — which inherited member that is
+///   depends on the position, not the name: [`implicitly_redefines_member`]
+///   tells whether a given one is it;
 /// - a case objective (SysML `checkRequirementUsageObjectiveRedefinition`),
 ///   a state's entry/do/exit action (`checkActionUsageStateActionRedefinition`),
 ///   a view rendering (`checkRenderingUsageRedefinition`) and a result
@@ -135,20 +132,14 @@ fn overlapping(b: &Builder, x: usize, y: usize) -> bool {
 ///   metadata definition's feature by the grammar (`MetadataBodyUsage`),
 ///   which the lowering spells as a same-named usage.
 fn implicitly_redefines(b: &Builder, e: usize) -> bool {
-    let elem = &b.elements[e];
-    let owner_ty = b.owner_elem(e).map(|o| b.elements[o].ty);
-    let in_behavior = owner_ty.is_some_and(|t| conforms(t, "Behavior") || conforms(t, "Step"));
-    if in_behavior && elem.props.get("direction").is_some_and(|d| d.is_string()) {
-        return true;
-    }
-    if elem.props.get("isEnd").and_then(|v| v.as_bool()) == Some(true) {
+    if b.redefines_by_position(e) {
         return true;
     }
+    let elem = &b.elements[e];
     if elem.owning_relationship.is_some_and(|r| {
         matches!(
             b.elements[r].ty,
-            "ReturnParameterMembership"
-                | "ObjectiveMembership"
+            "ObjectiveMembership"
                 | "StateSubactionMembership"
                 | "ViewRenderingMembership"
                 | "ResultExpressionMembership"
@@ -156,7 +147,36 @@ fn implicitly_redefines(b: &Builder, e: usize) -> bool {
     }) {
         return true;
     }
-    owner_ty.is_some_and(|t| conforms(t, "MetadataFeature"))
+    b.owner_elem(e)
+        .is_some_and(|o| conforms(b.elements[o].ty, "MetadataFeature"))
+}
+
+/// Whether `e`, an owned member of `owner`, redefines the inherited member
+/// `hidden` by implication. A parameter, result or end redefines what its position
+/// pairs it with, directly or through what that redefines: `in b;` as the
+/// only parameter under `Partial :> Diff { in a; in b; }` redefines `a`,
+/// and its reuse of the name `b` is the collision the rule reports. The
+/// other implied kinds ([`implicitly_redefines`]) carry their role's one
+/// inherited member.
+fn implicitly_redefines_member(b: &mut Builder, owner: usize, e: usize, hidden: usize) -> bool {
+    if !b.redefines_by_position(e) {
+        return implicitly_redefines(b, e);
+    }
+    let mut closure: HashSet<usize> = HashSet::new();
+    let mut stack = b.indexed_redefinition_targets(e);
+    stack.extend(b.positional_redefinition_targets(e, owner));
+    while let Some(t) = stack.pop() {
+        if t == hidden {
+            return true;
+        }
+        if closure.insert(t) {
+            stack.extend(b.indexed_redefinition_targets(t));
+            if let Some(o) = b.owner_elem(t) {
+                stack.extend(b.positional_redefinition_targets(t, o));
+            }
+        }
+    }
+    false
 }
 
 /// Whether `reuser` spells a redefinition or subsetting of `hidden` —
@@ -297,6 +317,8 @@ fn redefinition_target(
     element: usize,
     hidden: usize,
     simple: bool,
+    facts: &super::facts::Facts,
+    directions: &mut super::directions::RedefinitionDirections,
 ) -> Option<String> {
     let b = &r.b;
     if !conforms(b.elements[element].ty, "Feature") || !conforms(b.elements[hidden].ty, "Feature") {
@@ -313,13 +335,10 @@ fn redefinition_target(
     if flag(hidden, "isEnd") && !flag(element, "isEnd") {
         return None;
     }
-    let (from, to) = (
-        prop_str(b, element, "direction"),
-        prop_str(b, hidden, "direction"),
-    );
-    if from.is_some() && to.is_some() && from != to && to != Some("inout") {
+    if directions.conformance(&mut r.b, facts, element, hidden) != Some(true) {
         return None;
     }
+    let b = &r.b;
     if b.values.contains_key(&element) {
         let mut chain = redefinition_closure(&mut r.b, hidden);
         chain.insert(hidden);
@@ -383,6 +402,8 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
 /// inherits twice, each in name order.
 pub fn collisions(r: &mut ResolvedModel) -> Vec<InheritedNameCollision> {
     let mut out = Vec::new();
+    let mut direction_facts = None;
+    let mut directions = super::directions::RedefinitionDirections::default();
     let lib_boundary = r.b.lib_boundary;
     for e in lib_boundary..r.b.explicit_len() {
         let unit = r.b.unit_of_elem(e);
@@ -520,7 +541,9 @@ pub fn collisions(r: &mut ResolvedModel) -> Vec<InheritedNameCollision> {
 
         let mut by_owned: BTreeMap<(String, usize), (Vec<usize>, bool)> = BTreeMap::new();
         for (m, o, key, simple) in hidden {
-            if !implicitly_redefines(&r.b, o) && !explicitly_specializes(&mut r.b, o, m) {
+            if !implicitly_redefines_member(&mut r.b, e, o, m)
+                && !explicitly_specializes(&mut r.b, o, m)
+            {
                 let entry = by_owned.entry((key, o)).or_insert((Vec::new(), simple));
                 entry.0.push(m);
                 entry.1 &= simple;
@@ -554,9 +577,13 @@ pub fn collisions(r: &mut ResolvedModel) -> Vec<InheritedNameCollision> {
                             _ => false,
                         }
                 });
-            let redefinition_target = one_chain
-                .then(|| redefinition_target(r, o, near, simple && ms.len() == 1))
-                .flatten();
+            let redefinition_target = if one_chain {
+                let facts =
+                    direction_facts.get_or_insert_with(|| super::facts::Facts::new(&mut r.b));
+                redefinition_target(r, o, near, simple && ms.len() == 1, facts, &mut directions)
+            } else {
+                None
+            };
             let hint = if !conforms(r.b.elements[o].ty, "Feature") {
                 "rename it"
             } else if redefinition_target.is_some() {
diff --git a/crates/sysmlv2-model/src/check/expressions.rs b/crates/sysmlv2-model/src/check/expressions.rs
index bcabaed..5ad1851 100644
--- a/crates/sysmlv2-model/src/check/expressions.rs
+++ b/crates/sysmlv2-model/src/check/expressions.rs
@@ -102,7 +102,12 @@ pub(super) fn types(
                 return ts;
             }
             if let Some((s, value)) = b.values.get(&e).cloned() {
-                return types(b, g, s, &value, depth + 1);
+                // The value's bound identities belong to its declaration,
+                // which may be in a different unit from the referencing bound.
+                let origin = b.set_identity_origin(e);
+                let result = types(b, g, s, &value, depth + 1);
+                b.identity_origin_unit = origin;
+                return result;
             }
         }
         ExprKind::Constructor { ty, .. }
@@ -263,7 +268,10 @@ pub(super) fn model_level(
                 return Some(is(b, o, "Metaclass") || is(b, o, "MetadataFeature"));
             }
             let (s, value) = b.values.get(&e)?.clone();
-            model_level(b, g, s, &value, depth + 1)
+            let origin = b.set_identity_origin(e);
+            let result = model_level(b, g, s, &value, depth + 1);
+            b.identity_origin_unit = origin;
+            result
         }
         ExprKind::Invocation { ty, args } => {
             let t = b.resolve(scope, ty.as_name()?, 0)?;
@@ -323,6 +331,7 @@ pub(super) fn validate(
     let mut out = Vec::new();
     for (owner, scope, expr) in roots {
         let unit = r.b.unit_of_elem(owner);
+        let origin = r.b.set_identity_origin(owner);
         let mut expressions = Expressions(Vec::new());
         expressions.visit_expr(&expr);
         for expr in expressions.0 {
@@ -429,16 +438,18 @@ pub(super) fn validate(
                 _ => {}
             }
         }
+        r.b.identity_origin_unit = origin;
     }
     let filters: Vec<_> =
         r.b.filter_exprs
             .iter()
-            .filter_map(|(scope, expr)| {
-                let unit = r.b.unit_of_elem(r.b.nearest_scope_owner(*scope)?);
-                (!model.is_library_unit(unit)).then(|| (unit, *scope, expr.clone()))
+            .filter_map(|(owner, scope, expr)| {
+                let unit = r.b.unit_of_elem(*owner);
+                (!model.is_library_unit(unit)).then(|| (*owner, unit, *scope, expr.clone()))
             })
             .collect();
-    for (unit, scope, expr) in filters {
+    for (owner, unit, scope, expr) in filters {
+        let origin = r.b.set_identity_origin(owner);
         if wrong_type(&mut r.b, g, scope, &expr, "ScalarValues::Boolean") {
             out.push((
                 unit,
@@ -459,6 +470,101 @@ pub(super) fn validate(
                 ),
             ));
         }
+        r.b.identity_origin_unit = origin;
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn expression_and_invocation_checks_restore_active_source_identity() {
+        let mut model = Model::new();
+        model.add_source("first.kerml", "package A;");
+        model.add_source("second.kerml", "package B { function actual { in a; in b default 2; a } class '88888888-8888-4888-8888-888888888888'; feature good = '88888888-8888-4888-8888-888888888888'(1); feature invalid = actual(unknown=1); feature unresolved = missing(1); feature empty = (); class Other; feature not_callable = Other(); filter true; filter ~1; }");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let actual = r.resolve_qualified("B::actual").unwrap();
+        let id = "88888888-8888-4888-8888-888888888888".parse().unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(actual), id)]));
+        let good = r.resolve_qualified("B::good").unwrap();
+        let expr = r.members_via(good, "FeatureValue")[0];
+        let edge = r
+            .owned_relationships(expr)
+            .into_iter()
+            .find(|e| r.element_type(*e) == "Membership")
+            .unwrap();
+        let mut hints = HashMap::from([((r.element_id(edge), "memberElement".into()), id)]);
+        assert!(r.bind_id_spelled_references_with(&mut hints).contains(&id));
+        let g = Facts::new(&mut r.b);
+        for origin in [None, Some(0)] {
+            r.b.identity_origin_unit = origin;
+            let findings = validate(&mut r, &model, &g);
+            assert_eq!(findings.len(), 2, "{findings:?}");
+            assert!(findings.iter().any(|(_, d)| {
+                d.message
+                    .contains("validateInvocationExpressionInstantiatedType")
+            }));
+            assert!(findings.iter().any(|(_, d)| {
+                d.message
+                    .contains("validateElementFilterMembershipIsModelLevelEvaluable")
+            }));
+            assert_eq!(r.b.identity_origin_unit, origin);
+            let findings = super::super::invocations::validate(&mut r, &model);
+            assert_eq!(findings.len(), 1, "{findings:?}");
+            assert!(findings[0].1.message.contains("unknown parameter"));
+            assert_eq!(r.b.identity_origin_unit, origin);
+        }
+        // No roots must also preserve the caller's state.
+        let mut empty = ResolvedModel::build(&Model::new());
+        let g = Facts::new(&mut empty.b);
+        for origin in [None, Some(0)] {
+            empty.b.identity_origin_unit = origin;
+            assert!(validate(&mut empty, &Model::new(), &g).is_empty());
+            assert!(super::super::invocations::validate(&mut empty, &Model::new()).is_empty());
+            assert_eq!(empty.b.identity_origin_unit, origin);
+        }
+    }
+
+    #[test]
+    fn model_level_dependency_restores_origin_for_known_unknown_and_depth_limit() {
+        for (value, expected) in [
+            ("true", Some(true)),
+            ("Holder::runtime", Some(false)),
+            ("missing", None),
+            ("loop", None),
+        ] {
+            let mut model = Model::new();
+            model.add_source("first.kerml", "package A;");
+            model.add_source("second.kerml", &format!("package B {{ class Holder {{ feature runtime; }} feature Actual = {value}; feature loop = Actual; feature '88888888-8888-4888-8888-888888888888'=true; feature bridge = '88888888-8888-4888-8888-888888888888'; }}"));
+            model.add_source("third.kerml", "package C { feature checked = B::bridge; }");
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let actual = r.resolve_qualified("B::Actual").unwrap();
+            let id = "88888888-8888-4888-8888-888888888888".parse().unwrap();
+            r.override_ids(&HashMap::from([(r.element_id(actual), id)]));
+            let bridge = r.resolve_qualified("B::bridge").unwrap();
+            let expr = r.members_via(bridge, "FeatureValue")[0];
+            let edge = r
+                .owned_relationships(expr)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Membership")
+                .unwrap();
+            let mut hints = HashMap::from([((r.element_id(edge), "memberElement".into()), id)]);
+            assert!(r.bind_id_spelled_references_with(&mut hints).contains(&id));
+            let checked = r.resolve_qualified("C::checked").unwrap();
+            let (scope, expr) = r.b.values.get(&checked.0).unwrap().clone();
+            let g = Facts::new(&mut r.b);
+            for origin in [None, Some(0)] {
+                r.b.identity_origin_unit = origin;
+                assert_eq!(model_level(&mut r.b, &g, scope, &expr, 0), expected);
+                assert_eq!(r.b.identity_origin_unit, origin);
+                assert_eq!(model_level(&mut r.b, &g, scope, &expr, 32), None);
+                assert_eq!(r.b.identity_origin_unit, origin);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/facts.rs b/crates/sysmlv2-model/src/check/facts.rs
index 7089974..75ce5dd 100644
--- a/crates/sysmlv2-model/src/check/facts.rs
+++ b/crates/sysmlv2-model/src/check/facts.rs
@@ -3,9 +3,30 @@
 mod id_index;
 
 use crate::{json::Builder, layered::LayeredVec, metaclass};
-use std::collections::HashSet;
+use std::{collections::HashSet, sync::OnceLock};
 use sysmlv2_syntax::Span;
 
+#[cfg(test)]
+thread_local! {
+    static SPAN_STEPS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Ownership steps [`Facts::span`] has taken on the current thread. A
+/// step moves from an element to its owner; resolving every element's
+/// span takes at most one per element.
+#[cfg(test)]
+pub(crate) fn span_steps() -> usize {
+    SPAN_STEPS.with(|c| c.get())
+}
+
+#[cfg(test)]
+fn note_span_step() {
+    SPAN_STEPS.with(|c| c.set(c.get() + 1));
+}
+
+#[cfg(not(test))]
+fn note_span_step() {}
+
 #[derive(Clone, Default, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Facts {
     ids: id_index::IdIndex,
@@ -15,8 +36,23 @@ pub(crate) struct Facts {
     contexts: crate::flat::Rows<usize>,
     outgoing: crate::flat::Rows<usize>,
     targets: crate::flat::Rows<(crate::properties::Key, usize)>,
+    /// The first element this analysis added; [`Facts::span`] answers
+    /// from `spans` for it and every later one.
+    #[serde(skip)]
+    span_start: usize,
+    /// The span of each element from `span_start` on, resolved for all
+    /// of them on the first query.
+    #[serde(skip)]
+    spans: OnceLock<Box<[Span]>>,
 }
 impl Facts {
+    pub(super) fn outgoing_relationships(&self, e: usize) -> &[usize] {
+        if e < self.outgoing.len() {
+            &self.outgoing[e]
+        } else {
+            &[]
+        }
+    }
     pub(crate) fn contains_id(&self, id: &uuid::Uuid) -> bool {
         self.ids.get(id).is_some()
     }
@@ -82,7 +118,15 @@ impl Facts {
         for e in b.elements.iter().take(n).skip(start) {
             outgoing.push(e.owned_relationships.to_vec());
         }
-        let mut changed = HashSet::new();
+        // Explicit about may add/remove semantic bases on a library target
+        // without adding a source specialization. Empty values preserve touched
+        // target history, so removals also refresh the prepared direct context.
+        let mut changed: HashSet<usize> = b
+            .metadata_about
+            .keys()
+            .copied()
+            .filter(|&target| target < start)
+            .collect();
         // Read resolved graph edges, including prefix metadata and standalone
         // relationships which do not all have a spec_targets entry.
         for (rel_index, rel) in b.elements.iter().enumerate().take(n).skip(start) {
@@ -95,6 +139,7 @@ impl Facts {
                 "Specialization" => ("specific", "general"),
                 "Conjugation" => ("conjugatedType", "originalType"),
                 "TypeFeaturing" => ("featureOfType", "featuringType"),
+                "FeatureChaining" => ("featureChained", "chainingFeature"),
                 "FeatureInverting" => ("featureInverted", "invertingFeature"),
                 _ => continue,
             };
@@ -135,6 +180,8 @@ impl Facts {
             owner,
             members,
             supers,
+            span_start: start,
+            spans: OnceLock::new(),
         }
     }
     pub(crate) fn freeze(&mut self) {
@@ -196,52 +243,6 @@ impl Facts {
         }
         out
     }
-    /// Direction as seen through the specializing/typing context. Conjugation
-    /// reverses in/out; conflicting paths leave the fact undecided.
-    pub fn direction_through<'a>(
-        &self,
-        b: &'a Builder,
-        owner: usize,
-        target: usize,
-    ) -> Option<&'a str> {
-        let direction = b.elements[target].props.get("direction")?.as_str()?;
-        let featuring = self.featuring(b, target)?;
-        let mut seen = HashSet::new();
-        let mut stack = vec![(owner, false)];
-        let mut result = None;
-        while let Some((e, flipped)) = stack.pop() {
-            if !seen.insert((e, flipped)) {
-                continue;
-            }
-            if e == featuring {
-                let d = match (direction, flipped) {
-                    ("in", true) => "out",
-                    ("out", true) => "in",
-                    _ => direction,
-                };
-                if result.is_some_and(|old| old != d) {
-                    return None;
-                }
-                result = Some(d);
-            }
-            for &rel in &self.outgoing[e] {
-                for (kind, key, flip) in [
-                    ("FeatureTyping", "type", false),
-                    ("Subclassification", "superclassifier", false),
-                    ("Subsetting", "subsettedFeature", false),
-                    ("Redefinition", "redefinedFeature", false),
-                    ("Conjugation", "originalType", true),
-                ] {
-                    if is(b, rel, kind) {
-                        if let Some(t) = self.target(b, rel, key) {
-                            stack.push((t, flipped ^ flip));
-                        }
-                    }
-                }
-            }
-        }
-        result
-    }
     pub fn effective_kind(&self, b: &Builder, e: usize, kind: &str) -> bool {
         let mut seen = HashSet::new();
         let mut stack = vec![e];
@@ -434,7 +435,64 @@ impl Facts {
             None
         }
     }
+    /// Where a finding on `e` is reported: its own declaration or member
+    /// span, else the nearest owner's, else nowhere (the default span).
     pub fn span(&self, b: &Builder, e: usize) -> Span {
+        if (self.span_start..self.owner.len()).contains(&e) {
+            let spans = self.spans.get_or_init(|| self.resolve_spans(b));
+            return spans[e - self.span_start];
+        }
+        self.walk_span(b, e)
+    }
+
+    /// [`Facts::span`] for every element from `span_start` on, each
+    /// ownership step taken once: an element without a span of its own
+    /// reports at its owner's, so a resolved owner answers for every
+    /// element below it. Walking from each element separately costs its
+    /// depth each time, which is quadratic in a nesting as deep as a
+    /// lowered operator chain's: four ownership levels per operator.
+    fn resolve_spans(&self, b: &Builder) -> Box<[Span]> {
+        let (start, end) = (self.span_start, self.owner.len());
+        let mut spans: Vec<Option<Span>> = vec![None; end - start];
+        let mut on_path = vec![false; end - start];
+        let mut path = Vec::new();
+        for e in start..end {
+            let mut current = Some(e);
+            let span = loop {
+                let Some(x) = current else {
+                    break Span::default();
+                };
+                if !(start..end).contains(&x) {
+                    // The library prefix owns only library elements, so
+                    // its walk never comes back to the path.
+                    break self.walk_span(b, x);
+                }
+                if let Some(span) = spans[x - start] {
+                    break span;
+                }
+                if on_path[x - start] {
+                    // An ownership cycle with no span anywhere on it.
+                    break Span::default();
+                }
+                if let Some(&span) = b.decl_spans.get(&x).or_else(|| b.member_spans.get(&x)) {
+                    spans[x - start] = Some(span);
+                    break span;
+                }
+                on_path[x - start] = true;
+                path.push(x);
+                note_span_step();
+                current = self.owner[x];
+            };
+            for x in path.drain(..) {
+                spans[x - start] = Some(span);
+                on_path[x - start] = false;
+            }
+        }
+        spans.into_iter().map(Option::unwrap_or_default).collect()
+    }
+
+    /// [`Facts::span`] by walking up from `e` alone.
+    fn walk_span(&self, b: &Builder, e: usize) -> Span {
         let mut current = Some(e);
         let mut seen = HashSet::new();
         while let Some(e) = current {
@@ -444,6 +502,7 @@ impl Facts {
             if let Some(span) = b.decl_spans.get(&e).or_else(|| b.member_spans.get(&e)) {
                 return *span;
             }
+            note_span_step();
             current = self.owner[e];
         }
         Span::default()
@@ -455,3 +514,57 @@ pub(super) fn is(b: &Builder, e: usize, kind: &str) -> bool {
 pub(super) fn flag(b: &Builder, e: usize, key: &str) -> bool {
     b.elements[e].props.get(key).and_then(|x| x.as_bool()) == Some(true)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Facts;
+    use crate::{json::ResolvedModel, model::Model};
+
+    /// The spans resolved together answer exactly as a walk up from each
+    /// element alone, also where ownership cycles, stops, or leaves the
+    /// elements the analysis added for the library's.
+    #[test]
+    fn resolved_spans_answer_as_the_walk_from_each_element() {
+        let mut base = Model::new();
+        base.add_library_source("lib.kerml", "package L { class A { feature f = 1 + 2; } }");
+        let prepared = base.prepare_library().unwrap();
+        let mut model = Model::new();
+        prepared.install(&mut model).unwrap();
+        model.add_source(
+            "user.sysml",
+            "package P { part def D { attribute x = 1 + 2 * (3 - 4); } \
+             part d : D { attribute :>> x = if true ? 1 else 2; } }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let mut seed = 0x9e37_79b9_7f4a_7c15_u64;
+        let mut next = move |bound: usize| {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            usize::try_from(seed % bound as u64).unwrap()
+        };
+        for round in 0..64 {
+            let mut facts = Facts::new(&mut r.b);
+            let (start, end) = (facts.span_start, facts.owner.len());
+            assert!(0 < start && start < end, "the library is a prefix");
+            // Rewire owners before the first query: to nothing, to the
+            // element itself, or anywhere, the library included.
+            for _ in 0..round {
+                let e = start + next(end - start);
+                facts.owner[e] = match next(4) {
+                    0 => None,
+                    1 => Some(e),
+                    _ => Some(next(end)),
+                };
+            }
+            for e in 0..end {
+                assert_eq!(
+                    facts.span(&r.b, e),
+                    facts.walk_span(&r.b, e),
+                    "element {e} in round {round}"
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/invocations.rs b/crates/sysmlv2-model/src/check/invocations.rs
index 0a20199..0b30b4b 100644
--- a/crates/sysmlv2-model/src/check/invocations.rs
+++ b/crates/sysmlv2-model/src/check/invocations.rs
@@ -9,9 +9,10 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     let mut out = Vec::new();
     // --- invocation arity ---
     // A user-defined calculation invoked with fewer positional arguments
-    // than its declared `in`/`inout` parameters leaves the trailing
-    // parameters unbound — the result can never compute unless they carry
-    // defaults. Named bindings must name a parameter exactly once.
+    // than its `in`/`inout` parameters, its own and those it inherits,
+    // leaves the trailing parameters unbound — the result can never
+    // compute unless they carry defaults. Named bindings must name a
+    // parameter exactly once.
     // Warnings are conservatively scoped: lambda bodies skipped, and both
     // caller and callee must be outside the standard library (KFL
     // functions overload their parameter lists).
@@ -32,28 +33,36 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
         if model.is_library_unit(unit) {
             continue;
         }
+        let origin = r.b.set_identity_origin(owner);
         let mut sites = Vec::new();
         collect_invocations(&expr, &mut sites);
         for (qn, args, span) in sites {
             let Some(callee) = r.b.resolve(scope, qn, 0) else {
                 continue;
             };
-            let Some(params) = r.b.in_params.get(&callee).cloned() else {
-                continue;
-            };
             if model.is_library_unit(r.b.unit_of_elem(callee)) {
                 continue; // Library signatures can overload or use variadics.
             }
+            // The inputs evaluation binds: own, then inherited. A callee
+            // with none is not checked, nor one whose names are ambiguous.
+            let Some(bindings) = r.b.calc_parameter_bindings(callee) else {
+                continue;
+            };
+            if bindings.is_empty() {
+                continue;
+            }
             if args.iter().any(|a| a.name.is_some())
                 && !matches!(
                     r.b.elements[callee].ty,
                     "CalculationDefinition" | "CalculationUsage" | "Function" | "Expression"
                 )
             {
-                // Requirements/cases also bind implicit subject parameters;
-                // in_params alone is not their complete callable signature.
+                // Requirements/cases also bind the subject their implied
+                // library bases declare; the written heritage alone is not
+                // their complete callable signature.
                 continue;
             }
+            let params: Vec<String> = bindings.iter().map(|p| p.name.clone()).collect();
             let mut bound = HashSet::new();
             let mut positional = 0;
             let mut invalid = false;
@@ -94,16 +103,16 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
             if invalid {
                 continue;
             }
-            let fields = r.b.ctor_fields.get(&callee);
-            let missing: Vec<_> = params
+            // A parameter with a default need not be bound, and one no name
+            // reaches is read by nothing.
+            let missing: Vec<_> = bindings
                 .iter()
-                .filter(|name| {
-                    !bound.contains(*name)
-                        && !fields
-                            .and_then(|fs| fs.iter().find(|(n, _)| n == *name))
-                            .is_some_and(|(_, e)| r.b.values.contains_key(e))
+                .filter(|p| {
+                    !p.name.is_empty()
+                        && !bound.contains(&p.name)
+                        && !r.b.values.contains_key(&p.element.0)
                 })
-                .cloned()
+                .map(|p| p.name.clone())
                 .collect();
             if !missing.is_empty() {
                 out.push((
@@ -121,6 +130,7 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
                 ));
             }
         }
+        r.b.identity_origin_unit = origin;
     }
     out
 }
@@ -144,8 +154,7 @@ fn collect_invocations<'a>(
         | ExprKind::Ref(_)
         | ExprKind::Extent { .. }
         | ExprKind::MetadataAccess { .. }
-        | ExprKind::Body { .. }
-        | ExprKind::BodyTerminator => {}
+        | ExprKind::Body { .. } => {}
         ExprKind::Conditional {
             cond,
             then_branch,
@@ -205,3 +214,43 @@ fn collect_invocations<'a>(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{json::ResolvedModel, model::Model};
+
+    #[test]
+    fn inherited_inputs_count_toward_arity() {
+        let declarations = "calc def Diff { in a; in b; return r = a - b; }
+             calc def D3 :> Diff { in x; }
+             calc def D2 :> Diff { in :>> b; }
+             calc def Child :> Diff;";
+        for (call, expected) in [
+            ("D3(10, 3)", None),
+            ("D3(10)", Some("`b` never bound")),
+            ("Child(10, 3)", None),
+            ("Child(10)", Some("`b` never bound")),
+            ("D2(10)", None),
+            ("D2(10, 3)", Some("supplies 2 arguments for 1 parameter")),
+        ] {
+            let mut model = Model::new();
+            model.add_source(
+                "arity.sysml",
+                &format!("package P {{ {declarations} attribute v = {call}; }}"),
+            );
+            assert!(!model.has_errors(), "{call}");
+            let mut r = ResolvedModel::build(&model);
+            let findings: Vec<String> = super::validate(&mut r, &model)
+                .into_iter()
+                .map(|(_, d)| d.message)
+                .collect();
+            match expected {
+                None => assert!(findings.is_empty(), "{call}: {findings:?}"),
+                Some(message) => assert!(
+                    findings.len() == 1 && findings[0].contains(message),
+                    "{call}: {findings:?}"
+                ),
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/multiplicities.rs b/crates/sysmlv2-model/src/check/multiplicities.rs
index d7a0873..9f0054f 100644
--- a/crates/sysmlv2-model/src/check/multiplicities.rs
+++ b/crates/sysmlv2-model/src/check/multiplicities.rs
@@ -3,18 +3,66 @@
 //! above the upper end is an error; a bound that does not evaluate — an
 //! unbound feature, a symbolic expression — stays undecided.
 use super::user_rows;
-use crate::{json::ResolvedModel, model::Model};
+use crate::{eval::Value, json::ResolvedModel, model::Model, rational::Rational};
+use std::fmt;
 use sysmlv2_syntax::diag::Diagnostic;
 
+/// Ordered numeric endpoints without rounding exact values through a double.
+/// Infinities stay distinct from finite integers beyond the double range.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(super) enum NumericBound {
+    NegativeInfinity,
+    Finite(Rational),
+    Infinity,
+}
+
+impl NumericBound {
+    pub(super) fn from_value(value: Value) -> Option<Self> {
+        match value {
+            Value::Integer(n) => Some(Self::Finite(Rational::from_integer(n))),
+            Value::Rational(n) => Some(Self::Finite(n)),
+            Value::Real(n) if n == f64::INFINITY => Some(Self::Infinity),
+            Value::Real(n) if n == f64::NEG_INFINITY => Some(Self::NegativeInfinity),
+            Value::Real(n) => Rational::from_f64(n).map(Self::Finite),
+            _ => None,
+        }
+    }
+
+    pub(super) fn is_natural(&self, upper: bool) -> bool {
+        match self {
+            Self::Finite(n) => n.is_integer() && n >= &Rational::zero(),
+            Self::Infinity => upper,
+            Self::NegativeInfinity => false,
+        }
+    }
+
+    pub(super) fn zero() -> Self {
+        Self::Finite(Rational::zero())
+    }
+}
+
+impl fmt::Display for NumericBound {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::NegativeInfinity => f.write_str("-inf"),
+            Self::Finite(n) => n.fmt(f),
+            Self::Infinity => f.write_str("inf"),
+        }
+    }
+}
+
 pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diagnostic)> {
     let mut out = Vec::new();
     let sites = user_rows(&r.b, model, r.b.multiplicities.iter(), |row| row.0);
     for (owner, scope, mult) in sites {
+        // Identity-spelled references are bound within their source unit.
+        let origin = r.b.set_identity_origin(owner);
         let upper = crate::eval::evaluate_expr_in(&mut r.b, scope, &mult.upper).ok();
         let lower = match &mult.lower {
             Some(l) => crate::eval::evaluate_expr_in(&mut r.b, scope, l).ok(),
             None => None,
         };
+        r.b.identity_origin_unit = origin;
         // Unknown symbolic bounds remain undecided. A known scalar of the
         // wrong kind, fractional count, or collection is not a multiplicity.
         // Infinity denotes an unbounded upper end, never a lower end.
@@ -26,7 +74,6 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
                 mult.lower.as_ref().map_or(mult.span, |e| e.span),
             ),
         ] {
-            use crate::eval::Value;
             let invalid = match value {
                 None | Some(Value::Indeterminate | Value::Unbound(_) | Value::UnboundMember(_)) => {
                     false
@@ -48,10 +95,10 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
                 ));
             }
         }
-        let lo = lower.as_ref().and_then(super::scalar_f64);
-        let hi = upper.as_ref().and_then(super::scalar_f64);
-        if let Some(lo) = lo {
-            if lo < 0.0 {
+        let lo = lower.and_then(NumericBound::from_value);
+        let hi = upper.and_then(NumericBound::from_value);
+        if let Some(lo) = &lo {
+            if lo < &NumericBound::zero() {
                 out.push((
                     r.b.unit_of_elem(owner),
                     Diagnostic::error(mult.span, "multiplicity lower bound is negative"),
@@ -59,8 +106,8 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
                 continue;
             }
         }
-        if let Some(hi) = hi {
-            if hi < 0.0 {
+        if let Some(hi) = &hi {
+            if hi < &NumericBound::zero() {
                 out.push((
                     r.b.unit_of_elem(owner),
                     Diagnostic::error(mult.span, "multiplicity upper bound is negative"),
@@ -82,3 +129,67 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bound_checks_restore_the_callers_source_origin_on_every_exit() {
+        let mut model = Model::new();
+        model.add_source("first.kerml", "package A;");
+        model.add_source(
+            "second.kerml",
+            "package B {
+            feature n = -1; feature bad[n]; multiplicity wrong[3..2];
+            feature unknown; feature skipped[unknown]; class C; feature boundObject : C;
+            feature fTyped[boundObject]; feature identity['bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb']; class Base { feature x[1]; }
+            class Child specializes Base { feature y[2] subsets x; feature z[unknown] subsets x; }
+            class ReceiverBase { feature n default = 3; feature x[0..n]; }
+            class ReceiverChild specializes ReceiverBase { feature n redefines ReceiverBase::n = -1; feature y redefines x; }
+        }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("B::n").unwrap();
+        let id = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb".parse().unwrap();
+        r.override_ids(&std::collections::HashMap::from([(r.element_id(n), id)]));
+        assert!(r.bind_id_spelled_references().contains(&id));
+        let previous = r.b.set_identity_origin(n.0);
+        assert_eq!(r.b.identity_origin_unit, Some(1));
+        r.b.identity_origin_unit = previous;
+        for origin in [Some(0), None] {
+            r.b.identity_origin_unit = origin;
+            let findings = crate::check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 6, "{findings:?}");
+            assert_eq!(r.b.identity_origin_unit, origin);
+        }
+    }
+
+    #[test]
+    fn numeric_endpoints_preserve_exact_values_and_infinity() {
+        let convert = |v| NumericBound::from_value(v).unwrap();
+        let exact = convert(Value::Integer(9_007_199_254_740_993));
+        let real = convert(Value::Real(9_007_199_254_740_992.0));
+        assert!(exact > real);
+        assert!(real.is_natural(false));
+        let huge = convert(Value::Rational(Rational::parse_decimal("1e400").unwrap()));
+        assert!(huge > exact && huge < NumericBound::Infinity);
+        assert!(huge.is_natural(false));
+        assert_eq!(convert(Value::Real(-0.0)), NumericBound::zero());
+        for n in [0.5, -0.5, -1.0, f64::NEG_INFINITY] {
+            let bound = convert(Value::Real(n));
+            assert!(!bound.is_natural(false));
+            assert!(!bound.is_natural(true));
+        }
+        let tiny = convert(Value::Rational(Rational::parse_decimal("-1e-400").unwrap()));
+        assert!(tiny < NumericBound::zero());
+        assert!(!tiny.is_natural(true));
+        assert!(!NumericBound::Infinity.is_natural(false));
+        assert!(NumericBound::Infinity.is_natural(true));
+        assert_eq!(convert(Value::Real(f64::INFINITY)), NumericBound::Infinity);
+        assert!(NumericBound::from_value(Value::Real(f64::NAN)).is_none());
+        assert!(NumericBound::from_value(Value::Indeterminate).is_none());
+        assert!(NumericBound::from_value(Value::Boolean(true)).is_none());
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/multiplicity_domains.rs b/crates/sysmlv2-model/src/check/multiplicity_domains.rs
new file mode 100644
index 0000000..a8f0e6c
--- /dev/null
+++ b/crates/sysmlv2-model/src/check/multiplicity_domains.rs
@@ -0,0 +1,496 @@
+//! Exact, bounded reads of explicitly constrained multiplicity domains.
+use super::multiplicities::NumericBound;
+use crate::{eval, json::Builder, metaclass::conforms};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone)]
+pub(super) struct Interval {
+    pub(super) lower: NumericBound,
+    pub(super) upper: NumericBound,
+}
+
+/// Index range syntax once per validation pass; memoized values remain local to
+/// a comparison because its specializing receiver is part of the interpretation.
+pub(super) struct DomainRows(HashMap<usize, usize>);
+
+impl DomainRows {
+    pub(super) fn new(b: &Builder) -> Self {
+        let mut rows = HashMap::new();
+        for (i, (owner, _, _)) in b.multiplicities.iter().enumerate() {
+            let range = if conforms(b.elements[*owner].ty, "Multiplicity") {
+                Some(*owner)
+            } else {
+                b.local_multiplicity(*owner).flatten()
+            };
+            if let Some(range) = range {
+                rows.insert(range, i);
+            }
+        }
+        Self(rows)
+    }
+
+    pub(super) fn compare(&self, b: &mut Builder, owner: usize, target: usize) -> Comparison {
+        let mut comparison = Comparison::default();
+        let mut reader = Reader {
+            rows: self,
+            receiver: b.owner_scope_of(owner),
+            steps: 0,
+            active: HashSet::new(),
+            memo: HashMap::new(),
+        };
+        let mut seen = HashSet::new();
+        let mut intervals = [None, None];
+        for (index, feature) in [target, owner].into_iter().enumerate() {
+            let value = b
+                .local_multiplicity(feature)
+                .flatten()
+                .and_then(|domain| reader.domain(b, domain, 0));
+            match value {
+                Some(Err(invalid)) => {
+                    // Only diagnose a newly invalid contextual range. Authored
+                    // invalid ranges belong to the declaration pass. Use lexical
+                    // evaluation, not the row's scope as a featuring receiver.
+                    if seen.insert(invalid.row)
+                        && matches!(
+                            reader.range(b, invalid.row, eval::MultiplicityBoundContext::Lexical),
+                            Some(Ok(_))
+                        )
+                    {
+                        comparison.reported_rows.push(invalid.row);
+                        comparison.invalid.push((index == 0, invalid.reason));
+                    }
+                }
+                Some(Ok(interval)) => intervals[index] = Some(interval),
+                None => {}
+            }
+        }
+        if reader.steps > eval::MAX_STEPS {
+            return Comparison::default();
+        }
+        let [general, own] = intervals;
+        comparison.intervals = own.zip(general);
+        comparison
+    }
+
+    /// Validate inherited domains in a supplied receiver, rather than in the
+    /// lexical owner of their unchanged Feature identities. Results are staged
+    /// until the whole bounded pass succeeds, and only newly invalid ranges
+    /// with a valid lexical baseline are diagnostic evidence.
+    pub(super) fn inherited_invalid(
+        &self,
+        b: &mut Builder,
+        receiver_scope: usize,
+        features: &[usize],
+        steps: &mut usize,
+    ) -> Vec<(usize, usize, String)> {
+        let mut reader = Reader {
+            rows: self,
+            receiver: Some(receiver_scope),
+            steps: *steps,
+            active: HashSet::new(),
+            memo: HashMap::new(),
+        };
+        let mut invalids = Vec::new();
+        let mut seen = HashSet::new();
+        for &feature in features {
+            reader.steps = reader.steps.saturating_add(1);
+            if reader.steps > eval::MAX_STEPS {
+                break;
+            }
+            let value = b
+                .local_multiplicity(feature)
+                .flatten()
+                .and_then(|domain| reader.domain(b, domain, 0));
+            if let Some(Err(invalid)) = value {
+                if seen.insert(invalid.row)
+                    && matches!(
+                        reader.range(b, invalid.row, eval::MultiplicityBoundContext::Lexical),
+                        Some(Ok(_))
+                    )
+                {
+                    invalids.push((invalid.row, feature, invalid.reason));
+                }
+            }
+        }
+        *steps = reader.steps;
+        if *steps > eval::MAX_STEPS {
+            Vec::new()
+        } else {
+            invalids
+        }
+    }
+}
+
+#[derive(Default)]
+pub(super) struct Comparison {
+    pub(super) intervals: Option<(Interval, Interval)>,
+    pub(super) invalid: Vec<(bool, String)>,
+    pub(super) reported_rows: Vec<usize>,
+}
+
+#[derive(Clone)]
+struct InvalidRange {
+    row: usize,
+    reason: String,
+}
+
+type Domain = Result<Interval, InvalidRange>;
+
+struct Reader<'a> {
+    rows: &'a DomainRows,
+    receiver: Option<usize>,
+    steps: usize,
+    active: HashSet<usize>,
+    memo: HashMap<(usize, usize), Option<Domain>>,
+}
+
+impl Reader<'_> {
+    fn domain(&mut self, b: &mut Builder, e: usize, depth: usize) -> Option<Domain> {
+        self.steps = self.steps.saturating_add(1);
+        if self.steps > eval::MAX_STEPS || depth >= 64 {
+            return None;
+        }
+        if let Some(value) = self.memo.get(&(e, depth)) {
+            return value.clone();
+        }
+        if !self.active.insert(e) {
+            return None;
+        }
+        let result = self.domain_inner(b, e, depth);
+        self.active.remove(&e);
+        self.memo.insert((e, depth), result.clone());
+        result
+    }
+
+    fn domain_inner(&mut self, b: &mut Builder, e: usize, depth: usize) -> Option<Domain> {
+        if !conforms(b.elements[e].ty, "Multiplicity") {
+            return None;
+        }
+        let mut interval = None;
+        if b.elements[e].ty == "MultiplicityRange" {
+            let i = *self.rows.0.get(&e)?;
+            interval = Some(self.range(
+                b,
+                i,
+                eval::MultiplicityBoundContext::Receiver(self.receiver),
+            )?);
+        }
+        self.steps = self
+            .steps
+            .saturating_add(b.elements[e].owned_relationships.len());
+        if self.steps > eval::MAX_STEPS {
+            return None;
+        }
+        for r in b.elements[e].owned_relationships.clone() {
+            let relation = &b.elements[r];
+            if !conforms(relation.ty, "Specialization") {
+                continue;
+            }
+            let property = match relation.ty {
+                "Subsetting" => "subsettedFeature",
+                "Redefinition" => "redefinedFeature",
+                _ => return None,
+            };
+            let id = relation.props.get(property)?.as_reference()?;
+            let target = b.element_index_of_uuid(id)?;
+            let next = self.domain(b, target, depth + 1)?;
+            interval = Some(match (interval, next) {
+                (None, next) => next,
+                (Some(Err(invalid)), _) | (_, Err(invalid)) => Err(invalid),
+                (Some(Ok(current)), Ok(next)) => {
+                    let intersection = Interval {
+                        lower: current.lower.max(next.lower),
+                        upper: current.upper.min(next.upper),
+                    };
+                    if intersection.lower > intersection.upper {
+                        return None;
+                    }
+                    Ok(intersection)
+                }
+            });
+        }
+        interval
+    }
+
+    fn range(
+        &mut self,
+        b: &mut Builder,
+        row: usize,
+        context: eval::MultiplicityBoundContext,
+    ) -> Option<Domain> {
+        let (source, scope, range) = b.multiplicities[row].clone();
+        let upper = eval::evaluate_multiplicity_bound(
+            b,
+            source,
+            scope,
+            context,
+            &range.upper,
+            &mut self.steps,
+        )?;
+        let lower = match &range.lower {
+            Some(lower) => Some(eval::evaluate_multiplicity_bound(
+                b,
+                source,
+                scope,
+                context,
+                lower,
+                &mut self.steps,
+            )?),
+            None => None,
+        };
+        // Unknown values must not be mistaken for known values of an invalid kind.
+        if matches!(
+            upper,
+            eval::Value::Indeterminate | eval::Value::Unbound(_) | eval::Value::UnboundMember(_)
+        ) || matches!(
+            lower,
+            Some(
+                eval::Value::Indeterminate
+                    | eval::Value::Unbound(_)
+                    | eval::Value::UnboundMember(_)
+            )
+        ) {
+            return None;
+        }
+        let invalid = |reason: String| Some(Err(InvalidRange { row, reason }));
+        let Some(upper) = NumericBound::from_value(upper) else {
+            return invalid("upper bound must be a Natural number (or `*`)".into());
+        };
+        let lower = match lower {
+            Some(lower) => match NumericBound::from_value(lower) {
+                Some(lower) => lower,
+                None => return invalid("lower bound must be a Natural number".into()),
+            },
+            None if upper == NumericBound::Infinity => NumericBound::zero(),
+            None => upper.clone(),
+        };
+        if !upper.is_natural(true) {
+            return invalid(format!(
+                "upper bound {upper} is not a Natural number (or `*`)"
+            ));
+        }
+        if !lower.is_natural(false) {
+            return invalid(format!("lower bound {lower} is not a Natural number"));
+        }
+        if lower > upper {
+            return invalid(format!("lower bound {lower} exceeds upper bound {upper}"));
+        }
+        Some(Ok(Interval { lower, upper }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    #[test]
+    fn inherited_domains_restore_origin_and_retry_after_exhaustion() {
+        let mut model = Model::new();
+        model.add_source("unrelated.kerml", "package Other;");
+        model.add_source("base.kerml", "class Base { feature n default = 3; feature x[0..n]; } class Child specializes Base { feature n redefines Base::n = -1; }");
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("Base::x").unwrap().0;
+        let child = r.resolve_qualified("Child").unwrap().0;
+        let scope = r.b.elem_scope.get(&child).copied().unwrap();
+        let rows = DomainRows::new(&r.b);
+        for origin in [None, Some(0)] {
+            r.b.identity_origin_unit = origin;
+            let mut exhausted = eval::MAX_STEPS;
+            assert!(
+                rows.inherited_invalid(&mut r.b, scope, &[x], &mut exhausted)
+                    .is_empty()
+            );
+            assert!(exhausted > eval::MAX_STEPS);
+            assert_eq!(r.b.identity_origin_unit, origin);
+            let mut fresh = 0;
+            let findings = rows.inherited_invalid(&mut r.b, scope, &[x, x], &mut fresh);
+            assert_eq!(findings.len(), 1);
+            assert!(findings[0].2.contains("upper bound -1"));
+            assert_eq!(r.b.identity_origin_unit, origin);
+        }
+    }
+
+    #[test]
+    fn contextual_errors_require_complete_domains_and_unwind_after_failure() {
+        for mutation in 0..4 {
+            let mut model = Model::new();
+            model.add_source("test.kerml", "class Base { feature n default = 3; feature x { multiplicity domain[0..n]; } } class Child specializes Base { feature n redefines Base::n = -1; feature y redefines x; } multiplicity extra[0..*]; multiplicity link subsets extra;");
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let x = r.resolve_qualified("Base::x").unwrap().0;
+            let y = r.resolve_qualified("Child::y").unwrap().0;
+            let range = r.resolve_qualified("Base::x::domain").unwrap().0;
+            let link = r.resolve_qualified("link").unwrap().0;
+            let edge = r.b.elements[link].owned_relationships[0];
+            // Move the constraint to the range; a duplicate relationship
+            // carrier is malformed and cannot support receiver evidence.
+            r.b.elements[link].owned_relationships = Vec::new().into();
+            r.b.elements[range].owned_relationships.push(edge);
+            let range_id = r.element_id(crate::json::ElementRef(range));
+            r.b.elements[edge]
+                .props
+                .insert("owningRelatedElement", serde_json::json!({"@id": range_id}));
+            let rows = DomainRows::new(&r.b);
+            assert_eq!(rows.compare(&mut r.b, y, x).invalid.len(), 1);
+            let previous = r.b.elements[edge].clone();
+            match mutation {
+                0 => r.b.elements[edge].ty = "Subclassification",
+                1 => {
+                    r.b.elements[edge].props.insert(
+                        "subsettedFeature",
+                        serde_json::json!({"@id": "11111111-1111-4111-8111-111111111111"}),
+                    );
+                }
+                2 => {
+                    let id = r.element_id(crate::json::ElementRef(range));
+                    r.b.elements[edge]
+                        .props
+                        .insert("subsettedFeature", serde_json::json!({"@id": id}));
+                }
+                _ => {
+                    let extra = r.resolve_qualified("extra").unwrap().0;
+                    r.b.elements[extra].ty = "Feature";
+                }
+            }
+            assert!(rows.compare(&mut r.b, y, x).invalid.is_empty());
+            r.b.elements[edge] = previous;
+            if mutation != 3 {
+                assert_eq!(rows.compare(&mut r.b, y, x).invalid.len(), 1);
+            }
+        }
+    }
+
+    #[test]
+    fn domain_intersection_requires_every_constraint_to_be_valid_and_complete() {
+        for (range, expected) in [
+            ("0..8", Some(("2", "5"))),
+            ("4..9", Some(("4", "5"))),
+            ("7..9", None),
+            ("6..3", None),
+        ] {
+            let mut model = Model::new();
+            model.add_source("test.kerml", &format!("multiplicity domain[{range}]; multiplicity restriction[2..5]; multiplicity link subsets restriction;"));
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let domain = r.resolve_qualified("domain").unwrap().0;
+            let link = r.resolve_qualified("link").unwrap().0;
+            let edge = r.b.elements[link].owned_relationships[0];
+            r.b.elements[domain].owned_relationships.push(edge);
+            let rows = DomainRows::new(&r.b);
+            let read = |b: &mut Builder| {
+                Reader {
+                    rows: &rows,
+                    receiver: None,
+                    steps: 0,
+                    active: HashSet::new(),
+                    memo: HashMap::new(),
+                }
+                .domain(b, domain, 0)
+                .and_then(Result::ok)
+                .map(|i| (i.lower.to_string(), i.upper.to_string()))
+            };
+            assert_eq!(read(&mut r.b), expected.map(|(l, u)| (l.into(), u.into())));
+            r.b.elements[edge].ty = "Subclassification";
+            assert!(read(&mut r.b).is_none());
+            r.b.elements[edge].ty = "Subsetting";
+            r.b.elements[edge].props.insert(
+                "subsettedFeature",
+                serde_json::json!({"@id": "11111111-1111-4111-8111-111111111111"}),
+            );
+            assert!(read(&mut r.b).is_none());
+        }
+    }
+
+    #[test]
+    fn domain_limits_unwind_and_do_not_poison_shallower_reads() {
+        let mut model = Model::new();
+        model.add_source("test.kerml", "multiplicity good[2..4]; multiplicity chain subsets good; multiplicity cycle subsets cycle;");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let good = r.resolve_qualified("good").unwrap().0;
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let cycle = r.resolve_qualified("cycle").unwrap().0;
+        let rows = DomainRows::new(&r.b);
+        let mut reader = Reader {
+            rows: &rows,
+            receiver: None,
+            steps: 0,
+            active: HashSet::new(),
+            memo: HashMap::new(),
+        };
+        assert!(reader.domain(&mut r.b, chain, 63).is_none());
+        assert!(reader.active.is_empty());
+        let bounds = reader.domain(&mut r.b, chain, 0).unwrap().ok().unwrap();
+        assert_eq!(bounds.lower.to_string(), "2");
+        assert_eq!(bounds.upper.to_string(), "4");
+        assert!(reader.domain(&mut r.b, cycle, 0).is_none());
+        assert!(reader.active.is_empty());
+        let before = reader.steps;
+        assert!(reader.domain(&mut r.b, good, 0).is_some());
+        assert!(reader.steps > before);
+        let before = reader.steps;
+        assert!(reader.domain(&mut r.b, good, 0).is_some());
+        assert!(reader.steps > before, "memo hits consume shared budget");
+        reader.steps = eval::MAX_STEPS;
+        assert!(reader.domain(&mut r.b, good, 0).is_none());
+        reader.steps = usize::MAX;
+        assert!(reader.domain(&mut r.b, good, 0).is_none());
+    }
+
+    #[test]
+    fn bound_wrapper_shares_work_preserves_exact_values_and_restores_origin() {
+        let mut model = Model::new();
+        model.add_source("first.kerml", "package A;");
+        model.add_source("second.kerml", "package B { feature n = 170141183460469231731687303715884105729; multiplicity exact['bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb']; multiplicity unknown[missing]; }");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("B::n").unwrap();
+        let id = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb".parse().unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), id)]));
+        assert!(r.bind_id_spelled_references().contains(&id));
+        let previous = r.b.set_identity_origin(n.0);
+        assert_eq!(r.b.identity_origin_unit, Some(1));
+        r.b.identity_origin_unit = previous;
+        for name in ["exact", "unknown"] {
+            let element = r.resolve_qualified(&format!("B::{name}")).unwrap().0;
+            let (source, scope, range) =
+                r.b.multiplicities
+                    .iter()
+                    .find(|row| row.0 == element)
+                    .unwrap()
+                    .clone();
+            for context in [
+                eval::MultiplicityBoundContext::Lexical,
+                eval::MultiplicityBoundContext::Receiver(None),
+            ] {
+                for origin in [Some(0), None] {
+                    for initial in [0, eval::MAX_STEPS, usize::MAX] {
+                        r.b.identity_origin_unit = origin;
+                        let mut steps = initial;
+                        let value = eval::evaluate_multiplicity_bound(
+                            &mut r.b,
+                            source,
+                            scope,
+                            context,
+                            &range.upper,
+                            &mut steps,
+                        );
+                        assert_eq!(r.b.identity_origin_unit, origin);
+                        assert!(steps > initial || initial == usize::MAX);
+                        if initial == 0 && name == "exact" {
+                            assert_eq!(
+                                NumericBound::from_value(value.unwrap())
+                                    .unwrap()
+                                    .to_string(),
+                                "170141183460469231731687303715884105729"
+                            );
+                        } else {
+                            assert!(value.is_none());
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/relationships.rs b/crates/sysmlv2-model/src/check/relationships.rs
index 49f2762..36a3577 100644
--- a/crates/sysmlv2-model/src/check/relationships.rs
+++ b/crates/sysmlv2-model/src/check/relationships.rs
@@ -313,10 +313,10 @@ pub(super) fn validate(
     for (e, (scope, expr)) in super::user_entries(&r.b, model, r.b.values.iter()) {
         let unit = r.b.unit_of_elem(e);
         if let ExprKind::Ref(_) = &expr.kind {
-            if let (Some(context), Some(t)) = (
-                g.featuring(&r.b, e),
-                expressions::referent(&mut r.b, scope, &expr),
-            ) {
+            let origin = r.b.set_identity_origin(e);
+            let target = expressions::referent(&mut r.b, scope, &expr);
+            r.b.identity_origin_unit = origin;
+            if let (Some(context), Some(t)) = (g.featuring(&r.b, e), target) {
                 if !featured_within(&r.b, g, t, context) {
                     errors.push((
                         unit,
@@ -341,7 +341,9 @@ pub(super) fn validate(
             .collect();
         if let [ret] = returns.as_slice() {
             let a = g.typed(&r.b, *ret);
+            let origin = r.b.set_identity_origin(e);
             let z = expressions::types(&mut r.b, g, scope, &expr, 0);
+            r.b.identity_origin_unit = origin;
             bindings.push((unit, expr.span, a, z));
         }
     }
@@ -352,6 +354,7 @@ pub(super) fn validate(
         {
             let span = qn.span;
             let a = g.typed(&r.b, s);
+            let origin = r.b.set_identity_origin(e);
             let z = expressions::types(
                 &mut r.b,
                 g,
@@ -362,6 +365,7 @@ pub(super) fn validate(
                 },
                 0,
             );
+            r.b.identity_origin_unit = origin;
             bindings.push((unit, span, a, z));
         }
     }
diff --git a/crates/sysmlv2-model/src/check/scalars.rs b/crates/sysmlv2-model/src/check/scalars.rs
index e4887e8..1ffc8d5 100644
--- a/crates/sysmlv2-model/src/check/scalars.rs
+++ b/crates/sysmlv2-model/src/check/scalars.rs
@@ -56,7 +56,10 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
         if kinds.is_empty() || kinds.len() != tys.len() {
             continue;
         }
-        let Ok(v) = crate::eval::evaluate_expr_in(&mut r.b, scope, &expr) else {
+        let origin = r.b.set_identity_origin(owner);
+        let value = crate::eval::evaluate_expr_in(&mut r.b, scope, &expr);
+        r.b.identity_origin_unit = origin;
+        let Ok(v) = value else {
             continue; // undecided, not wrong
         };
         let Some(value_kind) = value_scalar_kind(&v) else {
@@ -207,3 +210,31 @@ fn declared_scalar_kind(b: &mut crate::json::Builder, ty: usize) -> Option<Scala
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn scalar_checks_restore_active_source_identity_on_every_outcome() {
+        let mut model = Model::new();
+        model.add_source("first.kerml", "package A;");
+        model.add_source("second.kerml", "package B { datatype Integer; feature n = 2; feature bound : Integer = '88888888-8888-4888-8888-888888888888'; feature invalid : Integer = true; feature unknown : Integer = missing; feature unbound; feature unconstrained = 3; feature empty : Integer = (); }");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("B::n").unwrap();
+        let id = "88888888-8888-4888-8888-888888888888".parse().unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), id)]));
+        assert!(r.bind_id_spelled_references().contains(&id));
+        let prior = r.b.set_identity_origin(n.0);
+        assert_eq!(r.b.identity_origin_unit, Some(1));
+        r.b.identity_origin_unit = prior;
+        for origin in [None, Some(0)] {
+            r.b.identity_origin_unit = origin;
+            let findings = validate(&mut r, &model);
+            assert_eq!(findings.len(), 1, "{findings:?}");
+            assert_eq!(r.b.identity_origin_unit, origin);
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/specialization.rs b/crates/sysmlv2-model/src/check/specialization.rs
index 37d985b..6a06c95 100644
--- a/crates/sysmlv2-model/src/check/specialization.rs
+++ b/crates/sysmlv2-model/src/check/specialization.rs
@@ -2,7 +2,7 @@
 //! subclassification cycles and duplicates, the metaclass a metadata
 //! feature is typed by, the conformance a redefinition owes its target,
 //! and the binariness a connector inherits through one.
-use super::user_rows;
+use super::multiplicity_domains::DomainRows;
 use crate::{json::ResolvedModel, model::Model};
 use std::collections::{HashMap, HashSet};
 use sysmlv2_syntax::diag::Diagnostic;
@@ -14,16 +14,23 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     // below skips library owners) and can't participate in a user-visible
     // cycle (no library edge points into a user definition) — skipping
     // them keeps the semantic pass proportional to the user model.
-    let specs = user_rows(&r.b, model, r.b.spec_targets.iter(), |row| row.0);
-    // Resolve every recorded target once.
+    let specs: Vec<_> =
+        r.b.spec_targets
+            .iter()
+            .enumerate()
+            .filter(|(_, row)| !model.is_library_unit(r.b.unit_of_elem(row.0)))
+            .map(|(i, row)| (i, row.clone()))
+            .collect();
+    // Pending resolution already applied source identity and header exclusions.
+    // Re-resolving display spellings can select a different element.
     let mut resolved: Vec<(
         usize,
         &'static str,
         usize,
         &sysmlv2_syntax::ast::QualifiedName,
     )> = Vec::new();
-    for (owner, kind, scope, qn) in &specs {
-        if let Some(t) = r.b.resolve(*scope, qn, 0) {
+    for (i, (owner, kind, _, qn)) in &specs {
+        if let Some(t) = r.b.spec_resolved.get(*i).copied().flatten() {
             resolved.push((*owner, kind, t, qn));
         }
     }
@@ -98,7 +105,7 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     // resolves to any other kind of element is provably wrong (error);
     // unresolved targets stay referential warnings, per checker policy.
     let mut metadata_typing_count: HashMap<usize, usize> = HashMap::new();
-    for (owner, kind, _, _) in &specs {
+    for (_, (owner, kind, _, _)) in &specs {
         if *kind == "FeatureTyping"
             && matches!(r.b.elements[*owner].ty, "MetadataUsage" | "MetadataFeature")
         {
@@ -143,21 +150,8 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
         }
     }
 
-    // Numeric bounds of a multiplicity: `[l..u]` directly, `[u]` is
-    // exact (`l = u`) except `[*]`, whose missing lower is 0.
-    let bounds = |r: &mut crate::json::ResolvedModel,
-                  scope: usize,
-                  m: &sysmlv2_syntax::ast::Multiplicity|
-     -> Option<(f64, f64)> {
-        let hi =
-            super::scalar_f64(&crate::eval::evaluate_expr_in(&mut r.b, scope, &m.upper).ok()?)?;
-        let lo = match &m.lower {
-            Some(l) => super::scalar_f64(&crate::eval::evaluate_expr_in(&mut r.b, scope, l).ok()?)?,
-            None if hi.is_infinite() => 0.0,
-            None => hi,
-        };
-        Some((lo, hi))
-    };
+    let domains = DomainRows::new(&r.b);
+    let mut reported_domains = HashSet::new();
 
     // --- redefinition type-compatibility ---
     // A redefining feature's declared types should conform to the
@@ -194,32 +188,43 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
             continue;
         }
         let qn = r.b.spec_targets[i].3.clone();
-        // Multiplicity conformance: when both sides declare
-        // explicit numeric multiplicities, the redefining range must
-        // lie within the redefined one.
-        // Copied out of the table because evaluating the bounds needs
-        // the builder mutably; only the two clauses in play are copied.
-        let declared = |r: &mut crate::json::ResolvedModel, e: usize| {
-            r.b.declared_multiplicity_of(e).map(|(s, m)| (s, m.clone()))
-        };
-        if let (Some((os, om)), Some((ts, tm))) = (declared(r, owner), declared(r, target)) {
-            let span = om.span;
-            if let (Some((olo, ohi)), Some((tlo, thi))) = (bounds(r, os, &om), bounds(r, ts, &tm)) {
-                // A subset may have fewer values; only redefinition must
-                // preserve the lower bound as well as the upper bound.
-                if (kind == "Redefinition" && olo < tlo) || ohi > thi {
-                    out.push((
-                        unit,
-                        Diagnostic::warning(
-                            span,
-                            if kind == "Redefinition" {
-                                format!("redefining multiplicity [{olo}..{ohi}] is not within the redefined feature's [{tlo}..{thi}]")
-                            } else {
-                                format!("subsetting multiplicity upper bound {ohi} exceeds the subsetted feature's upper bound {thi}")
-                            },
-                        ),
-                    ));
-                }
+        // Compare complete, explicitly constrained domains in the same receiver.
+        // A named domain's source span may belong to another file; findings for
+        // body/named constraints belong at this user's specialization site.
+        let span =
+            r.b.declared_multiplicity_of(owner)
+                .map_or(qn.span, |(_, m)| m.span);
+        let comparison = domains.compare(&mut r.b, owner, target);
+        if let Some(scope) = r.b.owner_scope_of(owner) {
+            reported_domains.extend(comparison.reported_rows.iter().map(|&row| (scope, row)));
+        }
+        for (general, reason) in comparison.invalid {
+            let subject = if general {
+                format!("multiplicity constraint from `{}`", qn.to_display_string())
+            } else {
+                "specializing multiplicity".into()
+            };
+            out.push((
+                unit,
+                Diagnostic::error(
+                    qn.span,
+                    format!("{subject} is invalid in this specializing context: {reason}"),
+                ),
+            ));
+        }
+        if let Some((own, general)) = comparison.intervals {
+            if (kind == "Redefinition" && own.lower < general.lower) || own.upper > general.upper {
+                out.push((
+                    unit,
+                    Diagnostic::warning(
+                        span,
+                        if kind == "Redefinition" {
+                            format!("redefining multiplicity [{}..{}] is not within the redefined feature's [{}..{}]", own.lower, own.upper, general.lower, general.upper)
+                        } else {
+                            format!("subsetting multiplicity upper bound {} exceeds the subsetted feature's upper bound {}", own.upper, general.upper)
+                        },
+                    ),
+                ));
             }
         }
         if kind == "Subsetting" {
@@ -254,6 +259,55 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
             ));
         }
     }
+    // An unchanged inherited Feature has no local specialization site. Its
+    // bounds must nevertheless remain valid after receiver value redefinition.
+    // Restrict this pass to non-Feature subclassifying receivers; nested
+    // instance/Feature contexts need an explicit evaluation environment.
+    let mut receivers = HashSet::new();
+    let mut providers = crate::json::provider_completeness::ProviderCompleteness::default();
+    for (receiver, kind, _, qn) in &resolved {
+        if *kind != "Subclassification"
+            || crate::metaclass::conforms(r.b.elements[*receiver].ty, "Feature")
+            || !receivers.insert(*receiver)
+        {
+            continue;
+        }
+        let Some(&scope) = r.b.elem_scope.get(receiver) else {
+            continue;
+        };
+        let mut steps = 0;
+        if !providers.scope(&mut r.b, scope, &mut steps) {
+            continue;
+        }
+        let Some(mut features) = r.b.cardinality_feature_candidates(*receiver, &mut steps) else {
+            continue;
+        };
+        features.retain(|&feature| {
+            r.b.owner_elem(feature) != Some(*receiver)
+                && !crate::metaclass::conforms(r.b.elements[feature].ty, "Multiplicity")
+        });
+        for (row, feature, reason) in
+            domains.inherited_invalid(&mut r.b, scope, &features, &mut steps)
+        {
+            if !reported_domains.insert((scope, row)) {
+                continue;
+            }
+            let name = r.b.elements[feature]
+                .props
+                .get("declaredName")
+                .and_then(|v| v.as_str())
+                .unwrap_or("<anonymous>");
+            out.push((
+                r.b.unit_of_elem(*receiver),
+                Diagnostic::error(
+                    qn.span,
+                    format!(
+                        "inherited multiplicity of `{name}` is invalid in this specializing context: {reason}"
+                    ),
+                ),
+            ));
+        }
+    }
     // --- connector binary specialization (KerML
     // checkConnectorBinarySpecialization) ---
     // A connector with more than two ends must not specialize a *binary*
@@ -343,3 +397,26 @@ pub(super) fn validate(r: &mut ResolvedModel, model: &Model) -> Vec<(usize, Diag
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trailing_shorthand_metadata_rows_have_pending_outcomes() {
+        for declaration in ["#M class C;", "class C { @M; }"] {
+            let mut model = Model::new();
+            model.add_source(
+                "test.kerml",
+                &format!("package P {{ metaclass M; {declaration} }}"),
+            );
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let target = r.resolve_qualified("P::M").unwrap().0;
+            assert_eq!(r.b.spec_targets.len(), 1);
+            assert_eq!(r.b.spec_resolved.len(), 1);
+            assert_eq!(r.b.spec_resolved[0], Some(target));
+            assert!(validate(&mut r, &model).is_empty());
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/check/structural.rs b/crates/sysmlv2-model/src/check/structural.rs
index c5eae94..7794e62 100644
--- a/crates/sysmlv2-model/src/check/structural.rs
+++ b/crates/sysmlv2-model/src/check/structural.rs
@@ -97,21 +97,6 @@ pub(super) fn validate(r: &ResolvedModel, model: &Model, g: &Facts) -> Vec<(usiz
                     "A feature redefining an end must itself be an end",
                 );
             }
-            let from = b.elements[*e]
-                .props
-                .get("direction")
-                .and_then(|v| v.as_str());
-            let to = g
-                .featuring(b, *e)
-                .and_then(|o| g.direction_through(b, o, t));
-            if from.is_some() && to.is_some() && from != to && to != Some("inout") {
-                report(
-                    *e,
-                    qn.span,
-                    "validateRedefinitionDirectionConformance",
-                    "A redefining feature must have a compatible direction",
-                );
-            }
             if g.featuring(b, *e).is_none() && g.featuring(b, t).is_none() {
                 report(
                     *e,
@@ -666,3 +651,39 @@ pub(super) fn validate(r: &ResolvedModel, model: &Model, g: &Facts) -> Vec<(usiz
     }
     out
 }
+
+/// Direction conformance shares the same contextual proof as repair proposals.
+pub(super) fn validate_directions(
+    r: &mut ResolvedModel,
+    model: &Model,
+    g: &Facts,
+) -> Vec<(usize, Diagnostic)> {
+    let candidates: Vec<_> =
+        r.b.spec_targets
+            .iter()
+            .enumerate()
+            .filter_map(|(i, (e, kind, _, qn))| {
+                if *kind != "Redefinition" {
+                    return None;
+                }
+                let t = r.b.spec_resolved.get(i).copied().flatten()?;
+                let unit = r.b.unit_of_elem(*e);
+                (!model.is_library_unit(unit)).then_some((*e, t, unit, qn.span))
+            })
+            .collect();
+    let mut proof = super::directions::RedefinitionDirections::default();
+    candidates
+        .into_iter()
+        .filter(|&(e, t, _, _)| proof.conformance(&mut r.b, g, e, t) == Some(false))
+        .map(|(_, _, unit, span)| {
+            (
+                unit,
+                super::rule_error(
+                    span,
+                    "validateRedefinitionDirectionConformance",
+                    "A redefining feature must have a compatible direction",
+                ),
+            )
+        })
+        .collect()
+}
diff --git a/crates/sysmlv2-model/src/check/values.rs b/crates/sysmlv2-model/src/check/values.rs
index 027fa1d..935cba3 100644
--- a/crates/sysmlv2-model/src/check/values.rs
+++ b/crates/sysmlv2-model/src/check/values.rs
@@ -21,13 +21,21 @@ pub(super) fn validate(
             continue;
         }
         let span = g.span(&r.b, e);
-        if let Some((_, value)) = r.b.values.get(&e) {
-            if g.redefined(&r.b, e)
-                .iter()
-                .any(|t| r.b.values.contains_key(t) && !r.b.default_values.contains(t))
+        if let Some(value_span) = r.b.values.get(&e).map(|(_, value)| value.span) {
+            if let Some(target) = g
+                .redefined(&r.b, e)
+                .into_iter()
+                .find(|t| r.b.values.contains_key(t) && !r.b.default_values.contains(t))
             {
-                out.push((unit, super::rule_error(value.span, "validateFeatureValueOverriding",
-                    "Cannot override an inherited binding value; the redefined value must be default")));
+                let name = r
+                    .element_qualified_name(ElementRef(target))
+                    .unwrap_or_else(|| format!("@{}", r.element_id(ElementRef(target))));
+                let target_unit = r.b.unit_of_elem(target);
+                let binding_span = r.b.values.get(&target).unwrap().1.span;
+                let source = &model.units()[target_unit];
+                let position = source.lines.line_col(binding_span.start);
+                out.push((unit, super::rule_error(value_span, "validateFeatureValueOverriding",
+                    format!("Cannot override the non-default value of `{name}`, bound at {}:{}:{}; the inherited value must be default to allow a new value", source.name, position.line, position.col))));
             }
         }
         if is(&r.b, e, "EnumerationUsage") {
@@ -99,8 +107,10 @@ pub(super) fn validate(
                         "A metadata body feature must redefine one feature of its metadata type")));
                 }
                 if let Some((scope, expr)) = r.b.values.get(&m).cloned() {
-                    if super::expressions::model_level(&mut r.b, g, scope, &expr, 0) == Some(false)
-                    {
+                    let origin = r.b.set_identity_origin(m);
+                    let evaluable = super::expressions::model_level(&mut r.b, g, scope, &expr, 0);
+                    r.b.identity_origin_unit = origin;
+                    if evaluable == Some(false) {
                         out.push((
                             unit,
                             super::rule_error(
@@ -117,7 +127,9 @@ pub(super) fn validate(
     for (e, scope, mult) in super::user_rows(&r.b, model, r.b.multiplicities.iter(), |row| row.0) {
         let unit = r.b.unit_of_elem(e);
         for expr in mult.lower.iter().chain(std::iter::once(&mult.upper)) {
+            let origin = r.b.set_identity_origin(e);
             let ts = super::expressions::types(&mut r.b, g, scope, expr, 0);
+            r.b.identity_origin_unit = origin;
             if !ts.is_empty() && ts.iter().all(|&t| !is(&r.b, t, "DataType")) {
                 out.push((
                     unit,
@@ -130,41 +142,46 @@ pub(super) fn validate(
             }
         }
     }
-    for (annotated, metas) in super::user_entries(&r.b, model, r.b.metadata_of.iter()) {
-        let unit = r.b.unit_of_elem(annotated);
-        for meta in metas {
-            let candidates: Vec<_> = g
-                .effective_members(&r.b, meta)
-                .into_iter()
-                .filter(|&member| {
-                    g.closure(member)
-                        .iter()
-                        .any(|&f| g.named(&r.b, f, "Metaobjects::Metaobject::annotatedElement"))
-                })
-                .collect();
-            // Separate subsetting features specify alternative permitted
-            // metaclasses; a single feature's multiple types are conjunctive.
-            let specific: Vec<_> = candidates
-                .iter()
-                .copied()
-                .filter(|t| {
-                    !candidates
-                        .iter()
-                        .any(|other| other != t && g.closure(*other).contains(t))
-                })
-                .collect();
-            if let Some(reflection) = r.b.reflection_metaclass(r.b.elements[annotated].ty) {
-                let actual = g.context(reflection);
-                let allowed: Vec<_> = specific.iter().map(|&m| g.typed(&r.b, m)).collect();
-                if !allowed.is_empty()
-                    && allowed.iter().all(|ts| !ts.is_empty())
-                    && !allowed
-                        .iter()
-                        .any(|ts| ts.iter().all(|t| actual.contains(t)))
-                {
-                    out.push((unit, super::rule_error(g.span(&r.b, meta), "validateMetadataFeatureAnnotatedElement",
+    let associations: Vec<_> = r
+        .b
+        .metadata_of
+        .iter()
+        .flat_map(|(&annotated, metas)| metas.iter().copied().map(move |meta| (annotated, meta)))
+        .filter(|&(_, meta)| !model.is_library_unit(r.b.unit_of_elem(meta)))
+        .collect();
+    for (annotated, meta) in associations {
+        let unit = r.b.unit_of_elem(meta);
+        let candidates: Vec<_> = g
+            .effective_members(&r.b, meta)
+            .into_iter()
+            .filter(|&member| {
+                g.closure(member)
+                    .iter()
+                    .any(|&f| g.named(&r.b, f, "Metaobjects::Metaobject::annotatedElement"))
+            })
+            .collect();
+        // Separate subsetting features specify alternative permitted
+        // metaclasses; a single feature's multiple types are conjunctive.
+        let specific: Vec<_> = candidates
+            .iter()
+            .copied()
+            .filter(|t| {
+                !candidates
+                    .iter()
+                    .any(|other| other != t && g.closure(*other).contains(t))
+            })
+            .collect();
+        if let Some(reflection) = r.b.reflection_metaclass(r.b.elements[annotated].ty) {
+            let actual = g.context(reflection);
+            let allowed: Vec<_> = specific.iter().map(|&m| g.typed(&r.b, m)).collect();
+            if !allowed.is_empty()
+                && allowed.iter().all(|ts| !ts.is_empty())
+                && !allowed
+                    .iter()
+                    .any(|ts| ts.iter().all(|t| actual.contains(t)))
+            {
+                out.push((unit, super::rule_error(g.span(&r.b, meta), "validateMetadataFeatureAnnotatedElement",
                         "The annotated element's metaclass does not conform to annotatedElement's type")));
-                }
             }
         }
     }
diff --git a/crates/sysmlv2-model/src/eval.rs b/crates/sysmlv2-model/src/eval.rs
index 6a8fe78..09fe190 100644
--- a/crates/sysmlv2-model/src/eval.rs
+++ b/crates/sysmlv2-model/src/eval.rs
@@ -10,11 +10,12 @@
 //! lambda bodies.
 //!
 //! KerML values are sequences; here scalars are singleton values and
-//! `null`/`()` is the empty [`Value::Sequence`]. Intrinsics are matched by
-//! the *last segment* of the invoked name (the Kernel Function Library
-//! names are treated as reserved), so models evaluated without the library
-//! loaded still compute. User-defined calculations — any resolvable element
-//! whose body carries a trailing result expression — invoke with
+//! `null`/`()` is the empty [`Value::Sequence`]. Resolved intrinsics are
+//! identified by their standard-library identity, including through aliases.
+//! Unresolved bare intrinsic names remain available without a library;
+//! declared functions and locally bound callees always take precedence.
+//! User-defined calculations — any resolvable element whose body carries a
+//! trailing result expression — invoke with
 //! positional and named arguments (parameters bind like lambda
 //! parameters; recursion is allowed to a fixed depth). Quantity brackets
 //! (`10 [mm]`) evaluate to [`Value::Quantity`]: units normalize to
@@ -49,7 +50,13 @@
 //! Documented v1 gaps (all reported as [`EvalError::Unsupported`]):
 //! extents (`all T`).
 
-use crate::json::{Builder, ElementRef, ResolvedModel, Tri};
+mod report;
+pub use report::{EvaluationDependency, EvaluationReport, InheritedDefaultFailure};
+
+use crate::json::{
+    Builder, CallableBody, CallableResult, ElementRef, ResolvedModel, RuntimeFrame,
+    RuntimeFrameProof, ScopeRef, Tri,
+};
 
 /// Owner-context library collections per member metaclass — the
 /// systems library's counterpart rows of SysML 8.4.2 Table 32 (the
@@ -68,8 +75,10 @@ fn implied_collection_extras(metaclass: &str) -> &'static [&'static str] {
 }
 use std::collections::{HashMap, HashSet};
 use std::fmt;
+use std::sync::OnceLock;
 use sysmlv2_syntax::Span;
 use sysmlv2_syntax::ast::*;
+use uuid::Uuid;
 
 pub use crate::rational::Rational;
 
@@ -811,6 +820,14 @@ impl fmt::Display for EvalError {
 }
 
 type Result_ = Result<Value, EvalError>;
+type Cardinality = (i128, Option<i128>);
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+enum CardinalityDomain {
+    Type,
+    Multiplicity,
+}
+type CardinalityKey = (usize, Option<usize>, CardinalityDomain);
+type CardinalityMemo = HashMap<CardinalityKey, Option<Cardinality>>;
 
 /// A control function's per-item computation: a `{ … }` lambda body, or
 /// a referenced function (`->reduce '+'`, `->minimize someCalc`).
@@ -825,7 +842,16 @@ pub(crate) fn evaluate_expr_in(b: &mut Builder, scope: usize, e: &Expr) -> Resul
     Evaluator {
         b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -851,7 +877,16 @@ pub(crate) fn evaluate_expr_with(
     Evaluator {
         b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides,
         unbound_receiver: None,
         lib_frames: 0,
@@ -872,7 +907,16 @@ pub(crate) fn unit_of_expr_in(b: &mut Builder, scope: usize, e: &Expr) -> Result
     Evaluator {
         b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -895,7 +939,16 @@ pub(crate) fn evaluate_query_in(b: &mut Builder, scope: usize, e: &Expr) -> Resu
     Evaluator {
         b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -907,10 +960,9 @@ pub(crate) fn evaluate_query_in(b: &mut Builder, scope: usize, e: &Expr) -> Resu
     .expr(scope, e)
 }
 
-/// [`evaluate_query_in`] with an initial environment: `env` binds names
-/// the expression may reference (a template's loop variables and
-/// inputs), innermost last — the rendering backend's entry point.
-pub(crate) fn evaluate_query_with_env(
+/// Query with external names for environment-shadowing regressions.
+#[cfg(test)]
+fn evaluate_query_with_env(
     b: &mut Builder,
     scope: usize,
     e: &Expr,
@@ -918,8 +970,25 @@ pub(crate) fn evaluate_query_with_env(
 ) -> Result_ {
     Evaluator {
         b,
-        env,
+        env: env
+            .into_iter()
+            .map(|(name, value)| EnvironmentBinding {
+                name,
+                value,
+                parameter: None,
+                frame: None,
+            })
+            .collect(),
+        lexical_scope: Some(scope),
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -931,12 +1000,185 @@ pub(crate) fn evaluate_query_with_env(
     .expr(scope, e)
 }
 
+/// Exact effective multiplicity, shared with symbolic translation.
+pub(crate) fn effective_cardinality(
+    model: &mut ResolvedModel,
+    e: ElementRef,
+) -> Option<Cardinality> {
+    Evaluator {
+        b: &mut model.b,
+        env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
+        in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
+        overrides: HashMap::new(),
+        unbound_receiver: None,
+        lib_frames: 0,
+        call_depth: 0,
+        steps: 0,
+        allocated: 0,
+        query: false,
+    }
+    .unbound_cardinality(e.0)
+}
+
+/// See [`ResolvedModel::implicit_open_multiplicity`]: the branch of
+/// [`Evaluator::cardinality_in`] that answers the open default, with no
+/// bound, subsetting or positional target to consult first.
+pub(crate) fn implicit_open_multiplicity(model: &mut ResolvedModel, e: ElementRef) -> bool {
+    let b = &mut model.b;
+    if !b.structural_usage(e.0)
+        || b.default_cardinality(e.0) != (0, None)
+        || b.local_multiplicity(e.0) != Some(None)
+        || b.declared_multiplicity_of(e.0).is_some()
+    {
+        return false;
+    }
+    let mut steps = 0;
+    matches!(b.cardinality_subset_targets(e.0, &mut steps), Some(targets) if targets.is_empty())
+        && matches!(b.cardinality_positional_targets(e.0, &mut steps), Some(targets) if targets.is_empty())
+}
+
+/// Current graph expressions admitted by the shared checked providers.
+#[derive(Default)]
+pub(crate) struct CheckedMultiplicityExpressions {
+    pub(crate) operators: HashMap<usize, (BinaryOp, Vec<usize>)>,
+    pub(crate) references: HashMap<usize, (usize, usize, usize)>,
+    pub(crate) universal_relationships: HashSet<usize>,
+}
+
+/// Read a structurally certified range through the same numeric/receiver evaluator.
+pub(crate) fn checked_multiplicity_domain(
+    b: &mut Builder,
+    e: usize,
+    context: Option<usize>,
+    operators: &CheckedMultiplicityExpressions,
+    steps: &mut usize,
+) -> Option<Cardinality> {
+    let mut evaluator = checked_multiplicity_evaluator(b, *steps);
+    let result = evaluator.multiplicity_domain(e, context, &mut HashMap::new(), Some(operators));
+    *steps = evaluator.steps;
+    result
+}
+
+/// Select a contextual referent with the same complete identity-based receiver
+/// evidence used by numeric execution. This does not evaluate stored source ASTs.
+pub(crate) fn checked_multiplicity_reference_target(
+    b: &mut Builder,
+    original: usize,
+    context: Option<usize>,
+    steps: &mut usize,
+) -> Option<usize> {
+    let mut evaluator = checked_multiplicity_evaluator(b, *steps);
+    let result = evaluator
+        .cardinality_reference_target(original, context)
+        .map(|(target, _)| target);
+    *steps = evaluator.steps;
+    result
+}
+
+fn checked_multiplicity_evaluator(b: &mut Builder, steps: usize) -> Evaluator<'_> {
+    Evaluator {
+        b,
+        env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
+        in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
+        overrides: HashMap::new(),
+        unbound_receiver: None,
+        lib_frames: 0,
+        call_depth: 0,
+        steps,
+        allocated: 0,
+        query: false,
+    }
+}
+
+/// Distinguishes declaration-level validity from valuation in a specializing
+/// receiver. A body range's lexical scope need not be its featuring receiver.
+#[derive(Clone, Copy)]
+pub(crate) enum MultiplicityBoundContext {
+    Lexical,
+    Receiver(Option<usize>),
+}
+
+/// A declaration bound evaluated in a specified specializing receiver, retaining
+/// exact numeric values. Validation shares the query budget across domain edges
+/// and expressions; it must not substitute Feature cardinality for a range value.
+pub(crate) fn evaluate_multiplicity_bound(
+    b: &mut Builder,
+    source: usize,
+    scope: usize,
+    context: MultiplicityBoundContext,
+    expr: &Expr,
+    steps: &mut usize,
+) -> Option<Value> {
+    *steps = steps.saturating_add(1);
+    if *steps > MAX_STEPS {
+        return None;
+    }
+    let origin = b.set_identity_origin(source);
+    let mut evaluator = Evaluator {
+        b,
+        env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
+        in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
+        overrides: HashMap::new(),
+        unbound_receiver: None,
+        lib_frames: 0,
+        call_depth: 0,
+        steps: *steps,
+        allocated: 0,
+        query: false,
+    };
+    let value = match context {
+        MultiplicityBoundContext::Lexical => evaluator.expr(scope, expr).ok(),
+        MultiplicityBoundContext::Receiver(receiver) => {
+            evaluator.cardinality_bound(scope, receiver, expr)
+        }
+    };
+    *steps = evaluator.steps;
+    evaluator.b.identity_origin_unit = origin;
+    value
+}
+
 /// Evaluate the feature-value expression of `e`.
 pub(crate) fn evaluate_feature(model: &mut ResolvedModel, e: ElementRef) -> Result_ {
     Evaluator {
         b: &mut model.b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -948,6 +1190,50 @@ pub(crate) fn evaluate_feature(model: &mut ResolvedModel, e: ElementRef) -> Resu
     .feature_value(e.0)
 }
 
+fn evaluate_report_with(
+    b: &mut Builder,
+    evaluate: impl FnOnce(&mut Evaluator<'_>) -> Result_,
+) -> EvaluationReport {
+    let mut evaluator = Evaluator {
+        b,
+        env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: Some(Box::default()),
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
+        in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
+        overrides: HashMap::new(),
+        unbound_receiver: None,
+        lib_frames: 0,
+        call_depth: 0,
+        steps: 0,
+        allocated: 0,
+        query: false,
+    };
+    let result = evaluate(&mut evaluator);
+    evaluator
+        .report
+        .take()
+        .expect("report collector")
+        .finish(result)
+}
+
+pub(crate) fn evaluate_feature_report(
+    model: &mut ResolvedModel,
+    e: ElementRef,
+) -> EvaluationReport {
+    evaluate_report_with(&mut model.b, |evaluator| evaluator.feature_value(e.0))
+}
+
+pub(crate) fn evaluate_expr_report(b: &mut Builder, scope: usize, expr: &Expr) -> EvaluationReport {
+    evaluate_report_with(b, |evaluator| evaluator.expr(scope, expr))
+}
+
 /// Evaluate the feature chain `root.m1.m2…` off an already-resolved
 /// root element: each member is a chain step over the value so far, so
 /// every receiver establishes the featuring context and redefinitions
@@ -960,7 +1246,16 @@ pub(crate) fn evaluate_chain_of(
     let mut ev = Evaluator {
         b: &mut model.b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -976,6 +1271,71 @@ pub(crate) fn evaluate_chain_of(
     Ok(v)
 }
 
+/// Charge recursive value traversal before cloning or comparing chain values.
+/// This also bounds the depth of externally constructed receivers.
+fn charge_chain_value(value: &Value, steps: &mut usize, depth: usize) -> Result<(), EvalError> {
+    *steps = steps.saturating_add(1);
+    if *steps > MAX_STEPS || depth > MAX_CALL_DEPTH {
+        return Err(EvalError::Budget("chain exceeds traversal budget".into()));
+    }
+    match value {
+        Value::Sequence(items) => {
+            for value in items {
+                charge_chain_value(value, steps, depth + 1)?;
+            }
+        }
+        Value::Instance { fields, .. } => {
+            for (_, value) in fields {
+                charge_chain_value(value, steps, depth + 1)?;
+            }
+        }
+        Value::Quantity(value, _) => charge_chain_value(value, steps, depth + 1)?,
+        _ => {}
+    }
+    Ok(())
+}
+
+/// A chain over a value whose source reference has already been evaluated.
+/// Validate externally supplied structure before recursive chain traversal.
+pub(crate) fn evaluate_value_chain(
+    model: &mut ResolvedModel,
+    target: Value,
+    members: &[&QualifiedName],
+) -> Result_ {
+    if members.iter().any(|m| m.segments.is_empty()) {
+        return Err(EvalError::Unsupported("empty chain member name".into()));
+    }
+    if members.is_empty() {
+        return Ok(target);
+    }
+    let mut ev = Evaluator {
+        b: &mut model.b,
+        env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
+        in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
+        overrides: HashMap::new(),
+        unbound_receiver: None,
+        lib_frames: 0,
+        call_depth: 0,
+        steps: 0,
+        allocated: 0,
+        query: false,
+    };
+    let mut value = target;
+    for member in members {
+        value = ev.chain_into(value, member)?;
+    }
+    Ok(value)
+}
+
 /// Evaluate `member` as a chain step off `receiver` — the semantics of
 /// `receiver.member`, so the receiver establishes the featuring context
 /// and its redefinitions shadow inherited values. Returns `None` when
@@ -990,7 +1350,16 @@ pub(crate) fn evaluate_member_of(
     let mut ev = Evaluator {
         b: &mut model.b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -1004,6 +1373,7 @@ pub(crate) fn evaluate_member_of(
             v @ (Value::Element(_)
             | Value::Unbound(_)
             | Value::UnboundMember(_)
+            | Value::Indeterminate
             | Value::Sequence(_)
             | Value::Instance { .. }),
         ) => v,
@@ -1019,7 +1389,8 @@ pub(crate) fn evaluate_member_of(
 /// bound (`1..1000000000`, a calculation doubling a string on every
 /// recursion, nested collects over large ranges, a product folding into
 /// a million-digit integer) fails with [`EvalError::Budget`] instead of
-/// hanging or exhausting memory. Steps count expression nodes; the
+/// hanging or exhausting memory. Steps count expression nodes and recursive
+/// chain traversal/comparison work; the
 /// allocation budget counts the bytes of every sequence or string an
 /// operator materializes, so many individually admissible values cannot
 /// add up without bound; exact numbers are refused past
@@ -1040,10 +1411,41 @@ pub const MAX_ALLOCATION: usize = 256 << 20;
 /// not a deep model.
 pub const MAX_CALL_DEPTH: usize = 64;
 
+#[derive(Clone, Copy)]
+struct CardinalityContext {
+    scope: Option<usize>,
+    /// Once a dependency is rebased, broader local evaluation cannot bypass
+    /// identity selection by calling into a locally declared sibling.
+    rebased: bool,
+    /// Conservative sum of syntax depths on the active dependency path.
+    depth: usize,
+}
+
+enum CardinalityFormulaLimit {
+    Unsupported,
+    Depth,
+}
+
+#[derive(Clone)]
+struct EnvironmentBinding {
+    name: String,
+    parameter: Option<usize>,
+    frame: Option<usize>,
+    value: Value,
+}
+
 struct Evaluator<'m> {
     b: &'m mut Builder,
     /// Lambda- and calculation-parameter bindings, innermost last.
-    env: Vec<(String, Value)>,
+    env: Vec<EnvironmentBinding>,
+    /// Declaration scope for runtime parameter admission, independent of receivers.
+    lexical_scope: Option<usize>,
+    call_frames: Vec<RuntimeFrame>,
+    frame_proofs: RuntimeFrameProof,
+    report: Option<Box<report::Collector>>,
+    /// Cache admission records hidden failures even when diagnostics are disabled.
+    inherited_failure_epoch: usize,
+    value_scopes: crate::json::ValueScopeResolver,
     /// (feature, evaluation scope) pairs currently being evaluated
     /// (cycle guard — context-aware, see [`Self::feature_value_in`]).
     in_progress: HashSet<(usize, usize)>,
@@ -1052,6 +1454,12 @@ struct Evaluator<'m> {
     /// requirement's subject binds to the satisfying feature); empty
     /// everywhere else.
     overrides: HashMap<usize, Value>,
+    /// Bounds can themselves call size; guard both bound and heritage cycles.
+    cardinality_in_progress: HashSet<CardinalityKey>,
+    /// A bound formula keeps its lexical scope while references select values
+    /// by identity in this featuring context. None means ordinary evaluation.
+    cardinality_context: Option<CardinalityContext>,
+    cardinality_providers: crate::json::provider_completeness::ProviderCompleteness,
     /// Depth of library-owned calculation bodies on the call stack.
     /// Inside them, unbound features keep the closed [`Value::Element`]
     /// convention (library functions legitimately count and compare
@@ -1130,6 +1538,41 @@ impl Evaluator<'_> {
         }
     }
 
+    /// Intersect visibility atomically: proof failure leaves every frame intact.
+    fn mask_frames(&mut self, lexical: usize, receiver: usize) -> Result<Vec<usize>, EvalError> {
+        let mut hidden = Vec::new();
+        for (index, &frame) in self.call_frames.iter().enumerate() {
+            if frame.visible
+                && !self
+                    .frame_proofs
+                    .permits_builder(
+                        self.b,
+                        frame,
+                        ScopeRef(lexical),
+                        ScopeRef(receiver),
+                        &mut self.steps,
+                    )
+                    .ok_or_else(|| {
+                        EvalError::Unsupported(
+                            "runtime frame visibility is incomplete or exceeds the budget".into(),
+                        )
+                    })?
+            {
+                hidden.push(index);
+            }
+        }
+        for &index in &hidden {
+            self.call_frames[index].visible = false;
+        }
+        Ok(hidden)
+    }
+
+    fn restore_frames(&mut self, hidden: Vec<usize>) {
+        for index in hidden {
+            self.call_frames[index].visible = true;
+        }
+    }
+
     fn feature_value_in(&mut self, e: usize, ctx: Option<usize>) -> Result_ {
         // Reading a local/output directly must not bypass the refusal at
         // invocation: its initializer need not be its value after execution.
@@ -1145,8 +1588,8 @@ impl Evaluator<'_> {
         if let Some(v) = self.overrides.get(&e) {
             return Ok(v.clone());
         }
-        let (scope, expr, inherited) = match self.b.values.get(&e).cloned() {
-            Some((s, x)) => (s, x, false),
+        let (scope, expr, inherited, origin) = match self.b.values.get(&e).cloned() {
+            Some((s, x)) => (s, x, false, e),
             // A redefining feature with no value of its own inherits a
             // `default` value expression from its redefinition target
             // (KerML FeatureValue isDefault: a default applies unless
@@ -1157,16 +1600,73 @@ impl Evaluator<'_> {
             // survives redefinition is spec-ambiguous, so those stay
             // unbound (the element itself) as before.
             None => match (self.inherited_default(e), self.b.owner_scope_of(e)) {
-                (Some(expr), Some(s)) => (s, expr, true),
+                (Some((origin, expr)), Some(s)) => (s, expr, true, origin),
                 _ => return Ok(self.placeholder(e)),
             },
         };
         if (inherited || self.b.default_values.contains(&e)) && self.receiver_member(e).is_some() {
             return Ok(Value::Indeterminate);
         }
-        let scope = ctx.unwrap_or(scope);
+        let scope = match self.value_scopes.select_builder(
+            self.b,
+            origin,
+            ctx.or(Some(scope)),
+            &mut self.steps,
+        ) {
+            crate::json::ValueScopeDecision::Lexical(scope)
+            | crate::json::ValueScopeDecision::Receiver(scope) => scope.0,
+            crate::json::ValueScopeDecision::Unsupported => {
+                return Err(EvalError::Unsupported(
+                    "value receiver identity is incomplete or ambiguous".into(),
+                ));
+            }
+        };
+        let dependency = EvaluationDependency {
+            requested: ElementRef(e),
+            origin: ElementRef(origin),
+            receiver: ScopeRef(scope),
+        };
+        if let Some(report) = &mut self.report {
+            report.push(dependency);
+        }
+        let result = self.stored_feature_value(dependency, &expr, inherited);
+        if let Some(report) = &mut self.report {
+            report.pop();
+        }
+        result
+    }
+
+    fn record_inherited_failure(
+        &mut self,
+        dependency: EvaluationDependency,
+        span: Span,
+        error: EvalError,
+    ) {
+        self.inherited_failure_epoch = self.inherited_failure_epoch.saturating_add(1);
+        if let Some(report) = &mut self.report {
+            report.record(
+                dependency,
+                self.b.unit_of_elem(dependency.origin.0),
+                span,
+                error,
+            );
+        }
+    }
+
+    fn stored_feature_value(
+        &mut self,
+        dependency: EvaluationDependency,
+        expr: &Expr,
+        inherited: bool,
+    ) -> Result_ {
+        let EvaluationDependency {
+            requested: ElementRef(e),
+            origin: ElementRef(origin),
+            receiver: ScopeRef(scope),
+        } = dependency;
         if !self.in_progress.insert((e, scope)) {
-            if inherited {
+            if inherited && self.report.is_none() {
+                self.inherited_failure_epoch = self.inherited_failure_epoch.saturating_add(1);
                 return Ok(self.placeholder(e));
             }
             let name = self.b.elements[e]
@@ -1175,19 +1675,41 @@ impl Evaluator<'_> {
                 .and_then(|v| v.as_str())
                 .unwrap_or("<anonymous>")
                 .to_string();
-            return Err(EvalError::Cycle(name));
+            let error = EvalError::Cycle(name);
+            if inherited {
+                self.record_inherited_failure(dependency, expr.span, error);
+                return Ok(self.placeholder(e));
+            }
+            return Err(error);
         }
-        let out = self.expr(scope, &expr);
+        let declaration = self.b.values.get(&origin).map(|(s, _)| *s).unwrap_or(scope);
+        let hidden = match self.mask_frames(declaration, scope) {
+            Ok(hidden) => hidden,
+            Err(error) => {
+                self.in_progress.remove(&(e, scope));
+                return Err(error);
+            }
+        };
+        let saved_origin = self.b.set_identity_origin(origin);
+        let lexical = self.lexical_scope;
+        self.lexical_scope = Some(declaration);
+        let out = self.expr(scope, expr);
+        self.lexical_scope = lexical;
+        self.b.identity_origin_unit = saved_origin;
+        self.restore_frames(hidden);
         self.in_progress.remove(&(e, scope));
         // The inherited-default path is best-effort: a default written for
         // the general feature may reference names its defining scope
         // imported that the redefining context cannot reach — degrade to
         // the unbound element (the pre-fallback answer) instead of
         // erroring, so downstream member access keeps working.
-        if inherited && out.is_err() {
-            return Ok(self.placeholder(e));
+        match out {
+            Err(error) if inherited => {
+                self.record_inherited_failure(dependency, expr.span, error);
+                Ok(self.placeholder(e))
+            }
+            result => result,
         }
-        out
     }
 
     /// The nearest `default` value expression on the redefinition-target
@@ -1195,7 +1717,7 @@ impl Evaluator<'_> {
     /// targets). A target carrying a *non-default* value ends the walk —
     /// whether such a binding survives redefinition is spec-ambiguous, so
     /// the caller keeps the feature unbound.
-    fn inherited_default(&mut self, e: usize) -> Option<Expr> {
+    fn inherited_default(&mut self, e: usize) -> Option<(usize, Expr)> {
         let mut seen = HashSet::new();
         let mut frontier = vec![e];
         while let Some(cur) = frontier.pop() {
@@ -1205,7 +1727,7 @@ impl Evaluator<'_> {
             for t in self.b.redefinition_target_elems(cur) {
                 if let Some((_, expr)) = self.b.values.get(&t) {
                     let expr = expr.clone();
-                    return self.b.default_values.contains(&t).then_some(expr);
+                    return self.b.default_values.contains(&t).then_some((t, expr));
                 }
                 frontier.push(t);
             }
@@ -1213,28 +1735,502 @@ impl Evaluator<'_> {
         None
     }
 
-    /// The knowable cardinality of an unbound feature, from its declared
-    /// multiplicity: `(lower, upper)` bounds, `[1..1]` when none is
-    /// written (the KerML default), `None` when the bounds cannot be
-    /// evaluated.
-    fn unbound_cardinality(&mut self, e: usize) -> Option<(f64, f64)> {
-        let Some((scope, m)) = self
-            .b
-            .multiplicities
-            .iter()
-            .find(|(o, _, _)| *o == e)
-            .map(|(_, s, m)| (*s, m.clone()))
-        else {
-            return Some((1.0, 1.0));
+    /// Exact nonnegative bounds from local declarations and supported heritage.
+    /// An absent upper bound denotes infinity; an unknown result must never
+    /// be interpreted as a singleton. Inherited references retain their identity
+    /// unless a supported redefinition applies. Inherited ranges intersect.
+    fn unbound_cardinality(&mut self, e: usize) -> Option<(i128, Option<i128>)> {
+        self.cardinality_in(e, self.b.owner_scope_of(e), &mut HashMap::new())
+    }
+
+    fn cardinality_in(
+        &mut self,
+        e: usize,
+        context: Option<usize>,
+        memo: &mut CardinalityMemo,
+    ) -> Option<Cardinality> {
+        let key = (e, context, CardinalityDomain::Type);
+        if let Some(bounds) = memo.get(&key) {
+            return *bounds;
+        }
+        self.steps += 1;
+        if self.steps > MAX_STEPS {
+            return None;
+        }
+        if self.cardinality_in_progress.len() >= MAX_CALL_DEPTH
+            || !self.cardinality_in_progress.insert(key)
+        {
+            return None;
+        }
+        let result = (|| {
+            let local_multiplicity = self.b.local_multiplicity(e)?;
+            if let Some((scope, m)) = self.b.declared_multiplicity_of(e) {
+                let m = m.clone();
+                let bound = |value| match value {
+                    Value::Integer(n) if n >= 0 => Some(Some(n)),
+                    Value::Real(n) if n == f64::INFINITY => Some(None),
+                    _ => None,
+                };
+                let origin = self.b.set_identity_origin(e);
+                let result = (|| {
+                    let upper = bound(self.cardinality_bound(scope, context, &m.upper)?)?;
+                    let lower = match m.lower {
+                        Some(lower) => bound(self.cardinality_bound(scope, context, &lower)?)??,
+                        None => upper.unwrap_or(0),
+                    };
+                    upper.is_none_or(|hi| lower <= hi).then_some((lower, upper))
+                })();
+                self.b.identity_origin_unit = origin;
+                return result;
+            }
+            if let Some(m) = local_multiplicity {
+                return self.multiplicity_domain(m, context, memo, None);
+            }
+            let mut targets = self.b.cardinality_subset_targets(e, &mut self.steps)?;
+            let default = self.b.default_cardinality(e);
+            if targets.is_empty() && default == (1, Some(1)) {
+                return Some(default);
+            }
+            for target in self.b.cardinality_positional_targets(e, &mut self.steps)? {
+                if !targets.contains(&target) {
+                    targets.push(target);
+                }
+            }
+            if targets.is_empty() {
+                return Some(default);
+            }
+            let mut lower = 0;
+            let mut upper: Option<i128> = None;
+            for target in targets {
+                let (lo, hi) = self.cardinality_in(target, context, memo)?;
+                lower = lower.max(lo);
+                upper = match (upper, hi) {
+                    (Some(a), Some(b)) => Some(a.min(b)),
+                    (a, b) => a.or(b),
+                };
+            }
+            upper.is_none_or(|hi| lower <= hi).then_some((lower, upper))
+        })();
+        self.cardinality_in_progress.remove(&key);
+        memo.insert(key, result);
+        result
+    }
+
+    /// A Multiplicity's numeric value domain is distinct from its own Feature
+    /// cardinality. Follow stored graph identities, including named constraints
+    /// whose subsettings have no textual specialization-index entry.
+    fn multiplicity_domain(
+        &mut self,
+        e: usize,
+        context: Option<usize>,
+        memo: &mut CardinalityMemo,
+        operators: Option<&CheckedMultiplicityExpressions>,
+    ) -> Option<Cardinality> {
+        let key = (e, context, CardinalityDomain::Multiplicity);
+        if let Some(bounds) = memo.get(&key) {
+            return *bounds;
+        }
+        self.steps += 1;
+        if self.steps > MAX_STEPS
+            || self.cardinality_in_progress.len() >= MAX_CALL_DEPTH
+            || !self.cardinality_in_progress.insert(key)
+        {
+            return None;
+        }
+        let result = (|| {
+            let ty = self.b.elements[e].ty;
+            if !crate::metaclass::conforms(ty, "Multiplicity") {
+                return None;
+            }
+            let mut bounds = None;
+            if ty == "MultiplicityRange" {
+                let members = self.b.owned_member_elems(e, false);
+                let count = members
+                    .iter()
+                    .take_while(|&&m| {
+                        crate::metaclass::conforms(self.b.elements[m].ty, "Expression")
+                    })
+                    .count();
+                if !(1..=2).contains(&count)
+                    || members[count..]
+                        .iter()
+                        .any(|&m| crate::metaclass::conforms(self.b.elements[m].ty, "Expression"))
+                {
+                    return None;
+                }
+                let upper =
+                    self.certified_multiplicity_bound(members[count - 1], context, operators)?;
+                let lower = if count == 2 {
+                    self.certified_multiplicity_bound(members[0], context, operators)??
+                } else {
+                    upper.unwrap_or(0)
+                };
+                if upper.is_some_and(|hi| lower > hi) {
+                    return None;
+                }
+                bounds = Some((lower, upper));
+            }
+            let relationships = self.b.elements[e].owned_relationships.clone();
+            for r in relationships {
+                if operators.is_some_and(|proof| proof.universal_relationships.contains(&r)) {
+                    continue;
+                }
+                let rel = &self.b.elements[r];
+                if !crate::metaclass::conforms(rel.ty, "Specialization") {
+                    continue;
+                }
+                let property = match rel.ty {
+                    "Subsetting" => "subsettedFeature",
+                    "Redefinition" => "redefinedFeature",
+                    _ => return None,
+                };
+                let id = rel.props.get(property)?.as_reference()?;
+                let target = self.b.element_index_of_uuid(id)?;
+                let (lo, hi) = self.multiplicity_domain(target, context, memo, operators)?;
+                bounds = Some(match bounds {
+                    None => (lo, hi),
+                    Some((lower, upper)) => (
+                        lower.max(lo),
+                        match (upper, hi) {
+                            (Some(a), Some(b)) => Some(a.min(b)),
+                            (a, b) => a.or(b),
+                        },
+                    ),
+                });
+            }
+            let (lower, upper) = bounds?;
+            upper.is_none_or(|hi| lower <= hi).then_some((lower, upper))
+        })();
+        self.cardinality_in_progress.remove(&key);
+        memo.insert(key, result);
+        result
+    }
+
+    /// Execute certified graph operands through the same exact arithmetic as
+    /// ordinary evaluation. Source syntax is never substituted for edited rows.
+    fn certified_multiplicity_bound(
+        &mut self,
+        e: usize,
+        context: Option<usize>,
+        operators: Option<&CheckedMultiplicityExpressions>,
+    ) -> Option<Option<i128>> {
+        let Some(operators) = operators else {
+            return self.multiplicity_bound(e, context);
         };
-        let as_num = |v: Value| v.as_f64();
-        let hi = as_num(self.expr(scope, &m.upper).ok()?)?;
-        let lo = match &m.lower {
-            Some(l) => as_num(self.expr(scope, l).ok()?)?,
-            None if hi.is_infinite() => 0.0,
-            None => hi,
+        match self.certified_multiplicity_value(e, context, operators, 0)? {
+            Value::Integer(n) if n >= 0 => Some(Some(n)),
+            Value::Real(n) if n == f64::INFINITY => Some(None),
+            _ => None,
+        }
+    }
+    fn certified_multiplicity_value(
+        &mut self,
+        e: usize,
+        context: Option<usize>,
+        operators: &CheckedMultiplicityExpressions,
+        depth: usize,
+    ) -> Option<Value> {
+        use crate::properties::Atom;
+        self.steps = self.steps.saturating_add(1);
+        if depth >= MAX_CALL_DEPTH || self.steps > MAX_STEPS {
+            return None;
+        }
+        match self.b.elements[e].ty {
+            "LiteralInfinity" => Some(Value::Real(f64::INFINITY)),
+            "LiteralInteger" => Some(Value::Integer(
+                match self.b.elements[e].props.get("value")? {
+                    Atom::Number(n) => i128::from(n.as_i64()?),
+                    Atom::String(s) => s.parse::<i128>().ok()?,
+                    _ => return None,
+                },
+            )),
+            "FeatureReferenceExpression" => {
+                let &(original, certified_target, value) = operators.references.get(&e)?;
+                let (selected, _) = self.cardinality_reference_target(original, context)?;
+                // The selected value graph was certified in this exact receiver.
+                if selected != certified_target {
+                    return None;
+                }
+                self.certified_multiplicity_value(value, context, operators, depth + 1)
+            }
+            "OperatorExpression" => {
+                let (operator, operands) = operators.operators.get(&e)?;
+                let first = self.certified_multiplicity_value(
+                    *operands.first()?,
+                    context,
+                    operators,
+                    depth + 1,
+                )?;
+                if operands.len() == 1 {
+                    return match operator {
+                        BinaryOp::Add => Some(first),
+                        BinaryOp::Sub => arith(BinaryOp::Sub, Value::Integer(0), first).ok(),
+                        _ => None,
+                    };
+                }
+                if operands.len() != 2 {
+                    return None;
+                }
+                let second =
+                    self.certified_multiplicity_value(operands[1], context, operators, depth + 1)?;
+                arith(*operator, first, second).ok()
+            }
+            _ => None,
+        }
+    }
+
+    /// Read graph bounds without converting exact integers through floating
+    /// point or resolving a stored reference again by its display name.
+    fn multiplicity_bound(&mut self, e: usize, context: Option<usize>) -> Option<Option<i128>> {
+        use crate::properties::Atom;
+        match self.b.elements[e].ty {
+            "LiteralInfinity" => Some(None),
+            "LiteralInteger" => {
+                let n = match self.b.elements[e].props.get("value")? {
+                    Atom::Number(n) => i128::from(n.as_i64()?),
+                    Atom::String(s) => s.parse::<i128>().ok()?,
+                    _ => return None,
+                };
+                (n >= 0).then_some(Some(n))
+            }
+            "FeatureReferenceExpression" => match self.multiplicity_reference_value(e, context)? {
+                Value::Integer(n) if n >= 0 => Some(Some(n)),
+                Value::Real(n) if n == f64::INFINITY => Some(None),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn multiplicity_reference_value(&mut self, e: usize, context: Option<usize>) -> Option<Value> {
+        if self.call_depth > 0 {
+            return None;
+        }
+        let mut refs = self.b.elements[e]
+            .owned_relationships
+            .iter()
+            .filter(|&&r| self.b.elements[r].ty == "Membership");
+        let r = *refs.next()?;
+        if refs.next().is_some() {
+            return None;
+        }
+        let id = self.b.elements[r]
+            .props
+            .get("memberElement")?
+            .as_reference()?;
+        let target = self.b.element_index_of_uuid(id)?;
+        let env = std::mem::take(&mut self.env);
+        let frames = std::mem::take(&mut self.call_frames);
+        let origin = self.b.set_identity_origin(e);
+        let value = self.cardinality_reference_value(target, context);
+        self.b.identity_origin_unit = origin;
+        self.env = env;
+        self.call_frames = frames;
+        value
+    }
+
+    /// FeatureReferenceExpression valuation follows referent identity and
+    /// redefinition, independently of the spelling used to reach that referent.
+    fn cardinality_reference_value(
+        &mut self,
+        original: usize,
+        context: Option<usize>,
+    ) -> Option<Value> {
+        let (target, rebased) = self.cardinality_reference_target(original, context)?;
+        self.cardinality_feature_value(target, context, rebased)
+    }
+
+    fn cardinality_reference_target(
+        &mut self,
+        original: usize,
+        context: Option<usize>,
+    ) -> Option<(usize, bool)> {
+        let owner = self.b.owner_elem(original);
+        if owner.is_none_or(|owner| !crate::metaclass::conforms(self.b.elements[owner].ty, "Type"))
+        {
+            // Root and package references keep their lexical identity, but the value
+            // expression still evaluates on the same target. A dependency may
+            // refer back to a member that the receiver redefines.
+            let (scope, _) = self.b.values.get(&original)?;
+            return Some((original, context.is_some_and(|s| s != *scope)));
+        }
+        let owner = owner?;
+        let receiver = context.and_then(|s| self.b.scope_owner(s))?;
+        if !crate::metaclass::conforms(self.b.elements[receiver].ty, "Type") {
+            return None;
+        }
+        let scope = *self.b.elem_scope.get(&receiver)?;
+        if !self
+            .cardinality_providers
+            .scope(self.b, scope, &mut self.steps)
+        {
+            return None;
+        }
+        let candidates = self
+            .b
+            .cardinality_feature_candidates(receiver, &mut self.steps)?;
+        let mut memo = HashMap::new();
+        let mut active = HashSet::new();
+        let mut selected = None;
+        for candidate in candidates {
+            if self.cardinality_redefines(candidate, original, &mut memo, &mut active)?
+                && selected
+                    .replace(candidate)
+                    .is_some_and(|previous| previous != candidate)
+            {
+                return None;
+            }
+        }
+        let target = selected?;
+        Some((target, receiver != owner || target != original))
+    }
+
+    fn cardinality_feature_value(
+        &mut self,
+        target: usize,
+        context: Option<usize>,
+        rebased: bool,
+    ) -> Option<Value> {
+        let (_, value) = self.b.values.get(&target)?;
+        if self.in_progress.len() >= MAX_CALL_DEPTH {
+            return None;
+        }
+        let rebased = rebased || self.cardinality_context.is_some_and(|c| c.rebased);
+        // Preserve the existing broader local evaluator. Once a formula or
+        // dependency has been rebased, calls/chains need separate contracts.
+        let previous = self.cardinality_context;
+        match Self::cardinality_scalar_expression_depth(value, 0) {
+            Ok(depth) => {
+                let depth = depth.checked_add(previous.map_or(0, |c| c.depth))?;
+                if depth > MAX_CALL_DEPTH {
+                    return None;
+                }
+                self.cardinality_context = Some(CardinalityContext {
+                    scope: context,
+                    rebased,
+                    depth,
+                });
+            }
+            Err(CardinalityFormulaLimit::Unsupported) if !rebased => {
+                self.cardinality_context = None;
+            }
+            Err(_) => return None,
+        }
+        let result = self.feature_value_in(target, None).ok();
+        self.cardinality_context = previous;
+        result
+    }
+
+    /// Admit bounded contextual formulas before entering the ordinary operator
+    /// evaluator. Broader local evaluation retains its existing behavior;
+    /// feature dependency depth is guarded separately above.
+    fn cardinality_scalar_expression_depth(
+        expr: &Expr,
+        depth: usize,
+    ) -> Result<usize, CardinalityFormulaLimit> {
+        if depth >= MAX_CALL_DEPTH {
+            return Err(CardinalityFormulaLimit::Depth);
+        }
+        let nested = |e| Self::cardinality_scalar_expression_depth(e, depth + 1);
+        match &expr.kind {
+            ExprKind::Literal(_) | ExprKind::Ref(_) => Ok(1),
+            ExprKind::Unary { operand, .. } => Ok(1 + nested(operand)?),
+            ExprKind::Binary { op, lhs, rhs } => {
+                if matches!(op, BinaryOp::Range | BinaryOp::NullCoalescing) {
+                    return Err(CardinalityFormulaLimit::Unsupported);
+                }
+                Ok(1 + nested(lhs)?.max(nested(rhs)?))
+            }
+            ExprKind::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+            } => Ok(1 + nested(cond)?
+                .max(nested(then_branch)?)
+                .max(nested(else_branch)?)),
+            _ => Err(CardinalityFormulaLimit::Unsupported),
+        }
+    }
+
+    fn cardinality_redefines(
+        &mut self,
+        candidate: usize,
+        original: usize,
+        memo: &mut HashMap<usize, bool>,
+        active: &mut HashSet<usize>,
+    ) -> Option<bool> {
+        if let Some(&result) = memo.get(&candidate) {
+            return Some(result);
+        }
+        self.steps += 1;
+        if self.steps > MAX_STEPS || active.len() >= MAX_CALL_DEPTH || !active.insert(candidate) {
+            return None;
+        }
+        let result = (|| {
+            let mut found = candidate == original;
+            for target in self
+                .b
+                .cardinality_redefinition_targets(candidate, &mut self.steps)?
+            {
+                found |= self.cardinality_redefines(target, original, memo, active)?;
+            }
+            Some(found)
+        })();
+        active.remove(&candidate);
+        if let Some(found) = result {
+            memo.insert(candidate, found);
+        }
+        result
+    }
+
+    /// A bound belongs to its declaration, not the caller's lambda environment.
+    /// Select member valuations only through proven redefinition identities;
+    /// lexical features outside the featuring type keep their original value.
+    fn cardinality_bound(
+        &mut self,
+        scope: usize,
+        context: Option<usize>,
+        expr: &Expr,
+    ) -> Option<Value> {
+        // Bound formulas do not yet substitute active runtime arguments.
+        // Clearing that environment must not expose a declaration default
+        // as the supplied argument.
+        if self.call_depth > 0 && !matches!(expr.kind, ExprKind::Literal(_)) {
+            return None;
+        }
+        let env = std::mem::take(&mut self.env);
+        let frames = std::mem::take(&mut self.call_frames);
+        let result = (|| {
+            if let ExprKind::Ref(qn) = &expr.kind {
+                let original = self.b.resolve(scope, qn, 0)?;
+                return self.cardinality_reference_value(original, context);
+            }
+            // Arbitrary inherited expressions still need identity-aware
+            // dependency mapping. Literal bounds never depend on a receiver.
+            if matches!(expr.kind, ExprKind::Literal(_)) || context.is_none_or(|s| s == scope) {
+                self.expr(scope, expr).ok()
+            } else {
+                None
+            }
+        })();
+        self.env = env;
+        self.call_frames = frames;
+        result
+    }
+
+    fn value_cardinality(&mut self, value: &Value) -> Option<Cardinality> {
+        let (Value::Unbound(ElementRef(e)) | Value::UnboundMember(ElementRef(e))) = value else {
+            return None;
         };
-        Some((lo, hi))
+        let previous = self.unbound_receiver;
+        if matches!(value, Value::UnboundMember(_)) {
+            // A symbolic bound must not become concrete by reading a default
+            // on the type of an unknown receiver.
+            self.unbound_receiver = self.b.owner_elem(*e);
+        }
+        let result = self.unbound_cardinality(*e);
+        self.unbound_receiver = previous;
+        result
     }
 
     /// The single exit for a freshly materialized value: it charges a
@@ -1271,7 +2267,16 @@ impl Evaluator<'_> {
         match &e.kind {
             ExprKind::Literal(l) => self.literal(l),
             ExprKind::Null => Ok(Value::null()),
-            ExprKind::Ref(qn) => self.reference(scope, qn),
+            ExprKind::Ref(qn) => {
+                if let Some(context) = self.cardinality_context {
+                    let value = self.b.resolve(scope, qn, 0).and_then(|original| {
+                        self.cardinality_reference_value(original, context.scope)
+                    });
+                    Ok(value.unwrap_or(Value::Indeterminate))
+                } else {
+                    self.reference(scope, qn)
+                }
+            }
             ExprKind::Conditional {
                 cond,
                 then_branch,
@@ -1330,12 +2335,12 @@ impl Evaluator<'_> {
                 // sequence.
                 match &tval {
                     Value::Indeterminate => return Ok(Value::Indeterminate),
-                    Value::Unbound(ElementRef(e)) | Value::UnboundMember(ElementRef(e)) => {
-                        let bounds = self.unbound_cardinality(*e);
-                        let admitted = i >= 1
-                            && bounds.is_none_or(|(_, hi)| hi.is_infinite() || i as f64 <= hi);
+                    Value::Unbound(_) | Value::UnboundMember(_) => {
+                        let bounds = self.value_cardinality(&tval);
+                        let admitted =
+                            i >= 1 && bounds.is_none_or(|(_, hi)| hi.is_none_or(|hi| i <= hi));
                         if admitted {
-                            return if i == 1 && bounds.is_some_and(|(_, hi)| hi <= 1.0) {
+                            return if i == 1 && bounds == Some((1, Some(1))) {
                                 Ok(tval)
                             } else {
                                 Ok(Value::Indeterminate)
@@ -1345,6 +2350,14 @@ impl Evaluator<'_> {
                     }
                     _ => {}
                 }
+                // A chain can yield a partial sequence whose unknown entry
+                // denotes an entire collection. Its flattened positions are
+                // unknown, so it cannot count as one slot before indexing.
+                // Keep the direct-placeholder bound checks above intact.
+                let tval = self.collection_value(tval);
+                if matches!(tval, Value::Indeterminate) {
+                    return Ok(tval);
+                }
                 let items = tval.items();
                 // KerML sequence indexing is 1-based.
                 usize::try_from(i)
@@ -1439,11 +2452,11 @@ impl Evaluator<'_> {
                     let name = a.name.as_ref().map(|n| n.to_display_string());
                     values.push((name, self.expr(scope, &a.value)?));
                 }
-                // Kernel Function Library names are reserved: intrinsics
-                // first (positional only), user-defined calculations after.
+                // Only recognized library targets (or unresolved convenience
+                // names) use the intrinsic implementation.
                 if values.iter().all(|(n, _)| n.is_none()) {
                     let positional: Vec<Value> = values.iter().map(|(_, v)| v.clone()).collect();
-                    match self.intrinsic(ty, &positional) {
+                    match self.intrinsic(scope, ty, &positional) {
                         Err(EvalError::Unsupported(_)) => {}
                         out => return out,
                     }
@@ -1452,11 +2465,15 @@ impl Evaluator<'_> {
             }
             ExprKind::Constructor { ty, args } => self.construct(scope, ty, args),
             ExprKind::Body { members } => self.body_result(scope, members),
-            ExprKind::BodyTerminator => self.body_result(scope, &[]),
             ExprKind::Sequence(items) => {
                 let mut out = Vec::new();
                 for i in items {
-                    out.extend(self.expr(scope, i)?.items());
+                    let value = self.expr(scope, i)?;
+                    let value = self.collection_value(value);
+                    if matches!(value, Value::Indeterminate) {
+                        return Ok(value);
+                    }
+                    out.extend(value.items());
                 }
                 self.charged(Value::Sequence(out))
             }
@@ -1518,14 +2535,104 @@ impl Evaluator<'_> {
         self.placeholder(anchor)
     }
 
-    fn reference(&mut self, scope: usize, qn: &QualifiedName) -> Result_ {
-        // Lambda parameters shadow model names.
-        if qn.segments.len() == 1 && !qn.is_global {
-            let name = &qn.segments[0].value;
-            if let Some((_, v)) = self.env.iter().rev().find(|(n, _)| n == name) {
-                return Ok(v.clone());
+    /// Runtime arguments are attached to declarations, not written spellings.
+    /// Name bindings are reserved for external query/standalone environments.
+    fn environment_value(
+        &mut self,
+        scope: usize,
+        qn: &QualifiedName,
+    ) -> Result<Option<Value>, EvalError> {
+        if self.env.is_empty() && self.call_frames.is_empty() {
+            return Ok(None);
+        }
+        let lexical = self.lexical_scope.unwrap_or(scope);
+        let reference = self.b.reference_identity(lexical, qn);
+        let external_name = (!reference.identity_bound && !qn.is_global && qn.segments.len() == 1)
+            .then(|| qn.segments[0].value.as_str());
+        for frame in (0..self.call_frames.len())
+            .rev()
+            .map(Some)
+            .chain(std::iter::once(None))
+        {
+            if frame.is_some_and(|i| !self.call_frames[i].visible) {
+                continue;
+            }
+            if let Some(binding) = self.env.iter().rev().find(|binding| {
+                binding.frame == frame
+                    && match binding.parameter {
+                        Some(parameter) => reference.target == Some(ElementRef(parameter)),
+                        None => external_name == Some(binding.name.as_str()),
+                    }
+            }) {
+                let visible = match binding.parameter {
+                    Some(parameter) => self.b.runtime_parameter_visible_with_steps(
+                        parameter,
+                        lexical,
+                        &mut self.steps,
+                    ).ok_or_else(|| EvalError::Unsupported(
+                        "runtime parameter lexical scope is incomplete or exceeds the budget".into(),
+                    ))?,
+                    None => true,
+                };
+                if visible {
+                    return Ok(Some(binding.value.clone()));
+                }
+            }
+            if let (Some(frame), Some(target)) = (frame, reference.target) {
+                let Some(callee) = self.call_frames[frame].callee else {
+                    continue;
+                };
+                match self.b.runtime_parameter_selection_with_steps(
+                    callee.0,
+                    lexical,
+                    scope,
+                    target.0,
+                    &mut self.steps,
+                ) {
+                    crate::json::RuntimeParameterSelection::Selected(parameter) => {
+                        if let Some(binding) = self.env.iter().rev().find(|binding| {
+                            binding.frame == Some(frame) && binding.parameter == Some(parameter.0)
+                        }) {
+                            return Ok(Some(binding.value.clone()));
+                        }
+                        // Defaults can depend on later omitted inputs. Read the
+                        // selected declaration rather than its general's default.
+                        if parameter != target {
+                            return self
+                                .feature_value_in(
+                                    parameter.0,
+                                    Some(self.call_frames[frame].receiver_scope.0),
+                                )
+                                .map(Some);
+                        }
+                    }
+                    crate::json::RuntimeParameterSelection::NotApplicable => {}
+                    crate::json::RuntimeParameterSelection::Unsupported => {
+                        return Err(EvalError::Unsupported(
+                            "runtime parameter redefinition is incomplete or ambiguous".into(),
+                        ));
+                    }
+                }
+            }
+        }
+        // A declined runtime binding must not reappear as the default of an
+        // unrelated parameter selected by receiver-name lookup.
+        if let Some(receiver_target) = self.b.resolve(scope, qn, 0) {
+            if reference.target != Some(ElementRef(receiver_target))
+                && self.b.is_parameter(receiver_target)
+            {
+                return Err(EvalError::Unsupported(
+                    "receiver lookup selects an unrelated parameter declaration".into(),
+                ));
             }
         }
+        Ok(None)
+    }
+
+    fn reference(&mut self, scope: usize, qn: &QualifiedName) -> Result_ {
+        if let Some(value) = self.environment_value(scope, qn)? {
+            return Ok(value);
+        }
         let Some(mut elem) = self.b.resolve(scope, qn, 0) else {
             // KerML `that` lives on the implied root feature `things`,
             // an implied specialization the resolver does not
@@ -1735,6 +2842,32 @@ impl Evaluator<'_> {
         self.chain_into(target, member)
     }
 
+    /// Materialize only a collection whose members are available. A
+    /// placeholder with multiplicity greater than one is not one member,
+    /// and flattening a tuple must not turn it into one. Closed model
+    /// elements (reflection results) still denote individual declarations.
+    fn collection_value(&mut self, value: Value) -> Value {
+        match value {
+            v @ (Value::Unbound(_) | Value::UnboundMember(_)) => match self.value_cardinality(&v) {
+                Some((0, Some(0))) => Value::null(),
+                Some((1, Some(1))) => v,
+                _ => Value::Indeterminate,
+            },
+            Value::Sequence(items) => {
+                let mut out = Vec::new();
+                for item in items {
+                    let item = self.collection_value(item);
+                    if matches!(item, Value::Indeterminate) {
+                        return item;
+                    }
+                    out.extend(item.items());
+                }
+                Value::Sequence(out)
+            }
+            v => v,
+        }
+    }
+
     /// One chain step over an evaluated target. Per KFL `'.'`, a
     /// multi-valued source maps the member access over its items and the
     /// result feature is *unique* (its `source`/`target` are declared
@@ -1747,6 +2880,11 @@ impl Evaluator<'_> {
     /// Uncertainty follows the evaluated receiver, including a receiver
     /// returned by an alias, conditional or calculation.
     fn chain_into(&mut self, target: Value, member: &QualifiedName) -> Result_ {
+        charge_chain_value(&target, &mut self.steps, 0)?;
+        if member.segments.is_empty() {
+            return Err(EvalError::Unsupported("empty chain member name".into()));
+        }
+        let target = self.collection_value(target);
         // An unknown target has nothing to resolve a member against, and
         // the step is as parametric as the target was: strictly
         // propagating (see [`Value::Indeterminate`]) rather than a type
@@ -1758,7 +2896,16 @@ impl Evaluator<'_> {
             let mut out: Vec<Value> = Vec::new();
             for item in items {
                 for v in self.chain_into(item, member)?.items() {
-                    if !out.iter().any(|x| value_eq(x, &v)) {
+                    let mut duplicate = false;
+                    for x in &out {
+                        charge_chain_value(x, &mut self.steps, 0)?;
+                        charge_chain_value(&v, &mut self.steps, 0)?;
+                        if value_eq(x, &v) {
+                            duplicate = true;
+                            break;
+                        }
+                    }
+                    if !duplicate {
                         out.push(v);
                     }
                 }
@@ -1811,279 +2958,21 @@ impl Evaluator<'_> {
         // materialize as relationships. `p.performedActions` collects
         // p's perform usages, each standing for its referenced action.
         if !unbound && !self.b.values.contains_key(&hit) {
-            // A named slot answers with its owned parts before the general
-            // collection rule, which would otherwise collect the slot
-            // itself (it specializes the member it redefines).
-            if let Some(v) = self.slot_projection(elem, hit)? {
-                return Ok(v);
-            }
             if let Some(items) = self.collection_items(elem, hit)? {
-                return Ok(match items.len() {
-                    1 => items.into_iter().next().unwrap(),
-                    _ => Value::Sequence(items),
-                });
-            }
-            if let Some(v) = self.dom_projection(elem, hit)? {
-                return Ok(v);
-            }
-        }
-        // Evaluate fixed formulas in the unknown receiver's context too:
-        // `eligible = willing` fixes the formula, not a default on willing.
-        // A concrete receiver establishes a fresh, known context.
-        let previous = self.unbound_receiver;
-        self.unbound_receiver = unbound.then_some(elem);
-        let value = self.feature_value_in(hit, sub);
-        self.unbound_receiver = previous;
-        value
-    }
-
-    /// A named slot's value: when the receiver owns a part that only
-    /// redefines `hit` (`part <n> :>> body { … }`, `:>> props { … }`),
-    /// that member's value is the slot's owned parts in membership order
-    /// — ownership is the sufficient representation. `None` when the
-    /// receiver owns no such slot.
-    fn slot_projection(&mut self, receiver: usize, hit: usize) -> Result<Option<Value>, EvalError> {
-        let owned = self.b.owned_member_elems(receiver, true);
-        let mut slot = None;
-        for m in owned {
-            if self.b.elements[m].ty != "PartUsage" || !self.is_dom_slot(m) {
-                continue;
-            }
-            // Only the *redefined* member projects; the slot addressed by
-            // its own short name stays the slot (a fragment node).
-            if self.b.redefinition_target_elems(m).contains(&hit) {
-                slot = Some(m);
-                break;
-            }
-        }
-        let Some(slot) = slot else {
-            return Ok(None);
-        };
-        let mut items = Vec::new();
-        for m in self.b.owned_member_elems(slot, true) {
-            if self.b.elements[m].ty == "PartUsage" {
-                items.extend(self.feature_value_in(m, None)?.items());
-            }
-        }
-        Ok(Some(match items.len() {
-            1 => items.into_iter().next().unwrap(),
-            _ => Value::Sequence(items),
-        }))
-    }
-
-    /// The Web platform library's constructed navigation: an imported
-    /// document stores only structural
-    /// ownership, so a derived DOM member reached on a node usage —
-    /// `childNodes`, `children`, `firstChild`, `lastChild`, `parentNode`,
-    /// `parentElement`, the sibling views, `childElementCount`,
-    /// `attributes` — is projected from the receiver's owned parts in
-    /// membership order: tree nodes are the owned parts that do not
-    /// conform to `Attr`; attributes are the ones that do. Applies only
-    /// to members declared by `Web::DOM`, so user features of the same
-    /// names are untouched. `None` for any other member.
-    fn dom_projection(&mut self, receiver: usize, hit: usize) -> Result<Option<Value>, EvalError> {
-        const NAV: &[&str] = &[
-            "childNodes",
-            "children",
-            "firstChild",
-            "lastChild",
-            "parentNode",
-            "parentElement",
-            "previousSibling",
-            "nextSibling",
-            "firstElementChild",
-            "lastElementChild",
-            "previousElementSibling",
-            "nextElementSibling",
-            "childElementCount",
-            "attributes",
-        ];
-        // A redefining member (`:>> attributes : AttributeLike[0..*]`)
-        // carries its name through the redefinition, not a declaration.
-        let Some(name) = self.b.id_name(hit) else {
-            return Ok(None);
-        };
-        if !NAV.contains(&name.as_str()) {
-            return Ok(None);
-        }
-        let scope = self.b.elem_scope.get(&receiver).copied().unwrap_or(0);
-        let attr_def = self
-            .b
-            .resolve(scope, &crate::json::lib_qn("Web::DOM::Attr"), 0);
-        let element_def = self
-            .b
-            .resolve(scope, &crate::json::lib_qn("Web::DOM::Element"), 0);
-        let node_def = self
-            .b
-            .resolve(scope, &crate::json::lib_qn("Web::DOM::Node"), 0);
-        let (Some(attr_def), Some(element_def), Some(node_def)) = (attr_def, element_def, node_def)
-        else {
-            return Ok(None);
-        };
-        // The member is a DOM view when it (or a feature it redefines) is
-        // declared inside `Web::DOM`, or when its owning definition is a
-        // node kind (a template element's redefined `attributes`).
-        let owner_is_node = self
-            .b
-            .owner_elem(hit)
-            .is_some_and(|o| self.b.conforms_upward(o, node_def));
-        if !owner_is_node && !self.redefines_web_dom_member(hit) {
-            return Ok(None);
-        }
-        let is_part = |b: &Builder, e: usize| b.elements[e].ty == "PartUsage";
-        // The receiver's owned parts split into tree nodes and attributes.
-        // A slot — a part with no typing of its own that redefines a
-        // collection (`part <n> :>> body { … }`, `:>> props { … }`) — is
-        // transparent: its owned parts are projected in its place.
-        let (nodes, attrs) = self.dom_owned(receiver, attr_def, node_def);
-        let mut elements = Vec::new();
-        for &m in &nodes {
-            if self.b.conforms_upward(m, element_def) {
-                elements.push(m);
-            }
-        }
-        // The receiver among its owner's tree nodes, for the parent and
-        // sibling views (a package-level node has no DOM parent, and an
-        // attribute is never a child of the element owning it).
-        let parent = if self.b.conforms_upward(receiver, attr_def) {
-            None
-        } else {
-            // Through transparent slots up to the nearest typed node.
-            let mut cur = self.b.owner_elem(receiver);
-            while let Some(o) = cur {
-                if !is_part(self.b, o) {
-                    cur = None;
-                    break;
-                }
-                if !self.is_dom_slot(o) {
-                    break;
-                }
-                cur = self.b.owner_elem(o);
-            }
-            cur.filter(|&o| self.b.conforms_upward(o, node_def))
-        };
-        let siblings: Vec<usize> = match parent {
-            Some(p) => self.dom_owned(p, attr_def, node_def).0,
-            None => Vec::new(),
-        };
-        let at = siblings.iter().position(|&m| m == receiver);
-        let before = |v: &[usize], i: Option<usize>| i.and_then(|i| v[..i].last().copied());
-        let after = |v: &[usize], i: Option<usize>| i.and_then(|i| v.get(i + 1).copied());
-        let element_siblings: Vec<usize> = {
-            let mut out = Vec::new();
-            for &m in &siblings {
-                if self.b.conforms_upward(m, element_def) {
-                    out.push(m);
-                }
-            }
-            out
-        };
-        let at_el = element_siblings.iter().position(|&m| m == receiver);
-        let picked: Vec<usize> = match name.as_str() {
-            "childNodes" => nodes,
-            "children" => elements,
-            "firstChild" => nodes.first().copied().into_iter().collect(),
-            "lastChild" => nodes.last().copied().into_iter().collect(),
-            "firstElementChild" => elements.first().copied().into_iter().collect(),
-            "lastElementChild" => elements.last().copied().into_iter().collect(),
-            "parentNode" => parent.into_iter().collect(),
-            "parentElement" => parent
-                .filter(|&p| self.b.conforms_upward(p, element_def))
-                .into_iter()
-                .collect(),
-            "previousSibling" => before(&siblings, at).into_iter().collect(),
-            "nextSibling" => after(&siblings, at).into_iter().collect(),
-            "previousElementSibling" => before(&element_siblings, at_el).into_iter().collect(),
-            "nextElementSibling" => after(&element_siblings, at_el).into_iter().collect(),
-            "childElementCount" => return Ok(Some(Value::Integer(elements.len() as i128))),
-            "attributes" => attrs,
-            _ => return Ok(None),
-        };
-        let mut items = Vec::with_capacity(picked.len());
-        for m in picked {
-            items.extend(self.feature_value_in(m, None)?.items());
-        }
-        Ok(Some(match items.len() {
-            1 => items.into_iter().next().unwrap(),
-            _ => Value::Sequence(items),
-        }))
-    }
-
-    /// The receiver's owned tree nodes and attributes in membership
-    /// order, transparent slots flattened.
-    fn dom_owned(
-        &mut self,
-        receiver: usize,
-        attr_def: usize,
-        node_def: usize,
-    ) -> (Vec<usize>, Vec<usize>) {
-        let mut nodes = Vec::new();
-        let mut attrs = Vec::new();
-        let mut stack: Vec<Vec<usize>> = vec![self.b.owned_member_elems(receiver, true)];
-        // Depth-first in order: a slot's members replace the slot.
-        let mut queue: Vec<usize> = Vec::new();
-        while let Some(batch) = stack.pop() {
-            queue.extend(batch);
-        }
-        let mut i = 0;
-        while i < queue.len() {
-            let m = queue[i];
-            i += 1;
-            if self.b.elements[m].ty != "PartUsage" {
-                continue;
-            }
-            if self.is_dom_slot(m) {
-                let inner = self.b.owned_member_elems(m, true);
-                queue.splice(i..i, inner);
-                continue;
-            }
-            if self.b.conforms_upward(m, attr_def) {
-                attrs.push(m);
-            } else if self.b.conforms_upward(m, node_def) {
-                nodes.push(m);
-            }
-        }
-        (nodes, attrs)
-    }
-
-    /// A part usage that only redefines (no typing of its own): a named
-    /// slot of a template block or component.
-    fn is_dom_slot(&mut self, e: usize) -> bool {
-        let specs = self.b.explicit_specialization_elems(e);
-        !specs.is_empty() && specs.iter().all(|(kind, _)| *kind == "Redefinition")
-    }
-
-    /// Does `e`, or a feature it (transitively) redefines, live inside
-    /// `Web::DOM`?
-    fn redefines_web_dom_member(&mut self, e: usize) -> bool {
-        let mut seen = HashSet::new();
-        let mut stack = vec![e];
-        while let Some(x) = stack.pop() {
-            if !seen.insert(x) {
-                continue;
-            }
-            if self.declared_in_web_dom(x) {
-                return true;
-            }
-            stack.extend(self.b.redefinition_target_elems(x));
-        }
-        false
-    }
-
-    /// Is `e` a member declared inside package `Web::DOM` (by owner
-    /// chain: some owner named `DOM` whose owner is named `Web`)?
-    fn declared_in_web_dom(&self, e: usize) -> bool {
-        let mut cur = self.b.owner_elem(e);
-        while let Some(o) = cur {
-            let owner = self.b.owner_elem(o);
-            if self.b.effective_name(o).as_deref() == Some("DOM")
-                && owner.is_some_and(|w| self.b.effective_name(w).as_deref() == Some("Web"))
-            {
-                return true;
+                return Ok(match items.len() {
+                    1 => items.into_iter().next().unwrap(),
+                    _ => Value::Sequence(items),
+                });
             }
-            cur = owner;
         }
-        false
+        // Evaluate fixed formulas in the unknown receiver's context too:
+        // `eligible = willing` fixes the formula, not a default on willing.
+        // A concrete receiver establishes a fresh, known context.
+        let previous = self.unbound_receiver;
+        self.unbound_receiver = unbound.then_some(elem);
+        let value = self.feature_value_in(hit, sub);
+        self.unbound_receiver = previous;
+        value
     }
 
     /// The values of the receiver's owned features that specialize
@@ -2273,14 +3162,20 @@ impl Evaluator<'_> {
             return hit.value;
         }
         let imports = std::mem::take(&mut self.b.used_imports);
+        let failure_epoch = self.inherited_failure_epoch;
         let value = self.expanded_unit_uncached(scope, elem, name, depth);
-        self.b.semantic_memo.units.insert(
-            key,
-            crate::semantic_memo::Proven {
-                value: value.clone(),
-                imports: self.b.used_imports.iter().copied().collect(),
-            },
-        );
+        // A cached conversion must not hide a suppressed default failure from
+        // a later report. Apply the same admission in legacy/report modes so
+        // observing diagnostics does not change semantic budget consumption.
+        if failure_epoch != usize::MAX && failure_epoch == self.inherited_failure_epoch {
+            self.b.semantic_memo.units.insert(
+                key,
+                crate::semantic_memo::Proven {
+                    value: value.clone(),
+                    imports: self.b.used_imports.iter().copied().collect(),
+                },
+            );
+        }
         self.b.used_imports.extend(imports);
         value
     }
@@ -2503,7 +3398,16 @@ impl Evaluator<'_> {
             .b
             .resolve(scope, qn, 0)
             .ok_or_else(|| EvalError::Unresolved(qn.to_display_string()))?;
-        let items = self.expr(scope, operand)?.items();
+        let value = self.expr(scope, operand)?;
+        let value = if matches!(op, ClassificationOp::AtType) {
+            value
+        } else {
+            self.collection_value(value)
+        };
+        if matches!(value, Value::Indeterminate) {
+            return Ok(value);
+        }
+        let items = value.items();
         match op {
             ClassificationOp::As => {
                 // Three-valued: a decided non-member drops, an *undecided*
@@ -2618,19 +3522,16 @@ impl Evaluator<'_> {
     /// referenced element. Lambda parameters shadow model names, as in
     /// plain references.
     fn metadata_access(&mut self, scope: usize, target: &QualifiedName) -> Result_ {
-        if target.segments.len() == 1 && !target.is_global {
-            let name = &target.segments[0].value;
-            if let Some((_, v)) = self.env.iter().rev().find(|(n, _)| n == name) {
-                let (Value::Element(ElementRef(e))
-                | Value::Unbound(ElementRef(e))
-                | Value::UnboundMember(ElementRef(e))) = v.clone()
-                else {
-                    return Err(EvalError::Type(
-                        "`.metadata` applies to model elements".into(),
-                    ));
-                };
-                return self.metaobjects_of(e);
-            }
+        if let Some(value) = self.environment_value(scope, target)? {
+            let (Value::Element(ElementRef(e))
+            | Value::Unbound(ElementRef(e))
+            | Value::UnboundMember(ElementRef(e))) = value
+            else {
+                return Err(EvalError::Type(
+                    "`.metadata` applies to model elements".into(),
+                ));
+            };
+            return self.metaobjects_of(e);
         }
         let elem = self
             .b
@@ -2646,6 +3547,11 @@ impl Evaluator<'_> {
     /// metaclass carrying the element's scalar abstract-syntax
     /// properties as bound fields.
     fn metaobjects_of(&mut self, elem: usize) -> Result_ {
+        if self.b.metadata_associations_incomplete {
+            return Err(EvalError::Unsupported(
+                "metadata annotation associations are incomplete".into(),
+            ));
+        }
         let mut out: Vec<Value> = self
             .b
             .metadata_of
@@ -2840,42 +3746,26 @@ impl Evaluator<'_> {
     /// element itself, or a feature *typed* by one (a function-typed
     /// parameter — `in calculation : Interpolate` — invoked in a body)?
     fn callee_is_calculation(&mut self, elem: usize) -> bool {
-        let calcish = |ty: &str| {
-            ty.contains("Calculation")
-                || ty.contains("Constraint")
-                || ty.contains("Expression")
-                || ty == "Function"
-                || ty == "Predicate"
-        };
-        if calcish(self.b.elements[elem].ty) {
+        if crate::json::calculation_like(self.b.elements[elem].ty) {
             return true;
         }
         self.b
             .direct_typing_elems(elem)
             .into_iter()
-            .any(|t| calcish(self.b.elements[t].ty))
+            .any(|t| crate::json::calculation_like(self.b.elements[t].ty))
     }
 
-    /// Effective input parameters of a calculation element. Calculation
-    /// usages commonly declare no parameters of their own and inherit the
-    /// signature from their typed calculation definition (`getOutput:
-    /// GetOutput`), so bodiless-call validation must walk explicit supertypes
-    /// instead of treating the usage as a zero-argument function.
-    fn callee_params(&mut self, elem: usize) -> Vec<String> {
-        let mut stack = vec![elem];
-        let mut seen = HashSet::new();
-        while let Some(e) = stack.pop() {
-            if !seen.insert(e) {
-                continue;
-            }
-            if let Some(params) = self.b.in_params.get(&e) {
-                if !params.is_empty() {
-                    return params.clone();
-                }
-            }
-            stack.extend(self.b.explicit_supertype_elems(e));
+    /// The results an invocation of `elem` evaluates, with the callables
+    /// that declare them (see [`ResolvedModel::callable_body`]): one, or
+    /// every result equally near when different generals each declare one.
+    fn calc_bodies(&mut self, elem: usize) -> Option<Vec<(usize, CallableResult)>> {
+        match self.b.callable_body(elem)? {
+            CallableBody::Declared { owner, result } => Some(vec![(owner.0, result)]),
+            CallableBody::Ambiguous(owners) => owners
+                .into_iter()
+                .map(|owner| Some((owner.0, self.b.own_callable_result(owner.0)?)))
+                .collect(),
         }
-        Vec::new()
     }
 
     /// Invoke a user-defined calculation (any element whose body carries a
@@ -2893,27 +3783,18 @@ impl Evaluator<'_> {
         let (display, elem) = match ty {
             TargetRef::Name(qn) => {
                 let display = qn.to_display_string();
-                if qn.segments.len() == 1 && !qn.is_global {
-                    let name = &qn.segments[0].value;
-                    let bound = self
-                        .env
-                        .iter()
-                        .rev()
-                        .find(|(n, _)| n == name)
-                        .map(|(_, v)| v.clone());
-                    if let Some(value) = bound {
-                        return match value {
-                            Value::Element(ElementRef(elem))
-                            | Value::Unbound(ElementRef(elem))
-                            | Value::UnboundMember(ElementRef(elem)) => {
-                                self.user_calc_elem(&display, elem, args)
-                            }
-                            Value::Indeterminate => Ok(Value::Indeterminate),
-                            other => Err(EvalError::Type(format!(
-                                "function `{display}` is bound to non-callable value {other}"
-                            ))),
-                        };
-                    }
+                if let Some(value) = self.environment_value(scope, qn)? {
+                    return match value {
+                        Value::Element(ElementRef(elem))
+                        | Value::Unbound(ElementRef(elem))
+                        | Value::UnboundMember(ElementRef(elem)) => {
+                            self.user_calc_elem(&display, elem, args)
+                        }
+                        Value::Indeterminate => Ok(Value::Indeterminate),
+                        other => Err(EvalError::Type(format!(
+                            "function `{display}` is bound to non-callable value {other}"
+                        ))),
+                    };
                 }
                 let Some(elem) = self.b.resolve(scope, qn, 0) else {
                     return Err(EvalError::Unsupported(format!("function `{display}`")));
@@ -2957,7 +3838,19 @@ impl Evaluator<'_> {
                 elem
             }
         };
-        let value = self.user_calc_body(display, elem, args);
+        let value = (|| {
+            let scope =
+                self.b.elem_scope.get(&elem).copied().ok_or_else(|| {
+                    EvalError::Unsupported("calculation scope is unavailable".into())
+                })?;
+            let hidden = self.mask_frames(scope, scope)?;
+            self.call_frames
+                .push(RuntimeFrame::calculation(ElementRef(elem), ScopeRef(scope)));
+            let value = self.user_calc_body(display, elem, args);
+            self.call_frames.pop();
+            self.restore_frames(hidden);
+            value
+        })();
         self.unbound_receiver = previous;
         value
     }
@@ -2973,12 +3866,8 @@ impl Evaluator<'_> {
                 "calculation body requires statement execution".into(),
             ));
         }
-        let has_body = self.b.result_exprs.iter().any(|(o, _, _)| *o == elem)
-            || self
-                .b
-                .return_params
-                .get(&elem)
-                .is_some_and(|ret| self.b.values.contains_key(ret));
+        let bodies = self.calc_bodies(elem);
+        let has_body = bodies.is_some();
         if !has_body && !self.callee_is_calculation(elem) {
             return Err(EvalError::Unsupported(format!(
                 "function `{display}` (no result expression)"
@@ -2986,30 +3875,32 @@ impl Evaluator<'_> {
         }
         // Validate and bind arguments before the abstract/bodiless fallback:
         // an unknown result does not make an invalid invocation well-formed.
-        let params = self.callee_params(elem);
-        // Parameters belong to this invocation. A missing argument/default
-        // must never capture a same-named parameter from the calling frame.
+        let params = self.b.calc_parameter_bindings(elem).ok_or_else(|| {
+            EvalError::Unsupported(
+                "calculation parameter identities are incomplete or ambiguous".into(),
+            )
+        })?;
+        // Mask this invocation's declaration identities, preserving distinct
+        // enclosing parameters even when their names happen to be equal.
         let caller_env = self.env.clone();
-        self.env.retain(|(name, _)| !params.contains(name));
+        self.env.retain(|binding| {
+            !params
+                .iter()
+                .any(|p| binding.parameter == Some(p.element.0))
+        });
         let mut positional = 0usize;
         let mut bound = HashSet::new();
-        for (name, v) in args {
-            match name {
-                Some(n) => {
-                    if !params.contains(&n) {
+        for (name, value) in args {
+            let parameter = match name {
+                Some(name) => match params.iter().find(|p| p.name == name) {
+                    Some(p) => p,
+                    None => {
                         self.env = caller_env;
                         return Err(EvalError::Unresolved(format!(
-                            "parameter `{n}` of `{display}`"
-                        )));
-                    }
-                    if !bound.insert(n.clone()) {
-                        self.env = caller_env;
-                        return Err(EvalError::Type(format!(
-                            "parameter `{n}` of `{display}` is bound more than once"
+                            "parameter `{name}` of `{display}`"
                         )));
                     }
-                    self.env.push((n, v));
-                }
+                },
                 None => {
                     let Some(p) = params.get(positional) else {
                         self.env = caller_env;
@@ -3017,89 +3908,71 @@ impl Evaluator<'_> {
                             "too many arguments to `{display}`"
                         )));
                     };
-                    if !bound.insert(p.clone()) {
-                        self.env = caller_env;
-                        return Err(EvalError::Type(format!(
-                            "parameter `{p}` of `{display}` is bound more than once"
-                        )));
-                    }
-                    self.env.push((p.clone(), v));
                     positional += 1;
+                    p
                 }
+            };
+            if !bound.insert(parameter.element.0) {
+                self.env = caller_env;
+                return Err(EvalError::Type(format!(
+                    "parameter `{}` of `{display}` is bound more than once",
+                    parameter.name
+                )));
             }
+            self.env.push(EnvironmentBinding {
+                name: parameter.name.clone(),
+                parameter: Some(parameter.element.0),
+                frame: self.call_frames.len().checked_sub(1),
+                value,
+            });
         }
         if has_body {
-            for name in &params {
-                if bound.contains(name) {
+            for parameter in &params {
+                if bound.contains(&parameter.element.0) {
                     continue;
                 }
-                let mut stack = vec![elem];
-                let mut seen = HashSet::new();
-                let mut parameter = None;
-                while let Some(owner) = stack.pop() {
-                    if !seen.insert(owner) {
+                if !self.b.values.contains_key(&parameter.element.0) {
+                    // No name reaches a parameter that has none of its own
+                    // and redefines none, so no body can read it.
+                    if parameter.name.is_empty() {
                         continue;
                     }
-                    if let Some((_, field)) = self
-                        .b
-                        .ctor_fields
-                        .get(&owner)
-                        .and_then(|fields| fields.iter().find(|(n, _)| n == name))
-                    {
-                        parameter = Some(*field);
-                        break;
-                    }
-                    stack.extend(self.b.explicit_supertype_elems(owner));
-                }
-                let Some(parameter) = parameter.filter(|p| self.b.values.contains_key(p)) else {
                     self.env = caller_env;
                     return Err(EvalError::Unresolved(format!(
-                        "unbound parameter `{name}` of `{display}`"
+                        "unbound parameter `{}` of `{display}`",
+                        parameter.name
                     )));
-                };
-                let value = match self.feature_value(parameter) {
+                }
+                let receiver = self.call_frames.last().map(|frame| frame.receiver_scope.0);
+                let value = match self.feature_value_in(parameter.element.0, receiver) {
                     Ok(value) => value,
                     Err(error) => {
                         self.env = caller_env;
                         return Err(error);
                     }
                 };
-                self.env.push((name.clone(), value));
+                self.env.push(EnvironmentBinding {
+                    name: parameter.name.clone(),
+                    parameter: Some(parameter.element.0),
+                    frame: self.call_frames.len().checked_sub(1),
+                    value,
+                });
             }
         }
-        // A calculation's result is its trailing result expression, or —
-        // the `return x = expr;` spelling — its return parameter's value.
-        enum CalcBody {
-            Result(usize, Expr),
-            Return(usize),
-        }
-        let result = self
-            .b
-            .result_exprs
-            .iter()
-            .find(|(o, _, _)| *o == elem)
-            .map(|(_, s, e)| (*s, e.clone()));
-        let body = match result {
-            Some((s, e)) => CalcBody::Result(s, e),
-            None => match self.b.return_params.get(&elem) {
-                Some(&ret) if self.b.values.contains_key(&ret) => CalcBody::Return(ret),
-                _ => {
-                    // A *calculation* with no body — abstract, a
-                    // declaration shell, or a function-typed parameter
-                    // whose actual is unknown — applied to arguments has
-                    // an unknown result: indeterminate, not unsupported.
-                    // Non-callable targets keep the error (degrading
-                    // those would mask a genuine model defect).
-                    if self.callee_is_calculation(elem) {
-                        self.env = caller_env;
-                        return Ok(Value::Indeterminate);
-                    }
-                    self.env = caller_env;
-                    return Err(EvalError::Unsupported(format!(
-                        "function `{display}` (no result expression)"
-                    )));
-                }
-            },
+        let Some(bodies) = bodies else {
+            // A *calculation* with no body — abstract, a declaration
+            // shell, or a function-typed parameter whose actual is
+            // unknown — applied to arguments has an unknown result:
+            // indeterminate, not unsupported. Non-callable targets keep
+            // the error (degrading those would mask a genuine model
+            // defect).
+            self.env = caller_env;
+            if self.callee_is_calculation(elem) {
+                return Ok(Value::Indeterminate);
+            }
+            return Err(EvalError::Unsupported(format!(
+                "function `{display}` (no result expression)"
+            )));
         };
         // Call depth is a budget, not a cycle: a recursion that does not
         // terminate reaches it, and so does a legitimately deep chain of
@@ -3111,22 +3984,84 @@ impl Evaluator<'_> {
             )));
         }
         self.call_depth += 1;
-        // A library-owned callee evaluates in a library frame: its body
-        // keeps the closed element convention for unbound features (see
+        // Results inherited from generals equally near all bind the one
+        // result: it is their common value, and unknown where they differ.
+        let mut out = None;
+        for (owner, body) in bodies {
+            let next = self.calc_result(elem, owner, body);
+            out = Some(match out {
+                None => next,
+                Some(Ok(first)) => match next {
+                    Ok(value) if value == first => Ok(first),
+                    Ok(_) => Err(EvalError::Unsupported(
+                        "the inherited results disagree".into(),
+                    )),
+                    error => error,
+                },
+                Some(error) => error,
+            });
+            if matches!(out, Some(Err(_))) {
+                break;
+            }
+        }
+        self.call_depth -= 1;
+        self.env = caller_env;
+        out.unwrap_or(Ok(Value::Indeterminate))
+    }
+
+    /// One result `owner` declares, for an invocation of `elem` whose
+    /// arguments are bound in the innermost call frame.
+    fn calc_result(&mut self, elem: usize, owner: usize, body: CallableResult) -> Result_ {
+        // A library-owned body evaluates in a library frame: it keeps the
+        // closed element convention for unbound features (see
         // `placeholder` — library sequence semantics count on it).
-        let lib_callee = elem < self.b.lib_boundary;
-        if lib_callee {
+        let lib_body = owner < self.b.lib_boundary;
+        if lib_body {
             self.lib_frames += 1;
         }
-        let out = match body {
-            CalcBody::Result(cscope, result) => self.expr(cscope, &result),
-            CalcBody::Return(ret) => self.feature_value(ret),
+        let saved_origin = self.b.set_identity_origin(owner);
+        let lexical = self.lexical_scope;
+        // An inherited body evaluates in the callee's own context, where
+        // its arguments stand for the parameters they redefine.
+        let callee_scope = self.call_frames.last().map(|frame| frame.receiver_scope.0);
+        let out = match (body, callee_scope) {
+            (
+                CallableResult::Expression {
+                    scope: ScopeRef(cscope),
+                    expression,
+                },
+                Some(receiver),
+            ) if owner != elem => {
+                self.lexical_scope = Some(cscope);
+                match self.mask_frames(cscope, receiver) {
+                    Ok(hidden) => {
+                        let out = self.expr(receiver, &expression);
+                        self.restore_frames(hidden);
+                        out
+                    }
+                    Err(error) => Err(error),
+                }
+            }
+            (CallableResult::Parameter(ret), Some(receiver)) if owner != elem => {
+                self.feature_value_in(ret.0, Some(receiver))
+            }
+            (
+                CallableResult::Expression {
+                    scope: ScopeRef(cscope),
+                    expression,
+                },
+                _,
+            ) => {
+                self.lexical_scope = Some(cscope);
+                self.expr(cscope, &expression)
+            }
+            (CallableResult::Parameter(ret), _) => self.feature_value(ret.0),
         };
-        if lib_callee {
+        self.b.identity_origin_unit = saved_origin;
+        self.lexical_scope = lexical;
+        if lib_body {
             self.lib_frames -= 1;
         }
-        self.call_depth -= 1;
-        self.env = caller_env;
         out
     }
 
@@ -3321,7 +4256,9 @@ impl Evaluator<'_> {
                 let TargetRef::Name(qn) = ty else {
                     return Err(EvalError::Unsupported("chained function reference".into()));
                 };
-                let name = qn.segments.last().unwrap().value.clone();
+                let name = self.intrinsic_name(scope, ty).ok_or_else(|| {
+                    EvalError::Unsupported(format!("control function `{}`", qn.to_display_string()))
+                })?;
                 self.control(scope, &name, first, &Applier::Lambda(body))
             }
             ArrowArgs::List(list) => {
@@ -3332,7 +4269,7 @@ impl Evaluator<'_> {
                 }
                 if values.iter().all(|(n, _)| n.is_none()) {
                     let positional: Vec<Value> = values.iter().map(|(_, v)| v.clone()).collect();
-                    match self.intrinsic(ty, &positional) {
+                    match self.intrinsic(scope, ty, &positional) {
                         Err(EvalError::Unsupported(_)) => {}
                         out => return out,
                     }
@@ -3345,7 +4282,9 @@ impl Evaluator<'_> {
                 let TargetRef::Name(qn) = ty else {
                     return Err(EvalError::Unsupported("chained function reference".into()));
                 };
-                let name = qn.segments.last().unwrap().value.clone();
+                let name = self.intrinsic_name(scope, ty).ok_or_else(|| {
+                    EvalError::Unsupported(format!("control function `{}`", qn.to_display_string()))
+                })?;
                 self.control(scope, &name, first, &Applier::FnRef(fnqn))
             }
         }
@@ -3372,12 +4311,14 @@ impl Evaluator<'_> {
 
     /// Apply a *referenced* function to arguments: operator spellings
     /// (`'+'`, `'*'`, …) fold through the arithmetic core, KFL intrinsics
-    /// dispatch by reserved name (`min`, `max`), anything else invokes as
+    /// dispatch by library identity, anything else invokes as
     /// a user calculation — where a bodiless callee degrades to
     /// indeterminate like any other invocation.
     fn apply_fn_ref(&mut self, scope: usize, qn: &QualifiedName, args: Vec<Value>) -> Result_ {
-        if let [l, r] = args.as_slice() {
-            let op = match qn.segments.last().unwrap().value.as_str() {
+        let target = TargetRef::Name(qn.clone());
+        let intrinsic = self.intrinsic_name(scope, &target);
+        if let (Some(name), [l, r]) = (intrinsic.as_deref(), args.as_slice()) {
+            let op = match name {
                 "+" => Some(BinaryOp::Add),
                 "-" => Some(BinaryOp::Sub),
                 "*" => Some(BinaryOp::Mul),
@@ -3391,9 +4332,12 @@ impl Evaluator<'_> {
                 return arith(op, l.clone(), r.clone());
             }
         }
-        match self.intrinsic(&TargetRef::Name(qn.clone()), &args) {
-            Err(EvalError::Unsupported(_)) => {}
-            out => return out,
+        if let Some(name) = intrinsic {
+            match self.intrinsic_uncharged(&name, &args) {
+                Err(EvalError::Unsupported(_)) => {}
+                Ok(value) => return self.charged(value),
+                Err(error) => return Err(error),
+            }
         }
         let named: Vec<(Option<String>, Value)> = args.into_iter().map(|v| (None, v)).collect();
         self.user_calc(scope, &TargetRef::Name(qn.clone()), named)
@@ -3419,6 +4363,10 @@ impl Evaluator<'_> {
         target: Value,
         applier: &Applier<'_>,
     ) -> Result_ {
+        let target = self.collection_value(target);
+        if matches!(target, Value::Indeterminate) {
+            return Ok(target);
+        }
         let items = target.items();
         match name {
             "collect" | "select" | "reject" | "forAll" | "exists" => {
@@ -3432,7 +4380,13 @@ impl Evaluator<'_> {
                 for item in &items {
                     let v = self.apply(scope, applier, std::slice::from_ref(item))?;
                     match name {
-                        "collect" => out.extend(v.items()),
+                        "collect" => {
+                            let v = self.collection_value(v);
+                            if matches!(v, Value::Indeterminate) {
+                                return Ok(v);
+                            }
+                            out.extend(v.items());
+                        }
                         "select" | "reject" => match v {
                             Value::Boolean(keep) => {
                                 if keep == (name == "select") {
@@ -3499,10 +4453,12 @@ impl Evaluator<'_> {
             "minimize" | "maximize" => {
                 let mut mapped = Vec::with_capacity(items.len());
                 for item in &items {
-                    mapped.extend(
-                        self.apply(scope, applier, std::slice::from_ref(item))?
-                            .items(),
-                    );
+                    let value = self.apply(scope, applier, std::slice::from_ref(item))?;
+                    let value = self.collection_value(value);
+                    if matches!(value, Value::Indeterminate) {
+                        return Ok(value);
+                    }
+                    mapped.extend(value.items());
                 }
                 extremum(mapped, name == "maximize")
             }
@@ -3557,12 +4513,59 @@ impl Evaluator<'_> {
                 args.len()
             )));
         }
+        let lowered = self
+            .b
+            .identity_origin_unit
+            .and_then(|unit| self.b.lambda_parameter_bindings(unit, body));
+        if self.b.identity_origin_unit.is_some()
+            && lowered.is_none()
+            && !params.is_empty()
+            && !self.query
+        {
+            return Err(EvalError::Unsupported(
+                "lambda parameter identities are incomplete or ambiguous".into(),
+            ));
+        }
+        if lowered
+            .as_ref()
+            .is_some_and(|(_, declared)| declared.len() != args.len())
+        {
+            return Err(EvalError::Unsupported(
+                "lambda parameter identity count differs".into(),
+            ));
+        }
         let depth = self.env.len();
-        for (p, v) in params.iter().zip(args) {
-            self.env.push((p.clone(), v.clone()));
+        let lexical = self.lexical_scope;
+        // A lambda body continues the current syntax subtree. Preserve existing
+        // visibility, but give its inputs an independently maskable activation.
+        self.call_frames.push(RuntimeFrame::lambda(
+            lowered.as_ref().map(|(s, _)| *s),
+            ScopeRef(scope),
+        ));
+        if let Some((body_scope, declared)) = lowered {
+            self.lexical_scope = Some(body_scope.0);
+            for (p, v) in declared.into_iter().zip(args) {
+                self.env.push(EnvironmentBinding {
+                    name: p.name,
+                    parameter: Some(p.element.0),
+                    frame: self.call_frames.len().checked_sub(1),
+                    value: v.clone(),
+                });
+            }
+        } else {
+            for (name, value) in params.iter().zip(args) {
+                self.env.push(EnvironmentBinding {
+                    name: name.clone(),
+                    parameter: None,
+                    frame: self.call_frames.len().checked_sub(1),
+                    value: value.clone(),
+                });
+            }
         }
         let out = self.expr(scope, result);
         self.env.truncate(depth);
+        self.lexical_scope = lexical;
+        self.call_frames.pop();
         out
     }
 
@@ -3659,23 +4662,82 @@ impl Evaluator<'_> {
         }
     }
 
-    /// Kernel Function Library intrinsics, matched by the invoked name's
-    /// last segment. An intrinsic that builds a sequence or a string
-    /// (`reverse`, `including`, `ToString`, `Substring`, …) returns it
-    /// through the allocation budget; an
-    /// [`EvalError::Unsupported`] answer is the "not an intrinsic"
-    /// sentinel invocation dispatch falls through on, and stays exactly
-    /// that.
-    fn intrinsic(&mut self, ty: &TargetRef, args: &[Value]) -> Result_ {
-        let value = self.intrinsic_uncharged(ty, args)?;
+    /// Resolve before choosing a built-in implementation. Looking at the
+    /// written suffix would hijack user functions, aliases and function-valued
+    /// parameters. Library identities are indexed once, independently of model
+    /// size; no library scan is performed for each call.
+    fn intrinsic_name(&mut self, scope: usize, ty: &TargetRef) -> Option<String> {
+        let resolved = match ty {
+            TargetRef::Name(qn) => {
+                let value = match self.environment_value(scope, qn) {
+                    Ok(value) => value,
+                    Err(_) => return None,
+                };
+                if let Some(value) = value {
+                    return match value {
+                        Value::Element(ElementRef(e))
+                        | Value::Unbound(ElementRef(e))
+                        | Value::UnboundMember(ElementRef(e)) => self.library_intrinsic(e),
+                        _ => None,
+                    };
+                }
+                return self.b.intrinsic_function_name(scope, qn);
+            }
+            TargetRef::Chain(links) => {
+                let empty = QualifiedName {
+                    is_global: false,
+                    segments: Vec::new(),
+                    span: Span::default(),
+                };
+                self.b.resolve_chain_member(scope, Some(links), &empty)
+            }
+        };
+        resolved.and_then(|elem| self.library_intrinsic(elem))
+    }
+
+    fn library_intrinsic(&self, elem: usize) -> Option<String> {
+        if elem >= self.b.lib_boundary {
+            return None;
+        }
+        library_intrinsics()
+            .get(&self.b.elem_id(elem))
+            .map(|s| (*s).to_owned())
+    }
+
+    /// Intrinsics return materialized values through the allocation budget.
+    /// Unsupported remains the sentinel for falling through to a calculation.
+    fn intrinsic(&mut self, scope: usize, ty: &TargetRef, args: &[Value]) -> Result_ {
+        let name = self
+            .intrinsic_name(scope, ty)
+            .ok_or_else(|| EvalError::Unsupported("non-intrinsic function".into()))?;
+        let value = self.intrinsic_uncharged(&name, args)?;
         self.charged(value)
     }
 
-    fn intrinsic_uncharged(&mut self, ty: &TargetRef, args: &[Value]) -> Result_ {
-        let TargetRef::Name(qn) = ty else {
-            return Err(EvalError::Unsupported("chained function reference".into()));
+    fn intrinsic_uncharged(&mut self, name: &str, args: &[Value]) -> Result_ {
+        // Normalize collection operands before any intrinsic can wrap,
+        // count or consume a placeholder as a single runtime value.
+        // Direct cardinality queries retain their bound-based answers.
+        let collection_args = match name {
+            "sum" | "product" | "head" | "last" | "tail" | "reverse" | "includes" | "excludes" => 1,
+            "union" => 2,
+            "min" | "max" if args.len() == 1 => 1,
+            "size" | "isEmpty" | "notEmpty" if matches!(args, [Value::Sequence(_)]) => 1,
+            _ => 0,
+        };
+        let mut normalized;
+        let args = if collection_args > 0 && args.len() >= collection_args {
+            normalized = args.to_vec();
+            for value in &mut normalized[..collection_args] {
+                *value = self.collection_value(value.clone());
+                if matches!(value, Value::Indeterminate) {
+                    return Ok(Value::Indeterminate);
+                }
+            }
+            &normalized[..]
+        } else {
+            args
         };
-        let name = qn.segments.last().unwrap().value.as_str();
         let items = |v: &Value| v.clone().items();
         match (name, args) {
             // Reflection over the model structure (query mode only —
@@ -3700,8 +4762,7 @@ impl Evaluator<'_> {
                 ],
             ) if self.query => Ok(Value::Sequence(self.owned_members(*e, true))),
             // Element reflection (query mode): names, metaclass and
-            // documentation of a model element, as the rendering backend's
-            // translated template expressions ask for them.
+            // documentation of a model element.
             (
                 "declaredName" | "shortName" | "qualifiedName" | "metaclass" | "docs",
                 [
@@ -3739,11 +4800,11 @@ impl Evaluator<'_> {
             // multiplicity, never from the placeholder itself. An exact
             // multiplicity answers; a lower/upper bound still settles
             // emptiness; anything else is honestly undecided. Sequences
-            // *containing* placeholders keep their literal arity, and
-            // library frames never mint Unbound in the first place.
-            ("size", [Value::Unbound(ElementRef(e)) | Value::UnboundMember(ElementRef(e))]) => {
-                match self.unbound_cardinality(*e) {
-                    Some((lo, hi)) if lo == hi && lo.is_finite() => Ok(Value::Integer(lo as i128)),
+            // containing placeholders are normalized above; library
+            // frames never mint Unbound in the first place.
+            ("size", [v @ (Value::Unbound(_) | Value::UnboundMember(_))]) => {
+                match self.value_cardinality(v) {
+                    Some((lo, Some(hi))) if lo == hi => Ok(Value::Integer(lo)),
                     // Indeterminate, not an error — the cardinality is
                     // simply unknown, and downstream arithmetic degrades
                     // with it (this answer is final either way: never
@@ -3752,17 +4813,17 @@ impl Evaluator<'_> {
                     _ => Ok(Value::Indeterminate),
                 }
             }
-            ("isEmpty", [Value::Unbound(ElementRef(e)) | Value::UnboundMember(ElementRef(e))]) => {
-                match self.unbound_cardinality(*e) {
-                    Some((_, 0.0)) => Ok(Value::Boolean(true)),
-                    Some((lo, _)) if lo >= 1.0 => Ok(Value::Boolean(false)),
+            ("isEmpty", [v @ (Value::Unbound(_) | Value::UnboundMember(_))]) => {
+                match self.value_cardinality(v) {
+                    Some((_, Some(0))) => Ok(Value::Boolean(true)),
+                    Some((lo, _)) if lo >= 1 => Ok(Value::Boolean(false)),
                     _ => Ok(Value::Indeterminate),
                 }
             }
-            ("notEmpty", [Value::Unbound(ElementRef(e)) | Value::UnboundMember(ElementRef(e))]) => {
-                match self.unbound_cardinality(*e) {
-                    Some((_, 0.0)) => Ok(Value::Boolean(false)),
-                    Some((lo, _)) if lo >= 1.0 => Ok(Value::Boolean(true)),
+            ("notEmpty", [v @ (Value::Unbound(_) | Value::UnboundMember(_))]) => {
+                match self.value_cardinality(v) {
+                    Some((_, Some(0))) => Ok(Value::Boolean(false)),
+                    Some((lo, _)) if lo >= 1 => Ok(Value::Boolean(true)),
                     _ => Ok(Value::Indeterminate),
                 }
             }
@@ -3921,14 +4982,194 @@ impl Evaluator<'_> {
                     Err(EvalError::Type("Substring bounds out of range".into()))
                 }
             }
-            _ => Err(EvalError::Unsupported(format!(
-                "function `{}`",
-                qn.to_display_string()
-            ))),
+            _ => Err(EvalError::Unsupported(format!("function `{name}`"))),
         }
     }
 }
 
+pub(crate) fn library_intrinsic_for_id(id: Uuid) -> Option<&'static str> {
+    library_intrinsics().get(&id).copied()
+}
+
+pub(crate) fn intrinsic_spelling(name: &str) -> bool {
+    matches!(
+        name,
+        "sum"
+            | "product"
+            | "size"
+            | "isEmpty"
+            | "notEmpty"
+            | "includes"
+            | "excludes"
+            | "head"
+            | "tail"
+            | "last"
+            | "reverse"
+            | "union"
+            | "min"
+            | "max"
+            | "abs"
+            | "sqrt"
+            | "ln"
+            | "exp"
+            | "log"
+            | "sin"
+            | "cos"
+            | "tan"
+            | "rat"
+            | "numer"
+            | "denom"
+            | "re"
+            | "im"
+            | "isZero"
+            | "isUnit"
+            | "floor"
+            | "round"
+            | "ToString"
+            | "ToInteger"
+            | "ToReal"
+            | "Length"
+            | "Substring"
+            | "collect"
+            | "select"
+            | "selectOne"
+            | "reject"
+            | "reduce"
+            | "forAll"
+            | "exists"
+            | "minimize"
+            | "maximize"
+            | "ownedMember"
+            | "ownedFeature"
+            | "declaredName"
+            | "shortName"
+            | "qualifiedName"
+            | "metaclass"
+            | "docs"
+            | "+"
+            | "-"
+            | "*"
+            | "/"
+            | "%"
+            | "**"
+            | "^"
+    )
+}
+
+/// Supported standard-library functions, keyed by the normative KerML
+/// qualified-name identity. Names shared by other libraries (for example
+/// CollectionFunctions::size) deliberately keep their own calculation bodies.
+fn library_intrinsics() -> &'static HashMap<Uuid, &'static str> {
+    static IDS: OnceLock<HashMap<Uuid, &'static str>> = OnceLock::new();
+    IDS.get_or_init(|| {
+        let groups: &[(&str, &[&str])] = &[
+            ("BaseFunctions", &["ToString"]),
+            ("BooleanFunctions", &["ToString"]),
+            ("StringFunctions", &["ToString", "Length", "Substring"]),
+            ("DataFunctions", &["min", "max"]),
+            ("ScalarFunctions", &["min", "max"]),
+            (
+                "NumericalFunctions",
+                &["sum", "product", "abs", "min", "max", "isZero", "isUnit"],
+            ),
+            (
+                "ComplexFunctions",
+                &[
+                    "sum", "product", "abs", "re", "im", "isZero", "isUnit", "ToString",
+                ],
+            ),
+            (
+                "RealFunctions",
+                &[
+                    "sum", "product", "abs", "min", "max", "re", "im", "sqrt", "floor", "round",
+                    "ToString", "ToReal",
+                ],
+            ),
+            (
+                "RationalFunctions",
+                &[
+                    "sum", "product", "abs", "min", "max", "rat", "numer", "denom", "floor",
+                    "round", "ToString",
+                ],
+            ),
+            (
+                "IntegerFunctions",
+                &[
+                    "sum",
+                    "product",
+                    "abs",
+                    "min",
+                    "max",
+                    "ToString",
+                    "ToInteger",
+                ],
+            ),
+            ("NaturalFunctions", &["min", "max", "ToString"]),
+            ("TrigFunctions", &["sin", "cos", "tan"]),
+            (
+                "SequenceFunctions",
+                &[
+                    "size", "isEmpty", "notEmpty", "includes", "excludes", "union", "head", "tail",
+                    "last",
+                ],
+            ),
+            (
+                "ControlFunctions",
+                &[
+                    "collect",
+                    "select",
+                    "selectOne",
+                    "reject",
+                    "reduce",
+                    "forAll",
+                    "exists",
+                    "minimize",
+                    "maximize",
+                ],
+            ),
+        ];
+        let mut ids = HashMap::new();
+        for &(package, names) in groups {
+            let namespace = Uuid::new_v5(
+                &Uuid::NAMESPACE_URL,
+                format!("https://www.omg.org/spec/KerML/{package}").as_bytes(),
+            );
+            for &name in names {
+                ids.insert(
+                    Uuid::new_v5(&namespace, format!("{package}::{name}").as_bytes()),
+                    name,
+                );
+            }
+        }
+        // Operator function references used by reduce follow the same identity
+        // rule as ordinary calls. Their escaped qualified names include quotes.
+        let operators: &[(&str, &[&str])] = &[
+            ("DataFunctions", &["+", "-", "*", "/", "**", "^", "%"]),
+            ("ScalarFunctions", &["+", "-", "*", "/", "**", "^", "%"]),
+            ("StringFunctions", &["+"]),
+            ("NumericalFunctions", &["+", "-", "*", "/", "**", "^", "%"]),
+            ("ComplexFunctions", &["+", "-", "*", "/", "**", "^"]),
+            ("RealFunctions", &["+", "-", "*", "/", "**", "^"]),
+            ("RationalFunctions", &["+", "-", "*", "/", "**", "^"]),
+            ("IntegerFunctions", &["+", "-", "*", "/", "**", "^", "%"]),
+            ("NaturalFunctions", &["+", "*", "/", "%"]),
+        ];
+        for &(package, names) in operators {
+            let namespace = Uuid::new_v5(
+                &Uuid::NAMESPACE_URL,
+                format!("https://www.omg.org/spec/KerML/{package}").as_bytes(),
+            );
+            for &name in names {
+                ids.insert(
+                    Uuid::new_v5(&namespace, format!("{package}::'{name}'").as_bytes()),
+                    name,
+                );
+            }
+        }
+        ids
+    })
+}
+
 /// Scale a scalar or vector quantity magnitude during same-dimension unit
 /// conversion. Components that already carry their own unit are coordinates
 /// with an explicit measurement reference and remain verbatim.
@@ -4271,7 +5512,16 @@ pub(crate) fn prepare_unit(b: &mut Builder, elem: usize) {
     let mut evaluator = Evaluator {
         b,
         env: Vec::new(),
+        lexical_scope: None,
+        value_scopes: Default::default(),
+        frame_proofs: Default::default(),
+        report: None,
+        inherited_failure_epoch: 0,
+        call_frames: Vec::new(),
         in_progress: HashSet::new(),
+        cardinality_in_progress: HashSet::new(),
+        cardinality_context: None,
+        cardinality_providers: Default::default(),
         overrides: HashMap::new(),
         unbound_receiver: None,
         lib_frames: 0,
@@ -4288,6 +5538,60 @@ pub(crate) fn prepare_unit(b: &mut Builder, elem: usize) {
 #[cfg(test)]
 mod memo_tests {
     use super::*;
+    #[test]
+    fn malformed_multiplicity_domains_do_not_fabricate_bounds() {
+        fn model() -> ResolvedModel {
+            let mut model = crate::model::Model::new();
+            model.add_source(
+                "ranges.kerml",
+                "package P {
+                feature f { multiplicity interval[2..5] { feature extra; } }
+                multiplicity four[4];
+                feature named { multiplicity m subsets four; }
+            }",
+            );
+            assert!(!model.has_errors());
+            ResolvedModel::build(&model)
+        }
+        for mutation in 0..6 {
+            let mut r = model();
+            let f = r.resolve_qualified("P::f").unwrap();
+            let m = r.resolve_qualified("P::f::interval").unwrap().0;
+            assert_eq!(r.effective_cardinality(f), Some((2, Some(5))));
+            let members = r.b.owned_member_elems(m, false);
+            match mutation {
+                // Bound expressions must be a contiguous prefix, at most two.
+                0 => r.b.elements[members[0]].ty = "Feature",
+                1 => r.b.elements[members[2]].ty = "LiteralInteger",
+                // Unsupported or unresolved added constraints cannot be ignored.
+                _ => {
+                    let named = r.resolve_qualified("P::named::m").unwrap().0;
+                    let rel = r.b.elements[named].owned_relationships[0];
+                    r.b.elements[m].owned_relationships.push(rel);
+                    if mutation == 2 {
+                        r.b.elements[rel].ty = "Subclassification";
+                    } else if mutation == 3 {
+                        r.b.elements[rel].props.insert(
+                            "subsettedFeature",
+                            serde_json::json!({
+                                "@id": "11111111-1111-4111-8111-111111111111"
+                            }),
+                        );
+                    }
+                    if mutation == 5 {
+                        let four = r.resolve_qualified("P::four").unwrap().0;
+                        let bound = r.b.owned_member_elems(four, false)[0];
+                        r.b.elements[bound]
+                            .props
+                            .insert("value", serde_json::json!(10));
+                    }
+                }
+            }
+            let expected = (mutation == 4).then_some((4, Some(4)));
+            assert_eq!(r.effective_cardinality(f), expected, "mutation {mutation}");
+        }
+    }
+
     #[test]
     fn unit_memo_replays_imports_and_bypasses_bound_or_recursive_contexts() {
         let mut model = crate::model::Model::new();
@@ -4298,7 +5602,16 @@ mod memo_tests {
         let mut ev = Evaluator {
             b: &mut r.b,
             env: Vec::new(),
+            lexical_scope: None,
+            value_scopes: Default::default(),
+            frame_proofs: Default::default(),
+            report: None,
+            inherited_failure_epoch: 0,
+            call_frames: Vec::new(),
             in_progress: HashSet::new(),
+            cardinality_in_progress: HashSet::new(),
+            cardinality_context: None,
+            cardinality_providers: Default::default(),
             overrides: HashMap::new(),
             unbound_receiver: None,
             lib_frames: 0,
@@ -4313,6 +5626,7 @@ mod memo_tests {
         assert_eq!(ev.b.semantic_memo.units.iter().count(), 0);
         let full = ev.expanded_unit(scope, elem, "m/s".into(), 0);
         assert_ne!(shallow, full);
+        assert_eq!(ev.b.semantic_memo.units.iter().count(), 1);
         let imports = ev.b.used_imports.clone();
         assert!(
             !imports.is_empty(),
@@ -4338,8 +5652,199 @@ mod memo_tests {
         ev.call_depth = 1;
         ev.expanded_unit(scope, elem, "m/s".into(), 0);
         ev.call_depth = 0;
-        ev.env.push(("x".into(), Value::Integer(1)));
+        ev.env.push(EnvironmentBinding {
+            name: "x".into(),
+            parameter: None,
+            frame: None,
+            value: Value::Integer(1),
+        });
         ev.expanded_unit(scope, elem, "m/s".into(), 0);
         assert_eq!(ev.b.semantic_memo.units.iter().count(), 0);
     }
 }
+
+#[cfg(test)]
+mod parameter_environment_tests {
+    use super::*;
+    use crate::model::Model;
+
+    #[test]
+    fn frame_masks_are_atomic_and_restore_after_failed_declarations_and_calls() {
+        let mut model = Model::new();
+        model.add_source("caller.sysml", "calc def Base {in q default 1; q}");
+        model.add_source(
+            "other.sysml",
+            "calc def Other {1/0} package P {attribute bad=1/0;}",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let base = r.resolve_qualified("Base").unwrap();
+        let other = r.resolve_qualified("Other").unwrap();
+        let bad = r.resolve_qualified("P::bad").unwrap();
+        let scope = r.element_scope(base).unwrap();
+        let mut ev = Evaluator {
+            b: &mut r.b,
+            env: Vec::new(),
+            lexical_scope: Some(scope.0),
+            value_scopes: Default::default(),
+            frame_proofs: Default::default(),
+            report: None,
+            inherited_failure_epoch: 0,
+            call_frames: vec![RuntimeFrame::lambda(None, scope); 2],
+            in_progress: HashSet::new(),
+            cardinality_in_progress: HashSet::new(),
+            cardinality_context: None,
+            cardinality_providers: Default::default(),
+            overrides: HashMap::new(),
+            unbound_receiver: None,
+            lib_frames: 0,
+            call_depth: 0,
+            steps: MAX_STEPS - 1,
+            allocated: 0,
+            query: false,
+        };
+        // The first frame is eligible for masking, but the second proof fails.
+        assert!(ev.mask_frames(scope.0, scope.0).is_err());
+        assert!(ev.call_frames.iter().all(|frame| frame.visible));
+        ev.steps = 0;
+        let outer = ev.mask_frames(scope.0, scope.0).unwrap();
+        assert_eq!(outer, vec![0, 1]);
+        let inner = ev.mask_frames(scope.0, scope.0).unwrap();
+        assert!(inner.is_empty());
+        ev.restore_frames(inner);
+        assert!(ev.call_frames.iter().all(|frame| !frame.visible));
+        ev.restore_frames(outer);
+        assert!(ev.call_frames.iter().all(|frame| frame.visible));
+        ev.call_frames = vec![RuntimeFrame::calculation(base, scope)];
+        ev.b.identity_origin_unit = Some(0);
+        ev.unbound_receiver = Some(base.0);
+        for _ in 0..2 {
+            assert!(ev.feature_value(bad.0).is_err());
+            assert!(ev.call_frames[0].visible);
+            assert!(ev.in_progress.is_empty());
+            assert_eq!(ev.lexical_scope, Some(scope.0));
+            assert_eq!(ev.b.identity_origin_unit, Some(0));
+            assert_eq!(ev.unbound_receiver, Some(base.0));
+            assert!(ev.user_calc_elem("Other", other.0, Vec::new()).is_err());
+            assert_eq!(ev.call_frames.len(), 1);
+            assert!(ev.call_frames[0].visible);
+            assert_eq!(ev.call_depth, 0);
+            assert_eq!(ev.lexical_scope, Some(scope.0));
+            assert_eq!(ev.b.identity_origin_unit, Some(0));
+            assert_eq!(ev.unbound_receiver, Some(base.0));
+        }
+    }
+
+    #[test]
+    fn external_query_names_yield_to_inner_parameter_identities() {
+        let mut model = Model::new();
+        model.add_source(
+            "parameters.sysml",
+            "calc def F { in x; x } attribute invocation=F(2); attribute plain=x;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        for (name, expected) in [("invocation", 2), ("plain", 99), ("invocation", 2)] {
+            let owner = r.resolve_qualified(name).unwrap();
+            let (scope, expr) = r.value_expr(owner).unwrap();
+            assert_eq!(
+                evaluate_query_with_env(
+                    &mut r.b,
+                    scope.0,
+                    &expr,
+                    vec![("x".into(), Value::Integer(99))]
+                ),
+                Ok(Value::Integer(expected))
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod inherited_signature_tests {
+    use super::*;
+    use crate::model::Model;
+
+    const DECLARATIONS: &str = "
+        calc def Diff { in a; in b; return r = a - b; }
+        calc def D3 :> Diff { in x; }
+        calc def D2 :> Diff { in :>> b; }
+        calc def Child :> Diff;
+        calc typed : Diff;
+        calc def Quotient { in n; in d; n / d }
+        calc def Half :> Quotient { in x; }
+        calc def Offset { in a; in b default 1; a - b }
+        calc def O3 :> Offset { in x; }
+        calc def Scaled :> Diff { in x; return :>> r = x * b; }
+        calc def Product { in p; in q; p * q }
+        calc def Both :> Diff, Product;
+        calc def Apply { in fn : Diff; return r = fn(5, 1); }
+    ";
+
+    /// `attribute result = <expr>;` beside `DECLARATIONS`, evaluated.
+    fn eval(expr: &str) -> Result_ {
+        let mut model = Model::new();
+        model.add_source(
+            "inherited.sysml",
+            &format!("package T {{ {DECLARATIONS} attribute result = {expr}; }}"),
+        );
+        assert!(!model.has_errors(), "{expr}");
+        let mut r = ResolvedModel::build(&model);
+        let result = r.resolve_qualified("T::result").unwrap();
+        r.evaluate(result)
+    }
+
+    #[test]
+    fn a_specialization_binds_its_own_then_its_inherited_inputs() {
+        // `x` takes over `a` by position; `b` is still `Diff`'s.
+        assert_eq!(eval("D3(10, 3)"), Ok(Value::Integer(7)));
+        assert_eq!(eval("D3(b = 3, x = 10)"), Ok(Value::Integer(7)));
+        assert_eq!(eval("Half(8, 2)"), Ok(Value::Integer(4)));
+        // An inherited default fills an inherited input left out.
+        assert_eq!(eval("O3(10)"), Ok(Value::Integer(9)));
+        // An own result reads an inherited input too.
+        assert_eq!(eval("Scaled(4, 3)"), Ok(Value::Integer(12)));
+        // `a` is no input of `D3`: `x` redefines it.
+        assert!(matches!(
+            eval("D3(a = 10, b = 3)"),
+            Err(EvalError::Unresolved(_))
+        ));
+    }
+
+    #[test]
+    fn an_explicit_redefinition_binds_by_position_as_well() {
+        // `in :>> b` also takes over `Diff`'s first parameter, so `D2` has
+        // one input, `b`, that both of `Diff`'s stand for.
+        let mut model = Model::new();
+        model.add_source("inherited.sysml", DECLARATIONS);
+        let mut r = ResolvedModel::build(&model);
+        let d2 = r.resolve_qualified("D2").unwrap();
+        let bindings = r.calc_parameter_bindings(d2).unwrap();
+        assert_eq!(bindings.len(), 1);
+        assert_eq!(bindings[0].name, "b");
+        assert_eq!(r.owner(bindings[0].element), Some(d2));
+        assert_eq!(eval("D2(10)"), Ok(Value::Integer(0)));
+        assert_eq!(eval("D2(b = 4)"), Ok(Value::Integer(0)));
+        assert!(
+            matches!(eval("D2(10, 3)"), Err(EvalError::Type(m)) if m.contains("too many arguments"))
+        );
+    }
+
+    #[test]
+    fn an_invocation_evaluates_an_inherited_result() {
+        assert_eq!(eval("Child(10, 3)"), Ok(Value::Integer(7)));
+        assert_eq!(eval("typed(10, 3)"), Ok(Value::Integer(7)));
+        // A function-typed parameter stands for an unknown calculation,
+        // whatever its type computes.
+        let mut model = Model::new();
+        model.add_source("inherited.sysml", DECLARATIONS);
+        let mut r = ResolvedModel::build(&model);
+        let result = r.resolve_qualified("Apply::r").unwrap();
+        assert_eq!(r.evaluate(result), Ok(Value::Indeterminate));
+        assert_eq!(eval("Apply(Child)"), Ok(Value::Integer(4)));
+        // Results equally near bind the one result: their common value,
+        // unknown where they differ.
+        assert_eq!(eval("Both(5, 1, 2, 2)"), Ok(Value::Integer(4)));
+        assert!(
+            matches!(eval("Both(5, 1, 2, 3)"), Err(EvalError::Unsupported(m)) if m.contains("disagree"))
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/eval/report.rs b/crates/sysmlv2-model/src/eval/report.rs
new file mode 100644
index 0000000..639baff
--- /dev/null
+++ b/crates/sysmlv2-model/src/eval/report.rs
@@ -0,0 +1,387 @@
+//! Bounded observations of failures hidden by inherited-default fallback.
+//!
+//! Reporting does not change evaluation's result or consume its semantic
+//! budgets. A clean report does not certify concrete values or conformance.
+
+use super::{EvalError, Value};
+use crate::json::{ElementRef, ScopeRef};
+use sysmlv2_syntax::Span;
+
+const MAX_EVENTS: usize = 256;
+const MAX_PATH: usize = 64;
+const MAX_BYTES: usize = 1 << 20;
+
+/// One feature-value dependency in evaluation order. This is not a complete
+/// expression or calculation call stack.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct EvaluationDependency {
+    /// Feature whose value was requested.
+    pub requested: ElementRef,
+    /// Feature declaring the selected value expression.
+    pub origin: ElementRef,
+    /// Featuring context used to evaluate that expression.
+    pub receiver: ScopeRef,
+}
+
+/// A failed inherited default replaced by a compatibility placeholder.
+#[derive(Clone, Debug, PartialEq)]
+pub struct InheritedDefaultFailure {
+    /// Feature whose inherited default failed.
+    pub requested: ElementRef,
+    /// Feature declaring that default expression.
+    pub origin: ElementRef,
+    /// Featuring context in which the failure occurred.
+    pub receiver: ScopeRef,
+    /// Source unit of the default declaration, independent of its receiver.
+    pub source_unit: usize,
+    /// Source span of the selected default expression.
+    pub source_span: Span,
+    /// Original failure, retained without changing its category or message.
+    pub error: EvalError,
+    /// Feature dependency ancestry, ending with this attempted default.
+    pub dependency_path: Vec<EvaluationDependency>,
+}
+
+/// Compatibility evaluation result plus causes hidden by default fallback.
+///
+/// Reporting retains at most 256 events, 64 feature dependencies per event,
+/// and 1 MiB of accounted collector/event/path/error-string storage. These
+/// limits are separate from evaluation's semantic budgets. If any diagnostic
+/// or dependency ancestry cannot be retained completely,
+/// [`Self::diagnostics_truncated`] is set and checked conversion rejects the
+/// report. Evaluation itself continues with the compatibility behavior.
+#[derive(Clone, Debug, PartialEq)]
+pub struct EvaluationReport {
+    /// The same result returned by the corresponding compatibility API.
+    pub result: Result<Value, EvalError>,
+    /// First failures observed on branches actually evaluated.
+    pub inherited_default_failures: Vec<InheritedDefaultFailure>,
+    /// Diagnostic events or dependency ancestry exceeded reporting limits.
+    /// Evaluation continues normally; checked conversion rejects this report.
+    pub diagnostics_truncated: bool,
+}
+
+impl EvaluationReport {
+    /// Return a value only when evaluation succeeded without hidden failures or
+    /// truncated diagnostics. Unbound/indeterminate values remain values; this
+    /// does not certify complete evaluability or model conformance. Rejection
+    /// returns the complete report in a box.
+    pub fn into_checked_result(self) -> Result<Value, Box<Self>> {
+        if self.result.is_ok()
+            && self.inherited_default_failures.is_empty()
+            && !self.diagnostics_truncated
+        {
+            // The checked branch guarantees this is Ok; matching avoids an
+            // unwrap and preserves the whole report in the error branch below.
+            match self.result {
+                Ok(value) => Ok(value),
+                Err(_) => unreachable!(),
+            }
+        } else {
+            Err(Box::new(self))
+        }
+    }
+}
+
+/// One optional boxed collector per evaluator. Legacy entrypoints use None,
+/// avoiding the fixed active-stack storage as well as path/event allocations. Accounting is independent of evaluator
+/// step/allocation limits so observation cannot alter compatibility results.
+pub(super) struct Collector {
+    active: [Option<EvaluationDependency>; MAX_PATH],
+    active_len: usize,
+    overflow_depth: usize,
+    failures: Vec<InheritedDefaultFailure>,
+    payload_bytes: usize,
+    truncated: bool,
+}
+
+impl Default for Collector {
+    fn default() -> Self {
+        Self {
+            active: [None; MAX_PATH],
+            active_len: 0,
+            overflow_depth: 0,
+            failures: Vec::new(),
+            payload_bytes: 0,
+            truncated: false,
+        }
+    }
+}
+
+fn fits(parts: &[usize]) -> Option<usize> {
+    parts.iter().try_fold(0usize, |total, &part| {
+        total.checked_add(part).filter(|&sum| sum <= MAX_BYTES)
+    })
+}
+
+fn error_capacity(error: &EvalError) -> usize {
+    match error {
+        EvalError::Unresolved(s)
+        | EvalError::Unsupported(s)
+        | EvalError::Type(s)
+        | EvalError::Cycle(s)
+        | EvalError::Budget(s) => s.capacity(),
+        EvalError::DivisionByZero => 0,
+    }
+}
+
+impl Collector {
+    pub(super) fn push(&mut self, dependency: EvaluationDependency) {
+        if self.active_len < MAX_PATH && self.overflow_depth == 0 {
+            self.active[self.active_len] = Some(dependency);
+            self.active_len += 1;
+        } else {
+            // Evaluation already bounds total operations. Saturation is a
+            // defensive guard; reaching usize::MAX nested calls is impossible.
+            self.overflow_depth = self.overflow_depth.saturating_add(1);
+        }
+    }
+
+    pub(super) fn pop(&mut self) {
+        if self.overflow_depth != 0 {
+            self.overflow_depth -= 1;
+        } else if self.active_len != 0 {
+            self.active_len -= 1;
+            self.active[self.active_len] = None;
+        } else {
+            debug_assert!(false, "unbalanced evaluation dependency stack");
+        }
+    }
+
+    pub(super) fn record(
+        &mut self,
+        dependency: EvaluationDependency,
+        source_unit: usize,
+        source_span: Span,
+        error: EvalError,
+    ) {
+        if self.failures.len() >= MAX_EVENTS {
+            self.truncated = true;
+            return;
+        }
+        // Keep a prefix and the terminal attempted default if ancestry is too
+        // deep. Never mark deep but wholly successful evaluation truncated.
+        let lost_path = self.overflow_depth != 0;
+        self.truncated |= lost_path;
+        let path_len = if lost_path { MAX_PATH } else { self.active_len };
+        let Some(path_bytes) = path_len.checked_mul(size_of::<EvaluationDependency>()) else {
+            self.truncated = true;
+            return;
+        };
+        // Reserve a bounded event table once, after checking the payload. This
+        // includes Vec capacity rather than only occupied event slots.
+        let event_capacity = self.failures.capacity().max(MAX_EVENTS);
+        let Some(event_bytes) = event_capacity.checked_mul(size_of::<InheritedDefaultFailure>())
+        else {
+            self.truncated = true;
+            return;
+        };
+        let Some(payload_bytes) = fits(&[self.payload_bytes, error_capacity(&error), path_bytes])
+        else {
+            self.truncated = true;
+            return;
+        };
+        if fits(&[size_of::<Self>(), event_bytes, payload_bytes]).is_none() {
+            self.truncated = true;
+            return;
+        }
+        if self.failures.capacity() == 0 {
+            self.failures.reserve_exact(MAX_EVENTS);
+        }
+        let mut dependency_path = Vec::with_capacity(path_len);
+        let retained_prefix = if lost_path { MAX_PATH - 1 } else { path_len };
+        dependency_path.extend(self.active[..retained_prefix].iter().flatten().copied());
+        if lost_path {
+            dependency_path.push(dependency);
+        }
+        // Account actual capacities too; allocator capacity is permitted to
+        // exceed the requested amount. Never retain an over-budget event.
+        let actual_event_bytes = self
+            .failures
+            .capacity()
+            .checked_mul(size_of::<InheritedDefaultFailure>());
+        let actual_path_bytes = dependency_path
+            .capacity()
+            .checked_mul(size_of::<EvaluationDependency>());
+        let retained = actual_event_bytes
+            .zip(actual_path_bytes)
+            .and_then(|(events, path)| {
+                let payload = fits(&[self.payload_bytes, error_capacity(&error), path])?;
+                fits(&[size_of::<Self>(), events, payload]).map(|_| payload)
+            });
+        let Some(retained) = retained else {
+            // A first reserve may report more capacity than requested. Drop
+            // that empty table rather than retaining an over-budget allocation.
+            // Nonempty accepted tables never grow beyond their fixed capacity.
+            if self.failures.is_empty() {
+                self.failures = Vec::new();
+            }
+            self.truncated = true;
+            return;
+        };
+        self.payload_bytes = retained;
+        self.failures.push(InheritedDefaultFailure {
+            requested: dependency.requested,
+            origin: dependency.origin,
+            receiver: dependency.receiver,
+            source_unit,
+            source_span,
+            error,
+            dependency_path,
+        });
+    }
+
+    pub(super) fn finish(self, result: Result<Value, EvalError>) -> EvaluationReport {
+        EvaluationReport {
+            result,
+            inherited_default_failures: self.failures,
+            diagnostics_truncated: self.truncated,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn dep(index: usize) -> EvaluationDependency {
+        EvaluationDependency {
+            requested: ElementRef(index),
+            origin: ElementRef(index + 1),
+            receiver: ScopeRef(index + 2),
+        }
+    }
+
+    #[test]
+    fn retains_first_events_and_checked_conversion_rejects_truncation() {
+        let mut collector = Collector::default();
+        for index in 0..MAX_EVENTS + 3 {
+            collector.push(dep(index));
+            collector.record(dep(index), 7, Span::default(), EvalError::DivisionByZero);
+            collector.pop();
+        }
+        let report = collector.finish(Ok(Value::Integer(9)));
+        assert_eq!(report.inherited_default_failures.len(), MAX_EVENTS);
+        assert_eq!(
+            report.inherited_default_failures[0].requested,
+            ElementRef(0)
+        );
+        assert_eq!(
+            report.inherited_default_failures[MAX_EVENTS - 1].requested,
+            ElementRef(MAX_EVENTS - 1)
+        );
+        assert!(report.diagnostics_truncated);
+        assert!(report.into_checked_result().is_err());
+    }
+
+    #[test]
+    fn accounts_string_capacity_not_length_and_recovers_for_new_query() {
+        let mut message = String::with_capacity(MAX_BYTES);
+        message.push('x');
+        let mut collector = Collector::default();
+        collector.push(dep(0));
+        collector.record(dep(0), 7, Span::default(), EvalError::Unsupported(message));
+        collector.pop();
+        let report = collector.finish(Ok(Value::Integer(9)));
+        assert!(report.inherited_default_failures.is_empty());
+        assert!(report.diagnostics_truncated);
+        assert!(report.into_checked_result().is_err());
+        assert_eq!(
+            Collector::default()
+                .finish(Ok(Value::Integer(9)))
+                .into_checked_result()
+                .unwrap(),
+            Value::Integer(9)
+        );
+        assert_eq!(fits(&[usize::MAX, 1]), None);
+    }
+
+    #[test]
+    fn cumulative_payload_budget_stops_before_event_count_cap() {
+        let mut collector = Collector::default();
+        for index in 0..40 {
+            let mut message = String::with_capacity(64 * 1024);
+            message.push('x');
+            collector.push(dep(index));
+            collector.record(dep(index), 7, Span::default(), EvalError::Type(message));
+            collector.pop();
+        }
+        assert!(
+            fits(&[
+                size_of::<Collector>(),
+                collector.failures.capacity() * size_of::<InheritedDefaultFailure>(),
+                collector.payload_bytes,
+            ])
+            .is_some()
+        );
+        let report = collector.finish(Ok(Value::Integer(9)));
+        assert!(report.diagnostics_truncated);
+        assert!(!report.inherited_default_failures.is_empty());
+        assert!(report.inherited_default_failures.len() < 16);
+        for (index, failure) in report.inherited_default_failures.iter().enumerate() {
+            assert_eq!(failure.requested, ElementRef(index));
+        }
+    }
+
+    #[test]
+    fn bounds_ancestry_preserving_terminal_and_balances_overflow() {
+        let mut collector = Collector::default();
+        for index in 0..MAX_PATH + 3 {
+            collector.push(dep(index));
+        }
+        collector.record(
+            dep(MAX_PATH + 2),
+            7,
+            Span::default(),
+            EvalError::Cycle("x".into()),
+        );
+        for _ in 0..MAX_PATH + 3 {
+            collector.pop();
+        }
+        assert_eq!(collector.active_len, 0);
+        assert_eq!(collector.overflow_depth, 0);
+        collector.push(dep(91));
+        collector.record(dep(91), 7, Span::default(), EvalError::DivisionByZero);
+        collector.pop();
+        let report = collector.finish(Ok(Value::Integer(9)));
+        assert!(report.diagnostics_truncated);
+        assert_eq!(
+            report.inherited_default_failures[0].dependency_path.len(),
+            MAX_PATH
+        );
+        assert_eq!(
+            report.inherited_default_failures[0].dependency_path[0],
+            dep(0)
+        );
+        assert_eq!(
+            *report.inherited_default_failures[0]
+                .dependency_path
+                .last()
+                .unwrap(),
+            dep(MAX_PATH + 2)
+        );
+        assert_eq!(
+            report.inherited_default_failures[1].dependency_path,
+            [dep(91)]
+        );
+    }
+
+    #[test]
+    fn deep_success_does_not_claim_lost_diagnostics_and_errors_preserve_report() {
+        let mut collector = Collector::default();
+        for index in 0..MAX_PATH + 3 {
+            collector.push(dep(index));
+        }
+        for _ in 0..MAX_PATH + 3 {
+            collector.pop();
+        }
+        assert!(
+            !collector
+                .finish(Ok(Value::Indeterminate))
+                .diagnostics_truncated
+        );
+        let report = Collector::default().finish(Err(EvalError::DivisionByZero));
+        let report = report.into_checked_result().unwrap_err();
+        assert_eq!(report.result, Err(EvalError::DivisionByZero));
+    }
+}
diff --git a/crates/sysmlv2-model/src/full.rs b/crates/sysmlv2-model/src/full.rs
index 71de1ee..062ff09 100644
--- a/crates/sysmlv2-model/src/full.rs
+++ b/crates/sysmlv2-model/src/full.rs
@@ -194,6 +194,32 @@ pub fn resolved_to_full_json(
     policy: EmissionPolicy,
 ) -> Result<Value, EmissionError> {
     let compact = model_to_compact_json(model);
+    resolved_compact_to_full_json_impl(resolved, model, compact, policy, false)
+}
+
+/// Full-form emission from a compact array and a matching resolved projection.
+/// Payload loaders restore identities and bind references before deriving full
+/// properties; a post-emission JSON overlay cannot restore missing semantics.
+/// `compact` and `resolved` must represent the same graph and element identities.
+/// The model supplies the canonical library element-name table only. Identity
+/// references must already be encoded as `@id`; every remaining `@ref`, including
+/// a UUID-shaped lexical name, follows the chosen unresolved-reference policy.
+pub fn resolved_compact_to_full_json(
+    resolved: &mut crate::json::ResolvedModel,
+    model: &Model,
+    compact: Value,
+    policy: EmissionPolicy,
+) -> Result<Value, EmissionError> {
+    resolved_compact_to_full_json_impl(resolved, model, compact, policy, true)
+}
+
+fn resolved_compact_to_full_json_impl(
+    resolved: &mut crate::json::ResolvedModel,
+    model: &Model,
+    compact: Value,
+    policy: EmissionPolicy,
+    lexical_uuid_names: bool,
+) -> Result<Value, EmissionError> {
     // Elements only: membership ids share their member's qualified name and
     // must not win the name→id inversion (implied bases target elements).
     let lib_names = crate::json::library_element_name_map(model);
@@ -204,13 +230,14 @@ pub fn resolved_to_full_json(
     let previous = resolved.closure_policy();
     resolved.set_closure_policy(policy.closures);
     let mut truncated: Vec<String> = Vec::new();
-    let result = full_from_compact_policy(
+    let result = full_from_compact_policy_with_reference_mode(
         compact,
         &by_name,
         policy.unresolved,
         Some(resolved),
         policy.closures,
         &mut truncated,
+        lexical_uuid_names,
     );
     resolved.set_closure_policy(previous);
     let value = result?;
@@ -304,7 +331,7 @@ pub fn from_compact_value_with_policy(
 ) -> Result<Value, UnresolvedReferenceError> {
     if policy == UnresolvedReferencePolicy::Reject {
         let mut references = Vec::new();
-        unresolved_ref_spellings(&compact, &mut references);
+        unresolved_ref_spellings(&compact, &mut references, false);
         references.sort();
         references.dedup();
         if !references.is_empty() {
@@ -438,23 +465,23 @@ fn is_import(t: &str) -> bool {
     )
 }
 
-fn unresolved_ref_spellings(value: &Value, out: &mut Vec<String>) {
+fn unresolved_ref_spellings(value: &Value, out: &mut Vec<String>, lexical_uuid_names: bool) {
     match value {
         Value::Object(object) => {
             if let Some(spelling) = object.get("@ref").and_then(Value::as_str) {
-                // An id-shaped spelling is a reference by id (kept as such
-                // on the wire), not an unresolved name.
-                if Uuid::parse_str(spelling.trim_matches('\'')).is_err() {
+                // Legacy mode keeps ID-shaped spellings as identities; the
+                // bound-compact mode treats every remaining @ref as lexical.
+                if lexical_uuid_names || Uuid::parse_str(spelling.trim_matches('\'')).is_err() {
                     out.push(spelling.to_string());
                 }
             }
             for value in object.values() {
-                unresolved_ref_spellings(value, out);
+                unresolved_ref_spellings(value, out, lexical_uuid_names);
             }
         }
         Value::Array(values) => {
             for value in values {
-                unresolved_ref_spellings(value, out);
+                unresolved_ref_spellings(value, out, lexical_uuid_names);
             }
         }
         _ => {}
@@ -468,34 +495,89 @@ fn full_from_compact_policy(
     projection: Option<&mut crate::json::ResolvedModel>,
     closures: ClosurePolicy,
     truncated: &mut Vec<String>,
+) -> Result<Value, UnresolvedReferenceError> {
+    full_from_compact_policy_with_reference_mode(
+        compact,
+        lib_by_name,
+        policy,
+        projection,
+        closures,
+        truncated,
+        false,
+    )
+}
+
+fn full_from_compact_policy_with_reference_mode(
+    compact: Value,
+    lib_by_name: &HashMap<String, String>,
+    policy: UnresolvedReferencePolicy,
+    projection: Option<&mut crate::json::ResolvedModel>,
+    closures: ClosurePolicy,
+    truncated: &mut Vec<String>,
+    lexical_uuid_names: bool,
 ) -> Result<Value, UnresolvedReferenceError> {
     if policy == UnresolvedReferencePolicy::Reject {
         let mut references = Vec::new();
-        unresolved_ref_spellings(&compact, &mut references);
+        unresolved_ref_spellings(&compact, &mut references, lexical_uuid_names);
         references.sort();
         references.dedup();
         if !references.is_empty() {
             return Err(UnresolvedReferenceError { references });
         }
     }
-    Ok(full_from_compact_with(
+    if lexical_uuid_names {
+        Ok(full_from_compact_with_reference_mode(
+            compact,
+            lib_by_name,
+            policy == UnresolvedReferencePolicy::Preserve,
+            projection,
+            closures,
+            truncated,
+            true,
+        ))
+    } else {
+        Ok(full_from_compact_with(
+            compact,
+            lib_by_name,
+            policy == UnresolvedReferencePolicy::Preserve,
+            projection,
+            closures,
+            truncated,
+        ))
+    }
+}
+
+pub(crate) fn full_from_compact_with(
+    compact: Value,
+    lib_by_name: &HashMap<String, String>,
+    recover_refs: bool,
+    projection: Option<&mut crate::json::ResolvedModel>,
+    closures: ClosurePolicy,
+    truncated: &mut Vec<String>,
+) -> Value {
+    full_from_compact_with_reference_mode(
         compact,
         lib_by_name,
-        policy == UnresolvedReferencePolicy::Preserve,
+        recover_refs,
         projection,
         closures,
         truncated,
-    ))
+        false,
+    )
 }
 
-pub(crate) fn full_from_compact_with(
+fn full_from_compact_with_reference_mode(
     compact: Value,
     lib_by_name: &HashMap<String, String>,
     recover_refs: bool,
     mut projection: Option<&mut crate::json::ResolvedModel>,
     closures: ClosurePolicy,
     truncated: &mut Vec<String>,
+    lexical_uuid_names: bool,
 ) -> Value {
+    let canonical = projection
+        .as_ref()
+        .is_some_and(|resolved| resolved.b.graph_format == crate::model::GraphFormat::CanonicalV3);
     let Value::Array(items) = compact else {
         return compact;
     };
@@ -508,28 +590,31 @@ pub(crate) fn full_from_compact_with(
         .collect();
 
     if recover_refs {
-        inject_unresolved_reps(&mut elements);
+        inject_unresolved_reps(&mut elements, lexical_uuid_names);
     }
 
     // Replace `{"@ref": name}` placeholders with deterministic dangling IDs
     // (`additionalProperties: false` forbids @ref in the published schema).
     for el in &mut elements {
         for v in el.values_mut() {
-            patch_refs(v);
+            patch_refs(v, lexical_uuid_names);
         }
     }
 
     // ---- implied relationships ----
     // The layer synthesizes them (`json/implied.rs`) when the library
-    // bases are known (a loaded library or a name table — the layer
-    // synthesizes none otherwise, so `isImpliedIncluded` stays false
-    // exactly where no implied relationship is listed); the full form
+    // bases are known, and derives positional redefinitions from local
+    // specializations even without a library. The full form
     // lists them under their owner's `ownedRelationship` and as elements
     // of the array. Without a model to project from, none can be offered.
     if let Some(resolved) = projection.as_deref_mut() {
         add_implied_relationships(&mut elements, resolved);
     }
-    let implied_included = projection.is_some() && !lib_by_name.is_empty();
+    let implied_included = projection.is_some()
+        && (!lib_by_name.is_empty()
+            || elements
+                .iter()
+                .any(|e| e.get("isImplied").and_then(Value::as_bool) == Some(true)));
 
     // ---- graph indexes ----
     let index: HashMap<String, usize> = elements
@@ -583,6 +668,55 @@ pub(crate) fn full_from_compact_with(
         })
         .collect();
 
+    if canonical {
+        // Constructor structural carriers have no independent flag syntax.
+        // Emit their actual owned defaults, not nullable schema placeholders,
+        // so a full document preserves the same contract as compact source.
+        // Stop at the argument expressions: their semantics are independent.
+        let mut pending: Vec<_> = elements
+            .iter()
+            .enumerate()
+            .filter(|(_, row)| ty(row) == "ConstructorExpression")
+            .flat_map(|(i, _)| owned_rels[i].iter().copied())
+            .collect();
+        let mut seen = vec![false; elements.len()];
+        while let Some(i) = pending.pop() {
+            if seen[i]
+                || !matches!(
+                    ty(&elements[i]),
+                    "Membership"
+                        | "OwningMembership"
+                        | "ReturnParameterMembership"
+                        | "ParameterMembership"
+                        | "Feature"
+                        | "FeatureChaining"
+                        | "FeatureValue"
+                        | "Redefinition"
+                )
+            {
+                continue;
+            }
+            seen[i] = true;
+            if let Some(properties) = metaclass_props(ty(&elements[i])) {
+                for &(name, _) in properties {
+                    if elements[i].contains_key(name) {
+                        continue;
+                    }
+                    let default = crate::semantic_catalog::property(ty(&elements[i]), name)
+                        .and_then(|(_, effective)| effective)
+                        .filter(|spec| !spec.derived)
+                        .and_then(|spec| spec.default_json)
+                        .and_then(|value| serde_json::from_str(value).ok());
+                    if let Some(default) = default {
+                        elements[i].insert(name.into(), default);
+                    }
+                }
+            }
+            pending.extend(owned_rels[i].iter().copied());
+            pending.extend(related_elems[i].iter().copied());
+        }
+    }
+
     // Effective names (pilot `Feature::namingFeature`): an unnamed
     // feature is named by the first feature it explicitly redefines or
     // references (`:>> uid = 4;`, `perform a;`), and a chain feature by
@@ -701,6 +835,21 @@ pub(crate) fn full_from_compact_with(
                         derived.insert((*name).to_string(), derived_to_json(resolved, &v));
                     }
                 }
+                // Connector ends redefine owned Relationship properties, so
+                // the computed-name loop does not project these generic aliases.
+                // Use the same endpoint view as typed and generic navigation.
+                if conforms(&t, "Connector") {
+                    let (source, target) = resolved.relationship_ends(e);
+                    for (name, values) in [("source", source), ("target", target)] {
+                        derived.insert(
+                            name.into(),
+                            derived_to_json(
+                                resolved,
+                                &crate::json::DerivedValue::References(values),
+                            ),
+                        );
+                    }
+                }
                 // Relationships this pass added to the array and the model
                 // does not hold — the unresolved-reference recovery
                 // annotations' memberships — still belong to their owner's
@@ -812,9 +961,27 @@ pub(crate) fn full_from_compact_with(
                     derived.insert("owningType".into(), oref);
                 }
             }
-            // End features are constant (KerML 2025 metamodel); the pilot's
-            // FlowEnds are not.
-            if is_end && t != "FlowEnd" {
+            if is_end && t == "Feature" {
+                // End membership alone does not imply constancy. Feature's
+                // owned default applies when absent; retained values (even
+                // invalid ones) remain evidence for validation.
+                let default = crate::semantic_catalog::property(&t, "isConstant")
+                    .and_then(|(_, effective)| effective)
+                    .filter(|spec| {
+                        !spec.derived
+                            && !spec
+                                .storage_names
+                                .iter()
+                                .any(|name| elements[i].contains_key(*name))
+                    })
+                    .and_then(|spec| spec.default_json)
+                    .and_then(|value| serde_json::from_str(value).ok());
+                if let Some(default) = default {
+                    derived.insert("isConstant".into(), default);
+                }
+            } else if is_end && t != "FlowEnd" && !(canonical && conforms(&t, "Usage")) {
+                // Preserve the existing subtype projection. Usage's
+                // conditional end rules are handled separately below.
                 derived.insert("isConstant".into(), Value::Bool(true));
             }
         }
@@ -892,11 +1059,10 @@ pub(crate) fn full_from_compact_with(
                 );
             }
         }
-        // End *usages* are constant, variable, and time-varying regardless
-        // of how they are owned (interface-body ends ride a plain
-        // FeatureMembership) — but the pilot's FlowEnds are none of these.
-        // Overrides: the compact form spells the textual defaults.
-        if elements[i].get("isEnd").and_then(|v| v.as_bool()) == Some(true)
+        // LegacyV2 preserves its historical blanket completion of Usage end
+        // flags. CanonicalV3 below requires current checked variability.
+        if !canonical
+            && elements[i].get("isEnd").and_then(|v| v.as_bool()) == Some(true)
             && t != "FlowEnd"
             && t.ends_with("Usage")
         {
@@ -904,6 +1070,31 @@ pub(crate) fn full_from_compact_with(
             overrides.insert("isVariable".into(), Value::Bool(true));
             overrides.insert("mayTimeVary".into(), Value::Bool(true));
         }
+        if canonical
+            && conforms(&t, "Usage")
+            && elements[i].get("isEnd").and_then(Value::as_bool) == Some(true)
+        {
+            // The compatibility emitter shares the checked provider; it must
+            // not replace an unavailable proof with a blanket end heuristic.
+            derived.remove("isVariable");
+            derived.remove("mayTimeVary");
+            if let Some(resolved) = projection.as_deref_mut() {
+                if let Some(e) = resolved
+                    .element_by_id(&this_id)
+                    .filter(|&e| resolved.element_type(e) == t)
+                {
+                    if let Ok(variable) = resolved.usage_variability_report(e).value {
+                        overrides.insert("isVariable".into(), Value::Bool(variable));
+                        overrides.insert("mayTimeVary".into(), Value::Bool(variable));
+                    }
+                    if let Some(report) = resolved.canonical_end_constant_with_budget(e, 0) {
+                        if let Ok(constant) = report.value {
+                            overrides.insert("isConstant".into(), Value::Bool(constant));
+                        }
+                    }
+                }
+            }
+        }
         // A state's *inline* entry/do/exit action is composite at the
         // model level; perform-references (`do performedAction;`) stay
         // referential.
@@ -1915,7 +2106,18 @@ pub(crate) fn full_from_compact_with(
                 if el.get(*name).map(|v| !v.is_null()).unwrap_or(false) {
                     continue;
                 }
-                let default = match shape {
+                // Interchange nullability is not the semantic default. Owned
+                // scalar defaults come from the effective XMI declaration;
+                // keep explicitly retained values and derived computations.
+                let owned_default = crate::semantic_catalog::property(&t, name)
+                    .and_then(|(_, effective)| effective)
+                    .filter(|spec| {
+                        !spec.derived
+                            && !spec.storage_names.iter().any(|name| el.contains_key(*name))
+                    })
+                    .and_then(|spec| spec.default_json)
+                    .and_then(|value| serde_json::from_str(value).ok());
+                let default = owned_default.unwrap_or_else(|| match shape {
                     b'A' => Value::Array(Vec::new()),
                     b'B' => Value::Bool(false),
                     // Required references: membership redefinitions alias
@@ -1929,7 +2131,7 @@ pub(crate) fn full_from_compact_with(
                         }
                     }
                     _ => Value::Null,
-                };
+                });
                 el.insert((*name).to_string(), default);
             }
             // Drop compact-form properties the metaclass doesn't declare
@@ -1962,26 +2164,29 @@ pub(crate) fn full_from_compact_with(
 /// (root, name). Injected in compact shape so the ordinary full-form
 /// derivation completes ownership lists, defaults, and derived properties
 /// exactly as for hand-written `rep` members.
-fn inject_unresolved_reps(elements: &mut Vec<Map<String, Value>>) {
+fn inject_unresolved_reps(elements: &mut Vec<Map<String, Value>>, lexical_uuid_names: bool) {
     let by_id: HashMap<String, usize> = elements
         .iter()
         .enumerate()
         .map(|(i, e)| (eid(e).to_string(), i))
         .collect();
-    fn collect_refs(v: &Value, out: &mut Vec<String>) {
+    fn collect_refs(v: &Value, out: &mut Vec<String>, lexical_uuid_names: bool) {
         match v {
             Value::Object(m) => {
                 if let Some(Value::String(s)) = m.get("@ref") {
-                    // Id-shaped spellings are ids, not names to recover.
-                    if Uuid::parse_str(s.trim_matches('\'')).is_ok() {
+                    // Legacy mode interprets ID-shaped spellings as identities.
+                    if !lexical_uuid_names && Uuid::parse_str(s.trim_matches('\'')).is_ok() {
                         return;
                     }
                     out.push(s.clone());
                     return;
                 }
-                m.values().for_each(|x| collect_refs(x, out));
+                m.values()
+                    .for_each(|x| collect_refs(x, out, lexical_uuid_names));
             }
-            Value::Array(a) => a.iter().for_each(|x| collect_refs(x, out)),
+            Value::Array(a) => a
+                .iter()
+                .for_each(|x| collect_refs(x, out, lexical_uuid_names)),
             _ => {}
         }
     }
@@ -2015,7 +2220,8 @@ fn inject_unresolved_reps(elements: &mut Vec<Map<String, Value>>) {
     let mut sites: Vec<(usize, String)> = Vec::new();
     for (i, el) in elements.iter().enumerate() {
         let mut refs = Vec::new();
-        el.values().for_each(|v| collect_refs(v, &mut refs));
+        el.values()
+            .for_each(|v| collect_refs(v, &mut refs, lexical_uuid_names));
         if !refs.is_empty() {
             let root = root_of(i);
             sites.extend(refs.into_iter().map(|s| (root, s)));
@@ -2063,30 +2269,30 @@ fn inject_unresolved_reps(elements: &mut Vec<Map<String, Value>>) {
     }
 }
 
-fn patch_refs(v: &mut Value) {
+fn patch_refs(v: &mut Value, lexical_uuid_names: bool) {
     match v {
         Value::Object(m) => {
             if let Some(Value::String(s)) = m.get("@ref") {
-                // An id-shaped spelling is a reference by id (the lift
-                // spells a target it cannot name — an unnamed element, or
+                // In legacy mode an id-shaped spelling is a reference by id
+                // (the lift spells a target it cannot name — an unnamed element, or
                 // a library element with no library loaded — as its quoted
                 // id): keep the id. Anything else gets a deterministic
                 // dangling id.
                 let id = match Uuid::parse_str(s.trim_matches('\'')) {
-                    Ok(id) => id.to_string(),
-                    Err(_) => dangling_id(s),
+                    Ok(id) if !lexical_uuid_names => id.to_string(),
+                    _ => dangling_id(s),
                 };
                 m.clear();
                 m.insert("@id".into(), Value::String(id));
                 return;
             }
             for x in m.values_mut() {
-                patch_refs(x);
+                patch_refs(x, lexical_uuid_names);
             }
         }
         Value::Array(a) => {
             for x in a {
-                patch_refs(x);
+                patch_refs(x, lexical_uuid_names);
             }
         }
         _ => {}
@@ -2096,17 +2302,10 @@ fn patch_refs(v: &mut Value) {
 /// Effective name of an element (pilot `Element::effectiveName`): the
 /// declared name, else the name of the first feature this one explicitly
 /// redefines (`Feature::namingFeature`) or references (SysML reference
-/// forms), else — for chain features — the last chaining target's name.
+/// forms). Anonymous feature chains do not confer names.
 ///
-/// One naming rule, four representations. The implementations are this
-/// one (over the full form's element maps, the only one that also
-/// derives the positional implied names),
-/// `json::Builder::graph_effective_name` (over the lowered element
-/// graph, where `Builder::effective_name` is the declaration-only half),
-/// `lift::Lifter::effective_name` (over payload JSON), and the fixpoint
-/// inside `ids::walk` (over a compact payload, for id segments). They
-/// agree by construction and by the differential test in the round-trip
-/// gate; a change to one belongs in all of them.
+/// Semantic naming fallback for records outside the shared projection.
+/// The versioned ID label in `ids` is intentionally a separate contract.
 fn effective_name_of(
     i: usize,
     elements: &[Map<String, Value>],
@@ -2121,38 +2320,52 @@ fn effective_name_of(
     if let Some(n) = elements[i].get("declaredName").and_then(|v| v.as_str()) {
         return Some(n.to_string());
     }
+    if elements[i]
+        .get("declaredShortName")
+        .and_then(Value::as_str)
+        .is_some()
+    {
+        return None;
+    }
     let resolve = |tid: String| -> Option<String> {
         if let Some(&k) = index.get(&tid) {
             return effective_name_of(k, elements, owned_rels, index, lib_id_names, depth + 1);
         }
         lib_id_names.get(tid.as_str()).map(|n| n.to_string())
     };
-    // Naming precedence mirrors the pilot: explicitly redefined feature,
-    // then the computed (implied positional) redefinition, then the
-    // referenced feature, then a chain's last link.
+    // Specialized SysML reference naming takes precedence. Otherwise use
+    // the first explicit redefinition, the implied positional redefinition,
+    // then the feature selected by a specialized reference naming rule.
+    let owning_ty = elements[i]
+        .get("owningRelationship")
+        .and_then(ref_of)
+        .and_then(|id| index.get(&id).copied())
+        .map(|r| ty(&elements[r]));
+    let named_reference = crate::json::naming::reference_names_feature(ty(&elements[i]), owning_ty)
+        .then(|| {
+            owned_rels[i]
+                .iter()
+                .copied()
+                .find(|&r| ty(&elements[r]) == "ReferenceSubsetting")
+        })
+        .flatten();
     let mut reference: Option<String> = None;
-    let mut last_chain: Option<String> = None;
     for &r in &owned_rels[i] {
+        if named_reference.is_some() && Some(r) != named_reference {
+            continue;
+        }
         if elements[r].get("isImplied").and_then(|v| v.as_bool()) == Some(true) {
             continue;
         }
         match ty(&elements[r]) {
             "Redefinition" => {
-                if let Some(n) = elements[r]
+                return elements[r]
                     .get("redefinedFeature")
                     .and_then(ref_of)
-                    .and_then(&resolve)
-                {
-                    return Some(n);
-                }
-            }
-            "ReferenceSubsetting" => {
-                if reference.is_none() {
-                    reference = elements[r].get("referencedFeature").and_then(ref_of);
-                }
+                    .and_then(&resolve);
             }
-            "FeatureChaining" => {
-                last_chain = elements[r].get("chainingFeature").and_then(ref_of);
+            "ReferenceSubsetting" if named_reference == Some(r) && reference.is_none() => {
+                reference = elements[r].get("referencedFeature").and_then(ref_of);
             }
             _ => {}
         }
@@ -2163,18 +2376,22 @@ fn effective_name_of(
     // Actor/stakeholder parameters implicitly *subset* the library
     // `actors`/`stakeholders` collections — subsetting carries no name, so
     // a reference-spelled `actor ::> x;` stays anonymous (pilot naming).
-    let owning_ty = elements[i]
-        .get("owningRelationship")
-        .and_then(ref_of)
-        .and_then(|id| index.get(&id).copied())
-        .map(|r| ty(&elements[r]));
     if matches!(owning_ty, Some("ActorMembership" | "StakeholderMembership")) {
         return None;
     }
-    if let Some(n) = reference.and_then(&resolve) {
-        return Some(n);
+    let mut target = reference?;
+    if crate::json::naming::reference_names_feature_target(ty(&elements[i]), owning_ty) {
+        if let Some(&t) = index.get(&target) {
+            if let Some(last) = owned_rels[t].iter().rev().find_map(|&r| {
+                (ty(&elements[r]) == "FeatureChaining")
+                    .then(|| elements[r].get("chainingFeature").and_then(ref_of))
+                    .flatten()
+            }) {
+                target = last;
+            }
+        }
     }
-    last_chain.and_then(resolve)
+    resolve(target)
 }
 
 /// Positional names of implicitly-redefining members (the pilot's computed
@@ -2275,6 +2492,9 @@ fn invocation_arg_name(
     elements: &[Map<String, Value>],
     index: &HashMap<String, usize>,
 ) -> Option<String> {
+    // A written Redefinition makes a named argument; an implied one (the
+    // accept's payload and receiver redefining `AcceptAction`'s by position)
+    // is the positional pairing itself and names nothing here.
     let has_redefinition = elements[i]
         .get("ownedRelationship")
         .and_then(|v| v.as_array())
@@ -2282,7 +2502,10 @@ fn invocation_arg_name(
             a.iter()
                 .filter_map(ref_of)
                 .filter_map(|id| index.get(&id).copied())
-                .any(|r| ty(&elements[r]) == "Redefinition")
+                .any(|r| {
+                    ty(&elements[r]) == "Redefinition"
+                        && elements[r].get("isImplied").and_then(Value::as_bool) != Some(true)
+                })
         });
     if has_redefinition {
         return None;
@@ -2517,6 +2740,9 @@ fn fill_relationship_endpoints(
             }
             "TypeFeaturing" => {
                 let source = get("featureOfType").or_else(|| owner.clone());
+                if let Some(feature) = &source {
+                    derived.insert("featureOfType".into(), feature.clone());
+                }
                 let target = get("featuringType");
                 (source.into_iter().collect(), target.into_iter().collect())
             }
@@ -2557,41 +2783,37 @@ fn add_implied_relationships(
     elements: &mut Vec<Map<String, Value>>,
     resolved: &mut crate::json::ResolvedModel,
 ) {
-    let mut additions: Vec<(usize, Map<String, Value>)> = Vec::new();
-    for (i, el) in elements.iter().enumerate() {
-        let own_id = eid(el);
-        let t = ty(el);
-        // Same id *and* same metaclass, as the projection requires.
-        let Some(e) = resolved
-            .element_by_id(own_id)
-            .filter(|&e| resolved.element_type(e) == t)
+    let mut roots = Vec::new();
+    for (owner_index, element) in elements.iter_mut().enumerate() {
+        let Some(owner) = resolved
+            .element_by_id(eid(element))
+            .filter(|&e| resolved.element_type(e) == ty(element))
         else {
             continue;
         };
-        for r in resolved.implied_relationships(e) {
-            let rel_id = resolved.element_id(r).to_string();
-            let mut rel = Map::new();
-            rel.insert("@type".into(), json!(resolved.element_type(r)));
-            rel.insert("@id".into(), json!(rel_id));
-            rel.insert("elementId".into(), json!(rel_id));
-            rel.insert("isImpliedIncluded".into(), json!(true));
-            rel.insert("ownedRelationship".into(), json!([]));
-            rel.insert("ownedRelatedElement".into(), json!([]));
-            rel.insert("owningRelatedElement".into(), id_ref(own_id));
-            rel.insert("owningRelationship".into(), Value::Null);
-            rel.extend(resolved.element_properties(r));
-            rel.insert("aliasIds".into(), json!([]));
-            rel.insert("declaredName".into(), Value::Null);
-            rel.insert("declaredShortName".into(), Value::Null);
-            additions.push((i, rel));
+        for relationship in resolved.implied_relationships(owner) {
+            if let Some(Value::Array(owned)) = element.get_mut("ownedRelationship") {
+                owned.push(id_ref(&resolved.element_id(relationship).to_string()));
+            }
+            roots.push((owner_index, relationship));
         }
     }
-    for (owner_idx, rel) in additions {
-        let rel_ref = id_ref(eid(&rel));
-        if let Some(Value::Array(rels)) = elements[owner_idx].get_mut("ownedRelationship") {
-            rels.push(rel_ref);
+    // Emit each generated subtree together. Non-relationship Features keep
+    // ordinary child ownership; no synthetic isImplied Feature property exists.
+    let mut seen = std::collections::HashSet::new();
+    for (_, root) in roots {
+        let mut stack = vec![root];
+        while let Some(node) = stack.pop() {
+            if !seen.insert(node) {
+                continue;
+            }
+            let Some(record) = resolved.generated_node_record(node) else {
+                continue;
+            };
+            let children = resolved.generated_node_children(node);
+            stack.extend(children.into_iter().rev());
+            elements.push(record);
         }
-        elements.push(rel);
     }
 }
 
@@ -2626,4 +2848,210 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn scalar_completion_does_not_replace_retained_invalid_values() {
+        for retained in [Value::Null, json!("invalid"), json!(17)] {
+            let input = json!([{
+                "@id": "00000000-0000-0000-0000-000000000001",
+                "@type": "PartDefinition",
+                "isIndividual": retained,
+            }]);
+            let full = full_from_compact_with(
+                input,
+                &HashMap::new(),
+                false,
+                None,
+                ClosurePolicy::Passthrough,
+                &mut Vec::new(),
+            );
+            assert_eq!(full[0]["isIndividual"], retained);
+        }
+    }
+
+    fn connector_end_fixture() -> (Model, Value, Vec<String>) {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source(
+                    "ends.kerml",
+                    "class A { end feature x; end feature y; connector c from x to y; }"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let compact = model_to_compact_json(&model);
+        let sparse_ends = compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|row| {
+                row["@type"] == "Feature" && row["isEnd"] == true && row.get("isConstant").is_none()
+            })
+            .map(|row| row["@id"].as_str().unwrap().to_owned())
+            .collect::<Vec<_>>();
+        assert_eq!(sparse_ends.len(), 2);
+        (model, compact, sparse_ends)
+    }
+
+    #[test]
+    fn ordinary_connector_end_defaults_match_owned_property_without_changing_source() {
+        let (model, compact, sparse_ends) = connector_end_fixture();
+        let mut resolved = crate::json::ResolvedModel::build(&model);
+        let original_ids = compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|row| row["@id"].clone())
+            .collect::<Vec<_>>();
+        for closures in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            let full = resolved_to_full_json(
+                &mut resolved,
+                &model,
+                EmissionPolicy {
+                    unresolved: UnresolvedReferencePolicy::Reject,
+                    closures,
+                },
+            )
+            .unwrap();
+            assert_eq!(
+                full.as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|row| row["@id"].clone())
+                    .collect::<Vec<_>>(),
+                original_ids
+            );
+            let ends = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .filter(|row| row["@type"] == "Feature" && row["isEnd"] == true)
+                .collect::<Vec<_>>();
+            assert_eq!(ends.len(), 4);
+            for row in ends {
+                assert_eq!(row["isConstant"], false);
+                let element = resolved
+                    .elements()
+                    .find(|&e| resolved.element_id(e).to_string() == row["@id"].as_str().unwrap())
+                    .unwrap();
+                assert_eq!(
+                    row["isConstant"],
+                    resolved.property(element, "isConstant").unwrap()
+                );
+                if sparse_ends.iter().any(|id| row["@id"] == *id) {
+                    assert!(
+                        !resolved
+                            .element_properties(element)
+                            .contains_key("isConstant")
+                    );
+                }
+            }
+            assert_eq!(model_to_compact_json(&model), compact);
+        }
+    }
+
+    #[test]
+    fn exact_feature_end_default_preserves_retained_values_including_invalid_ones() {
+        let (_, compact, sparse_ends) = connector_end_fixture();
+        for (constant, variable) in [
+            (None, None),
+            (None, Some(json!(true))),
+            (Some(json!(true)), Some(json!(true))),
+            (Some(json!(true)), Some(json!(false))),
+            (Some(json!(false)), Some(json!(true))),
+            (Some(Value::Null), Some(json!(false))),
+            (Some(json!("invalid")), Some(json!(false))),
+            (Some(json!(17)), None),
+            (Some(json!([])), None),
+            (Some(json!({})), None),
+        ] {
+            let mut input = compact.clone();
+            let row = input
+                .as_array_mut()
+                .unwrap()
+                .iter_mut()
+                .find(|row| row["@id"] == sparse_ends[0])
+                .unwrap()
+                .as_object_mut()
+                .unwrap();
+            if let Some(value) = &constant {
+                row.insert("isConstant".into(), value.clone());
+            }
+            if let Some(value) = &variable {
+                row.insert("isVariable".into(), value.clone());
+            }
+            let before = input.clone();
+            let full = from_compact_value(input, &HashMap::new(), true);
+            let row = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|row| row["@id"] == sparse_ends[0])
+                .unwrap();
+            assert_eq!(row["isConstant"], constant.unwrap_or(json!(false)));
+            if let Some(variable) = variable {
+                assert_eq!(row["isVariable"], variable);
+            }
+            assert_eq!(
+                full.as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|row| row["@id"].clone())
+                    .collect::<Vec<_>>(),
+                before
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|row| row["@id"].clone())
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+
+    #[test]
+    fn end_subtypes_keep_computed_flags_and_use_owned_defaults() {
+        let (_, compact, sparse_ends) = connector_end_fixture();
+        for (metaclass, constant) in [
+            ("FlowEnd", json!(false)),
+            ("ReferenceUsage", json!(true)),
+            ("Step", json!(true)),
+        ] {
+            let mut input = compact.clone();
+            let row = input
+                .as_array_mut()
+                .unwrap()
+                .iter_mut()
+                .find(|row| row["@id"] == sparse_ends[0])
+                .unwrap();
+            row["@type"] = json!(metaclass);
+            let full = full_from_compact_with(
+                input,
+                &HashMap::new(),
+                false,
+                None,
+                ClosurePolicy::Passthrough,
+                &mut Vec::new(),
+            );
+            let row = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|row| row["@id"] == sparse_ends[0])
+                .unwrap();
+            assert_eq!(row["isConstant"], constant, "{metaclass}");
+            if metaclass == "ReferenceUsage" {
+                assert_eq!(row["isVariable"], true);
+                assert_eq!(row["mayTimeVary"], true);
+            }
+        }
+    }
 }
diff --git a/crates/sysmlv2-model/src/ids.rs b/crates/sysmlv2-model/src/ids.rs
index 293fa07..1a51a56 100644
--- a/crates/sysmlv2-model/src/ids.rs
+++ b/crates/sysmlv2-model/src/ids.rs
@@ -8,7 +8,7 @@
 //! Derivation: `id(child) = uuid5(id(parent), segment)` — the
 //! *parent's payload id* is the namespace, so one divergent parent
 //! never cascades into its subtree. Segments per IDS.md (id
-//! scheme 1): a single-member membership with a named member chains
+//! scheme 2): a single-member membership with a named member chains
 //! **past the membership** — the member takes `"::" + escaped
 //! id-name` directly under its owner and the membership takes `"m"`
 //! under the member; alias memberships take `"::" + escapedName`;
@@ -72,6 +72,13 @@ impl From<IdError> for String {
     }
 }
 
+/// Preserve the unresolved spelling convention used by structural identity
+/// paths. Recovery annotations must use the same suffix, including quotes;
+/// decoding a name here would change existing identities.
+pub(crate) fn reference_path_name(spelling: &str) -> &str {
+    spelling.rsplit("::").next().unwrap_or(spelling)
+}
+
 /// Per element of `compact` (payload order): the graph-derived id, or
 /// `None` where the scheme assigns rather than derives (document
 /// roots) or the element is unreachable from any root. `external_name`
@@ -227,7 +234,24 @@ fn walk(
     };
     let mut names: Vec<Option<String>> = (0..n).map(declared).collect();
     let effective = |i: usize, names: &[Option<String>]| -> Option<String> {
+        let membership = obj(i)
+            .get("owningRelationship")
+            .and_then(|v| v.get("@id"))
+            .and_then(Value::as_str)
+            .and_then(|id| index.get(id))
+            .map(|&r| ty(r));
+        let named_reference = crate::json::naming::reference_names_feature(ty(i), membership)
+            .then(|| {
+                owned_rels[i]
+                    .iter()
+                    .copied()
+                    .find(|&r| ty(r) == "ReferenceSubsetting")
+            })
+            .flatten();
         for &r in &owned_rels[i] {
+            if named_reference.is_some() && Some(r) != named_reference {
+                continue;
+            }
             let key = match ty(r) {
                 "Redefinition" => "redefinedFeature",
                 "ReferenceSubsetting" => "referencedFeature",
@@ -235,11 +259,28 @@ fn walk(
             };
             let target = obj(r).get(key)?;
             if let Some(s) = target.get("@ref").and_then(Value::as_str) {
-                return Some(s.rsplit("::").next().unwrap_or(s).to_string());
+                return Some(reference_path_name(s).to_string());
             }
             let s = target.get("@id").and_then(Value::as_str)?;
             return match index.get(s) {
-                Some(&t) => names[t].clone(),
+                Some(&t) => {
+                    if key == "referencedFeature"
+                        && crate::json::naming::reference_names_feature_target(ty(i), membership)
+                    {
+                        if let Some(&last) = owned_rels[t]
+                            .iter()
+                            .rev()
+                            .find(|&&r| ty(r) == "FeatureChaining")
+                        {
+                            let id = obj(last).get("chainingFeature")?.get("@id")?.as_str()?;
+                            return match index.get(id) {
+                                Some(&t) => names[t].clone(),
+                                None => external_name(id),
+                            };
+                        }
+                    }
+                    names[t].clone()
+                }
                 None => external_name(s),
             };
         }
@@ -305,6 +346,21 @@ fn walk(
         for (i, &rel) in owned_rels[owner].iter().enumerate() {
             let kids = &owned_elems[rel];
             let membership = ty(rel).ends_with("Membership");
+            // This structural role cannot reuse a legacy argument's r1/e0
+            // identity or acquire the instantiated type's effective name.
+            if ty(owner) == "ConstructorExpression"
+                && ty(rel) == "ReturnParameterMembership"
+                && kids.len() == 1
+                && ty(kids[0]) == "Feature"
+            {
+                derived[rel] = Some(Uuid::new_v5(&owner_ns, b"result"));
+                paths.extend(rel, owner, "result");
+                let rel_ns = final_of(rel, &derived)?;
+                derived[kids[0]] = Some(Uuid::new_v5(&rel_ns, b"e0"));
+                paths.extend(kids[0], rel, "e0");
+                stack.extend([rel, kids[0]]);
+                continue;
+            }
             // A single-member membership whose member has an id-name
             // chains **past the membership**: the member
             // takes the owner-scope named segment, and the membership
diff --git a/crates/sysmlv2-model/src/json.rs b/crates/sysmlv2-model/src/json.rs
index af0860f..0e4878e 100644
--- a/crates/sysmlv2-model/src/json.rs
+++ b/crates/sysmlv2-model/src/json.rs
@@ -18,20 +18,95 @@
 //! normative UUIDv5 library IDs).
 
 mod behavior;
+mod callable_bodies;
 mod cases;
 mod closures;
 mod derived;
 mod derived_compositions;
+mod direction_proof;
+mod exposure;
+mod feature_type_projection;
+mod literal_inheritance;
+mod membership_context;
+mod metadata_associations;
+mod model_level_evaluability;
+use membership_context::{ImportProjection, MembershipContext, MembershipProjection};
+mod dynamic_graph;
+mod dynamic_invocations;
+mod generated_defaults;
 mod implied;
-mod naming;
+mod import_memberships;
+mod local_featuring;
+mod membership_evidence;
+mod membership_projection;
+#[cfg(test)]
+mod named_argument_index_tests;
+pub(crate) mod naming;
+mod operations;
+mod owned_results;
+mod parameter_context;
+mod parameters;
+mod positional;
+mod positional_delta;
+pub(crate) mod provider_completeness;
+mod publication;
+mod recorded_lookup;
+mod redefinition_provenance;
+mod result_redefinition;
+mod runtime_frames;
 mod scope_table;
+mod semantic;
+mod semantic_batch;
+mod semantic_ownership;
+pub mod settled;
+mod structural_index;
+mod succession_endpoints;
+mod type_features;
+mod type_inputs;
+mod type_relations;
+pub use type_features::{TypeFeatureReport, TypeFeatures};
+pub use type_inputs::{FunctionResultReport, TypeInputIssue, TypeInputReport};
+mod invocation_bindings;
+pub use invocation_bindings::{
+    InvocationBinding, InvocationBindingIssue, InvocationBindingReport, InvocationBindings,
+};
+mod constructor_bindings;
+pub use constructor_bindings::{
+    ConstructorBinding, ConstructorBindingIssue, ConstructorBindingReport, ConstructorBindings,
+    ConstructorDefaultBinding, ConstructorDefaultReport, ConstructorResult,
+    ConstructorResultReport, ConstructorSelection, ConstructorSelectionReport,
+};
+mod cardinality;
+pub use cardinality::{CardinalityBounds, CardinalityIssue, CardinalityReport};
+mod end_constancy;
 mod typeops;
+pub use end_constancy::{EndConstancyIssue, EndConstancyReport};
+mod usage_variability;
+pub use usage_variability::{UsageVariabilityIssue, UsageVariabilityReport};
+pub(crate) mod value_context;
+pub(crate) use callable_bodies::calculation_like;
+pub use callable_bodies::{CallableBody, CallableResult};
 pub use closures::{CLOSURE_NAMES, ClosurePolicy};
 pub use derived::dangling_id;
 pub use derived::{
     CatalogEntry, Derived, DerivedValue, Derives, PropertyShape, Reference, computed_names,
     derives, derives_under, is_owned_property, metaclass_conforms, property_catalog,
 };
+pub(crate) use direction_proof::{DirectionFact, DirectionProof, authored_direction};
+pub use feature_type_projection::{FeatureTypeIssue, FeatureTypeReport};
+pub use model_level_evaluability::{
+    ModelLevelEvaluability, ModelLevelEvaluabilityReport, ModelLevelEvaluabilityUnknown,
+};
+pub use operations::{
+    OperationArgumentIssue, OperationError, OperationExecutionSignature, OperationResult,
+    operation_execution_signature,
+};
+pub use parameter_context::RuntimeParameterSelection;
+pub use parameters::{ParameterBinding, ReferenceIdentity};
+pub use runtime_frames::{RuntimeFrame, RuntimeFrameProof};
+pub use semantic::{ConditionalPropertyCapability, conditional_property_capability};
+pub use semantic::{PropertyError, PropertyIssue, SemanticExportError};
+pub use value_context::{ValueScopeDecision, ValueScopeResolver};
 
 use serde_json::{Map, Value, json};
 use std::collections::{HashMap, HashSet};
@@ -71,6 +146,58 @@ pub fn library_name_map(model: &crate::model::Model) -> HashMap<String, Vec<Stri
         .collect()
 }
 
+/// Canonical library names and the referenced identities whose canonical name
+/// cannot be used from an external source. The full name table retains its
+/// identity-derivation contract; remove the second set only from the table fed
+/// to the textual lifter, so those references use its existing UUID fallback.
+/// No alternate name is invented and source-language visibility is unchanged.
+pub fn library_reference_names(
+    model: &crate::model::Model,
+    referenced: &HashSet<Uuid>,
+) -> (HashMap<String, Vec<String>>, HashSet<String>) {
+    let mut b = Builder::default();
+    b.build_model(model);
+    let names: HashMap<_, _> = b
+        .lib_qnames
+        .iter()
+        .chain(b.lib_mem_qnames.iter())
+        .map(|(id, segments)| (id.to_string(), segments.clone()))
+        .collect();
+    let mut fallback = HashSet::new();
+    for id in referenced {
+        let text = id.to_string();
+        let Some(segments) = names.get(&text) else {
+            continue;
+        };
+        let qn = QualifiedName {
+            is_global: true,
+            segments: segments
+                .iter()
+                .map(|value| Name {
+                    value: value.clone(),
+                    span: Span::default(),
+                })
+                .collect(),
+            span: Span::default(),
+        };
+        // Membership imports serialize the selected alias/owning Membership,
+        // while ordinary reference expressions serialize the selected member.
+        let usable = match b.resolve_result(0, &qn, 0, false) {
+            LookupResult::Found(element, _, membership) => {
+                b.elem_id(element) == *id
+                    || membership
+                        .or(b.elements[element].owning_relationship)
+                        .is_some_and(|m| b.elem_id(m) == *id)
+            }
+            LookupResult::Missing | LookupResult::Ambiguous => false,
+        };
+        if !usable {
+            fallback.insert(text);
+        }
+    }
+    (names, fallback)
+}
+
 /// [`library_name_map`] restricted to library *elements* (memberships and
 /// aliases excluded) — the safe basis for name→id inversions, where a
 /// membership entry would collide with its member's qualified name.
@@ -111,7 +238,13 @@ pub fn model_to_compact_json_with_units(
         .filter(|&&(start, _)| start >= boundary)
         .map(|&(start, orig)| (start - boundary, model.unit_meta(orig).0.to_owned()))
         .collect();
-    (b.finish(boundary), units)
+    if model.graph_format() == crate::model::GraphFormat::CanonicalV3 {
+        let mut resolved = ResolvedModel::from_builder(b, model);
+        let compact = resolved.completed_compact_range(boundary, resolved.b.explicit_len());
+        (compact, units)
+    } else {
+        (b.finish(boundary), units)
+    }
 }
 
 /// The resolved standard library itself as a compact element array:
@@ -141,7 +274,12 @@ pub fn library_to_compact_json_with_units(
         .filter(|&&(start, _)| start < boundary)
         .map(|&(start, orig)| (start, model.unit_meta(orig).0.to_owned()))
         .collect();
-    (b.finish_range(0, boundary), units)
+    if model.graph_format() == crate::model::GraphFormat::CanonicalV3 {
+        let mut resolved = ResolvedModel::from_builder(b, model);
+        (resolved.completed_compact_range(0, boundary), units)
+    } else {
+        (b.finish_range(0, boundary), units)
+    }
 }
 
 /// The standard-library **resolver artifact**: everything a
@@ -485,16 +623,23 @@ pub(crate) struct BlockedSite {
 pub(crate) struct InheritedBindings {
     pub(crate) members: Vec<(usize, usize)>,
     pub(crate) alias_rels: Vec<usize>,
+    /// Contributing Membership identities in normative per-base order.
+    pub(crate) membership_order: Vec<usize>,
     /// A heritage or import chain reached [`MAX_RESOLUTION_DEPTH`], so
     /// members beyond it are missing from `members`.
     pub(crate) truncated: bool,
+    /// Known cyclic or unsupported semantic dependency. This is distinct
+    /// from an actual depth-budget cut and does not certify completeness.
+    pub(crate) incomplete: bool,
     /// `(dropped, shadowing)` pairs removed by the SysML implicit
     /// same-name usage redefinition (condition (c) of the removal pass):
     /// `dropped` is the inherited member a same-named usage-family member
     /// `shadowing` (owned by the enumerated scope, or inherited from a
     /// nearer base) hides without a spelled `:>>`. Lookup treats the pair
     /// as a redefinition; the namespace-distinguishability check reads it
-    /// as the collision the normative rule reports.
+    /// as the collision the normative rule reports. A parameter of a
+    /// behavior or step, a result or an end shadows nothing this way, in
+    /// lookup or here: it redefines by position.
     pub(crate) implicit_redefinitions: Vec<(usize, usize)>,
 }
 
@@ -532,10 +677,54 @@ type ImportVisit = (usize, u8, bool, Vec<(usize, usize)>);
 
 #[derive(Clone, Default, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Builder {
+    pub(crate) graph_format: crate::model::GraphFormat,
+    // Reconstructed from Model input metadata on every build; payload units
+    // are user units and cannot be frozen into a prepared library prefix.
+    #[serde(skip)]
+    payload_source_units: HashSet<usize>,
     dialect: Dialect,
     pub(crate) semantic_memo: crate::semantic_memo::SemanticMemo,
     #[serde(skip)]
     pub(crate) semantic_ready: bool,
+    /// Sole publication authority; skipped by prepared serialization.
+    #[serde(skip)]
+    implied: Option<implied::ImpliedTable>,
+    #[serde(skip)]
+    publication: publication::Control,
+    #[serde(skip)]
+    dynamic_graph: Option<Arc<dynamic_graph::Snapshot>>,
+    #[serde(skip)]
+    static_planning: bool,
+    #[serde(skip)]
+    recorded_lookup_ready: bool,
+    #[serde(skip)]
+    recorded_lookup_graph: Option<recorded_lookup::Graph>,
+    #[serde(skip)]
+    recorded_lookup_prefix: Option<Arc<recorded_lookup::Graph>>,
+    /// Whether the structural shape can change under Membership selection.
+    /// Persist this proof across prepared snapshots; user append recomputes it.
+    recorded_lookup_candidate: bool,
+    /// The outcomes this build starts from (see [`settled`]), taken by
+    /// [`Self::resolve_pending`].
+    #[serde(skip)]
+    seed: Option<settled::Seed>,
+    /// Whether this build keeps the outcomes it settles on.
+    #[serde(skip)]
+    keep_settled: bool,
+    /// The outcomes this build settled on, when kept.
+    #[serde(skip)]
+    settled: Option<Arc<settled::SettledOutcomes>>,
+    /// Selection did not stabilize within the pass budget. Restore contextual
+    /// bootstrap outputs together and preserve qualification across snapshots.
+    recorded_lookup_incomplete: bool,
+    #[serde(skip)]
+    redefinition_lookup_owner: Option<usize>,
+    #[serde(skip)]
+    redefinition_lookup_base: Option<usize>,
+    #[serde(skip)]
+    recorded_lookup_suppressed: bool,
+    #[serde(skip)]
+    library_refs_to_users: bool,
     /// Immutable library facts; never retain facts about user additions.
     #[serde(skip)]
     pub(crate) library_facts: Option<std::sync::Arc<crate::check::facts::Facts>>,
@@ -547,6 +736,9 @@ pub(crate) struct Builder {
     /// Flat element list in ownership (depth-first) order.
     #[serde(with = "element_table")]
     pub(crate) elements: crate::layered::LayeredVec<Elem>,
+    /// Ownership-path hash states, kept only while a build lowers.
+    #[serde(skip)]
+    path_hashes: Option<PathHashes>,
     #[serde(with = "scope_table")]
     scopes: crate::layered::LayeredVec<Scope>,
     /// Element index → its body scope (for namespace-owning elements).
@@ -554,10 +746,16 @@ pub(crate) struct Builder {
     /// Per-scope cache of resolved namespace-import target scopes (with the
     /// recursive flag and the import's bracket-filter indices).
     #[serde(skip)]
-    import_cache: Vec<Option<Vec<ImportedScope>>>,
+    import_cache: Vec<Option<Arc<Vec<ImportedScope>>>>,
+    /// Per scope and access, the sub-scopes a recursive import walks: the
+    /// scopes its admitted named members open, sorted. Lookups through a
+    /// recursive import visit them for every name; the lists are the scope
+    /// tables', fixed for a pass.
+    #[serde(skip)]
+    recursive_subs: crate::layered::IdMap<(usize, u8), Arc<[usize]>>,
     /// Import relationships a lookup actually resolved a name through
     /// (admitted hits only) — the unused-import check's evidence.
-    pub(crate) used_imports: HashSet<usize>,
+    pub(crate) used_imports: crate::layered::IdSet<usize>,
     /// Import relationships the resolution in progress walked through,
     /// each with the access the walk ran under; cleared per user
     /// reference and recorded on its [`RefSite`].
@@ -582,11 +780,25 @@ pub(crate) struct Builder {
     /// Per-scope cache of resolved specialization-base scopes.
     #[serde(skip)]
     base_cache: Vec<Option<(Vec<usize>, usize)>>,
+    /// Rule-required positional edges, keyed by stable element indices.
+    #[serde(skip)]
+    positional_redefinitions: Option<positional::PositionalRedefinitions>,
+    /// Private recursion guard; never stands in for completed evidence.
+    #[serde(skip)]
+    positional_planning: bool,
+    /// Library/variation requirements reused by positional planning and
+    /// materialization. External name-table overrides bypass this cache.
+    #[serde(skip)]
+    supported_implied: Option<Arc<implied::SupportedImpliedSpecializations>>,
+    /// Caller-supplied library-name overrides used by positional planning
+    /// before the implied relationship view is materialized.
+    #[serde(skip)]
+    external_implied_names: HashMap<String, Uuid>,
     /// Per-(scope, include_implied) memo of the inherited-member
     /// enumeration ([`Self::inherited_bindings`]), cleared with the
     /// other lookup caches. Shared, so a hit costs a pointer copy.
     #[serde(skip)]
-    inherited_cache: HashMap<(usize, bool), Arc<InheritedBindings>>,
+    inherited_cache: crate::layered::IdMap<(usize, bool), Arc<InheritedBindings>>,
     /// The same memo keyed by heritage for scopes that own nothing (a
     /// bodiless usage or definition): their enumeration is a function of
     /// their base scopes alone, and a large model has thousands of such
@@ -597,11 +809,12 @@ pub(crate) struct Builder {
     /// ([`Self::lookup`]). `None` under the active stamp means the scope is
     /// currently being evaluated (a cyclic re-entry is a miss); `Some`
     /// memoizes the completed result so multiple import paths can apply
-    /// their own filters without re-walking the graph.
+    /// their own filters without re-walking the graph. The six slots separate
+    /// three visibility levels for compatibility and semantic-name queries.
     #[serde(skip)]
-    visit_stamp: Vec<[u64; 3]>,
+    visit_stamp: Vec<[u64; 6]>,
     #[serde(skip)]
-    visit_result: Vec<[Option<LookupResult>; 3]>,
+    visit_result: Vec<[Option<LookupResult>; 6]>,
     /// The active lookup query number (one per (start scope, name) chase).
     #[serde(skip)]
     query_stamp: u64,
@@ -614,7 +827,7 @@ pub(crate) struct Builder {
     /// Resolved target of each namespace import per scope, with the
     /// import walks its own resolution took (attributed to the import's
     /// reference site, not to whichever lookup first filled the cache).
-    import_targets: HashMap<(usize, String), (Option<usize>, ImportWalks)>,
+    import_targets: crate::layered::IdMap<(usize, String), (Option<usize>, ImportWalks)>,
     /// Library element IDs → qualified-name segments (collected while
     /// assigning normative IDs).
     lib_qnames: crate::layered::LayeredVec<(Uuid, Vec<String>)>,
@@ -633,20 +846,67 @@ pub(crate) struct Builder {
     /// Unresolved references to patch after all scopes exist. A property key
     /// of the form `base#n` appends to the array property `base`.
     pending: Vec<PendingRef>,
+    /// User references retained only for models containing UUID spellings.
+    /// Interchange loading replays them after restoring explicit identities.
+    #[serde(skip)]
+    id_binding_pending: Vec<PendingRef>,
+    /// Identity spellings, keyed by source unit and first-segment span.
+    /// Distinct lexical names that happen to spell the same UUID retain
+    /// their normal meaning, even in the same interchange document.
+    #[serde(skip)]
+    id_spelled_targets: HashMap<(usize, u32, u32), (Uuid, Uuid)>,
+    /// Source provenance of a lifted expression/name while its resolution
+    /// context may belong to another unit (inherited defaults, imports).
+    #[serde(skip)]
+    pub(crate) identity_origin_unit: Option<usize>,
+    /// Source units for aliases; the global scope may contain aliases
+    /// declared in several source units with identical target spans.
+    #[serde(skip)]
+    alias_origins: crate::layered::IdMap<(usize, usize), usize>,
     /// Library-cache replay: recorded outcomes for library-origin pending
     /// refs, consumed positionally by `resolve_pending` (see
     /// [`crate::libcache`]).
     #[serde(skip)]
     lib_hints: Option<std::vec::IntoIter<(Option<Uuid>, Vec<String>)>>,
+    /// Whether `lib_hints` hold the library's own fixed point (see
+    /// [`crate::libcache::LibraryCache`]) rather than a first pass's outcomes.
+    #[serde(skip)]
+    lib_hints_fixed_point: bool,
+    /// Whether the last resolution pass took every library-origin pending
+    /// ref from `lib_hints`, none resolved afresh.
+    #[serde(skip)]
+    lib_replayed_all: bool,
+    /// Replay only the recorded targets from `lib_hints` in the next pass:
+    /// a recorded miss is resolved afresh, which alone tells an ambiguous
+    /// name from a missing one.
+    #[serde(skip)]
+    lib_replay_targets_only: bool,
     /// Root names the user units of the model being built introduce, from
     /// declarations, inferred names and root imports; `None` when a root
     /// construct's contribution needs the resolver. Replay skips every
     /// recorded outcome whose root misses intersect this set.
     #[serde(skip)]
     replay_completions: Option<HashSet<String>>,
-    /// Root misses seen while resolving the current pending reference.
+    /// Root misses seen while resolving the current pending reference, or
+    /// while computing the innermost lookup-cache entry in progress.
     #[serde(skip)]
     current_misses: Vec<String>,
+    /// The misses of every resolution a lookup-cache fill in progress
+    /// interrupted, outermost first: each fill notes its own misses in
+    /// `current_misses` (see [`Self::begin_fill`]).
+    #[serde(skip)]
+    fill_frames: Vec<Vec<String>>,
+    /// Root misses behind each scope's `base_cache` entry.
+    #[serde(skip)]
+    base_misses: Vec<FillMisses>,
+    /// Root misses behind each scope's `import_cache` entry — the
+    /// resolution of every namespace import target of the scope, which
+    /// also yields its `import_targets` entries.
+    #[serde(skip)]
+    import_misses: Vec<FillMisses>,
+    /// Root misses behind the `semantic_metadata` memo.
+    #[serde(skip)]
+    semantic_metadata_misses: FillMisses,
     /// Sealed-snapshot replay: the cache whose final library element ids
     /// are consumed positionally at element creation — skipping
     /// ownership-path construction and UUIDv5 hashing for the whole
@@ -685,7 +945,9 @@ pub(crate) struct Builder {
     pub(crate) owned_cross_features: crate::layered::LayeredMap<usize, usize>,
     pub(crate) payload_flows: HashSet<usize>,
     pub(crate) contract_exprs: crate::layered::LayeredMap<usize, (usize, Expr)>,
-    /// Multiplicities for semantic checks: (owning element, scope, clause).
+    /// Authored ranges for semantic checks: (source element, lexical scope,
+    /// clause). Header rows name the constrained element; body/named domain
+    /// rows name the MultiplicityRange itself and do not specify its cardinality.
     pub(crate) multiplicities: crate::layered::LayeredVec<(usize, usize, Multiplicity)>,
     /// Connector-family end features with reference targets, for the
     /// featuring-accessibility check: (connector, end feature, target span).
@@ -729,6 +991,16 @@ pub(crate) struct Builder {
     /// here instead of re-resolving (`:>>` names self-hit and fall through
     /// to full import scans, ~0.2 ms each on import-heavy scopes).
     pub(crate) spec_resolved: crate::layered::LayeredVec<Option<usize>>,
+    /// Root misses behind each `spec_resolved` outcome, by the same index:
+    /// a resolution that reads another reference's recorded outcome
+    /// depends on the root names that reference missed.
+    #[serde(skip)]
+    spec_misses: MissTable,
+    /// Root misses behind the recorded single-valued outcome of each
+    /// relationship, by the relationship element — what the recorded
+    /// lookup graph built from those outcomes depends on.
+    #[serde(skip)]
+    ref_misses: MissTable,
     /// `spec_targets` index the next created pending ref reports into.
     pending_spec_idx: Option<usize>,
     /// Trailing result expressions for constraint verdicts and calculation
@@ -740,9 +1012,11 @@ pub(crate) struct Builder {
     /// the result of executing the body. This is derived from source on
     /// every build, including builds that replay a library cache.
     pub(crate) executable_calculations: HashSet<usize>,
-    /// Named `in`/`inout` parameters per owning element, in declaration
-    /// order — the binding targets for user-defined calculation invocation.
-    pub(crate) in_params: crate::layered::LayeredMap<usize, Vec<String>>,
+    /// Derived source-site parameter identities, rebuilt when elements are appended.
+    #[serde(skip)]
+    parameter_sites: Option<parameters::ParameterSites>,
+    #[serde(skip)]
+    parameter_signatures: Option<parameters::ParameterSignatures>,
     /// Every named usage member per owning element, in declaration order
     /// with its element index — the binding targets for `new T(…)`
     /// constructor evaluation (filtered to data usages at use).
@@ -766,13 +1040,36 @@ pub(crate) struct Builder {
     /// `referencedFeature` without a [`ResolvedModel`] at hand. Rebuilt
     /// when the element count moves (edit sessions append).
     #[serde(skip)]
-    id_index: Option<HashMap<Uuid, usize>>,
+    id_index: Option<Arc<crate::layered::IdMap<Uuid, usize>>>,
     /// Element count `id_index` was built for (the map itself is shorter
     /// than the element list when ids collide, which must not force a
     /// rebuild per lookup).
     #[serde(skip)]
     id_index_built_for: usize,
-    /// Lazily built owning element → first [`Self::multiplicities`] row,
+    /// Immutable stored topology only; semantic proof facts stay query-local.
+    #[serde(skip)]
+    stored_structure: Option<Arc<structural_index::StoredStructure>>,
+    /// The structural scan of the frozen library rows, made when the
+    /// library is frozen and shared by every build on it: a build scans only
+    /// its own rows again. Not serialized: a decoded library's freeze makes
+    /// its own.
+    #[serde(skip)]
+    pub(crate) prefix_structure: Option<Arc<structural_index::PrefixStructure>>,
+    /// The frozen rows by id, kept by the freeze for the identity
+    /// assignment of every build on them (see [`Self::assign_user_ids`]):
+    /// the kept lookup graph's own table where there is one, else made at
+    /// the freeze. Not serialized: a decoded library's freeze makes its own.
+    #[serde(skip)]
+    pub(crate) prefix_ids: Option<Arc<crate::layered::IdMap<Uuid, usize>>>,
+    /// The library name tables by id, the first entry of an id winning,
+    /// made by the first build on the frozen rows whose identity
+    /// assignment reads a library row's name from them, and shared by
+    /// every build on them (see [`IdentityTables::table_name`]). Not
+    /// serialized: a decoded library's freeze makes its own cell.
+    #[serde(skip)]
+    pub(crate) prefix_table_names: Arc<std::sync::OnceLock<Arc<HashMap<Uuid, String>>>>,
+    /// Lazily built constrained element → first header [`Self::multiplicities`]
+    /// row, excluding body/named domain rows,
     /// with the row count it was built from. The table is
     /// library-inclusive, so the scan it replaces was proportional to
     /// the library on every lookup.
@@ -788,6 +1085,10 @@ pub(crate) struct Builder {
     /// the model's content stops at [`Self::explicit_len`].
     #[serde(skip)]
     pub(crate) implied_from: Option<usize>,
+    /// Immutable ownership/source projection for materialized semantic nodes.
+    /// Source storage and prepared snapshots never serialize this view.
+    #[serde(skip)]
+    semantic_ownership: Option<Arc<semantic_ownership::SemanticOwnership>>,
     /// Set while building an enum definition's direct body members.
     in_enum_body: bool,
     /// Usage elements with an expected featuring type (owned by a Type via
@@ -820,19 +1121,32 @@ pub(crate) struct Builder {
     /// References whose lookup found multiple same-precedence targets.
     ambiguous: Vec<(usize, QualifiedName)>,
     /// Import filter conditions — `filter expr;` members and bracketed
-    /// `import P::*[expr]` filters: (scope the expression's names resolve
-    /// from, the syntax expression). Applied by [`Self::lookup`] to every
+    /// `import P::*[expr]` filters: (source relationship, scope the expression's names resolve from, the syntax expression). Applied by [`Self::lookup`] to every
     /// hit that arrives through an import (see [`Self::filter_verdict`]).
-    pub(crate) filter_exprs: crate::layered::LayeredVec<(usize, Expr)>,
+    pub(crate) filter_exprs: crate::layered::LayeredVec<(usize, usize, Expr)>,
     /// Per-filter re-entrancy guard: resolving a filter's own metaclass
     /// names may walk back through the filtered import; a re-entered
     /// filter answers *undecided* (member stays visible).
     #[serde(skip)]
     filters_active: Vec<bool>,
     /// Direct metadata annotations per annotated element: `#M` prefix
-    /// metadata and about-less body `@M;` / `metadata m : M;` members
-    /// (`@M about x;` annotates `x`, not its owner — not recorded).
+    /// metadata, about-less body members and validated explicit Annotation
+    /// targets. Explicit-about snapshots are refreshed between resolution passes.
     pub(crate) metadata_of: crate::layered::LayeredMap<usize, Vec<usize>>,
+    /// Captured lazily only for models containing explicit metadata about sites.
+    #[serde(default)]
+    metadata_intrinsic: Option<crate::layered::LayeredMap<usize, Vec<usize>>>,
+    /// Current explicit contributions; empty keys retain touched-target history
+    /// so prepared library contexts can be refreshed after association removal.
+    #[serde(default)]
+    pub(crate) metadata_about: std::collections::BTreeMap<usize, Vec<usize>>,
+    /// Semantic snapshot changes can invalidate query proofs without row edits.
+    #[serde(skip)]
+    metadata_association_generation: Option<std::sync::Arc<()>>,
+    #[serde(default)]
+    explicit_metadata_annotations: crate::layered::LayeredVec<usize>,
+    #[serde(default)]
+    pub(crate) metadata_associations_incomplete: bool,
     /// Port definition element → its implicit ConjugatedPortDefinition
     /// (`~P` typings resolve through the original and substitute this).
     conjugated_defs: crate::layered::LayeredMap<usize, usize>,
@@ -848,7 +1162,7 @@ pub(crate) struct Builder {
     /// permanently caching an empty `import_scopes` for the scope on the
     /// way down).
     #[serde(skip)]
-    member_import_active: std::collections::HashSet<(usize, usize)>,
+    member_import_active: crate::layered::IdSet<(usize, usize)>,
 }
 
 /// Three-valued verdict of a filter condition against one candidate
@@ -903,19 +1217,101 @@ fn access_mode(access: LookupAccess) -> AccessMode {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 enum LookupResult {
     Missing,
-    Found(usize, Option<usize>),
+    /// Element, member scope, and the named alias Membership (if any).
+    /// Retaining the last component lets membership imports preserve identity
+    /// while ordinary references continue to denote the member element.
+    Found(usize, Option<usize>, Option<usize>),
     Ambiguous,
 }
 
 impl LookupResult {
     fn option(self) -> Option<(usize, Option<usize>)> {
         match self {
-            Self::Found(elem, scope) => Some((elem, scope)),
+            Self::Found(elem, scope, _) => Some((elem, scope)),
             Self::Missing | Self::Ambiguous => None,
         }
     }
 }
 
+/// The root misses ([`Builder::note_root_miss`]) behind one entry of a
+/// lookup cache. The caches outlive the reference whose resolution fills
+/// them, so every read of an entry notes these names again: an outcome
+/// read through a cache depends on each root name the cached computation
+/// looked up and missed, whichever reference computed it.
+#[derive(Clone, Default)]
+enum FillMisses {
+    /// Not computed yet, or computed without missing a root name.
+    #[default]
+    None,
+    /// Being computed by the fill [`Builder::begin_fill`] numbered so. A
+    /// read from inside it sees the partial entry, which depends on what
+    /// the fill has missed so far.
+    Filling(usize),
+    /// Computed; its computation missed these root names.
+    Missed(Arc<[String]>),
+}
+
+/// Root misses by a dense index (a scope, an element, a specialization
+/// entry), grown on demand. Only builds that record library outcomes fill
+/// one, and sparsely: an absent index costs a bounds check, not a hash.
+#[derive(Clone, Default)]
+struct MissTable(Vec<Option<Arc<[String]>>>);
+
+impl MissTable {
+    fn get(&self, index: usize) -> Option<&Arc<[String]>> {
+        self.0.get(index)?.as_ref()
+    }
+
+    fn set(&mut self, index: usize, misses: &[String]) {
+        if misses.is_empty() {
+            if let Some(slot) = self.0.get_mut(index) {
+                *slot = None;
+            }
+            return;
+        }
+        if self.0.len() <= index {
+            self.0.resize(index + 1, None);
+        }
+        self.0[index] = Some(misses.into());
+    }
+
+    fn clear(&mut self) {
+        self.0 = Vec::new();
+    }
+}
+
+/// The lookup state one query sets for itself — see
+/// [`Builder::enter_fill_mode`].
+struct QueryMode {
+    probing: bool,
+    widen: Option<(usize, LookupAccess)>,
+    exclude: Option<usize>,
+    declared_only: bool,
+    header_owner: Option<usize>,
+    header_base: Option<usize>,
+    member_imports: crate::layered::IdSet<(usize, usize)>,
+    /// The filter flags, when some filter was being evaluated.
+    filters: Option<Vec<bool>>,
+    suppressed: bool,
+}
+
+/// The root miss that stands for the root namespace importing nothing.
+/// The recorded lookup graph takes a scope's implied roots as absent only
+/// while no root import could make them visible, so what it reads through
+/// such a scope depends on this as on the roots themselves, and any root
+/// import supplies it. A root member spelled this way through an
+/// unrestricted name costs a needless re-resolution, never a wrong one.
+pub(crate) const ROOT_IMPORTS: &str = "::*";
+
+/// Note `names` among the misses of the resolution in progress, once each.
+fn note_misses<'a>(noted: &mut Vec<String>, names: impl IntoIterator<Item = &'a String>) {
+    for name in names {
+        if !noted.contains(name) {
+            noted.push(name.clone());
+        }
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct NamespaceImport {
     target: QualifiedName,
@@ -973,21 +1369,186 @@ struct PendingRef {
     spec_idx: Option<usize>,
 }
 
+/// The rows an identity assignment reads by id and by name (see
+/// [`Builder::assign_user_ids`]): its own rows, from `start`, in tables of
+/// its own; the frozen rows before them through the ids their freeze kept
+/// and their names on demand.
+struct IdentityTables {
+    start: usize,
+    /// Pre-reassignment id → index of the rows from `start`: the last row
+    /// carrying an id.
+    by_id: crate::layered::IdMap<Uuid, usize>,
+    /// The identity names of the rows from `start`.
+    names: Vec<Option<String>>,
+    /// The frozen rows by id, when `start` is their end.
+    frozen: Option<Arc<crate::layered::IdMap<Uuid, usize>>>,
+    /// The library name tables by id, the first entry of an id winning,
+    /// made when a row's identity name is first read from them: the cell
+    /// every build on the frozen rows shares while the tables are the
+    /// frozen rows' alone, else a table of this build's own.
+    table_names: Option<Arc<HashMap<Uuid, String>>>,
+}
+
+impl IdentityTables {
+    /// The row carrying `id`: the last of this build's rows to, else the
+    /// frozen row.
+    fn index_of(&self, id: &Uuid) -> Option<usize> {
+        self.by_id
+            .get(id)
+            .or_else(|| self.frozen.as_ref()?.get(id))
+            .copied()
+    }
+
+    /// Row `e`'s identity name: declared, else from the library name tables.
+    fn name(&mut self, b: &Builder, e: usize) -> Option<String> {
+        if e >= self.start {
+            return self.names[e - self.start].clone();
+        }
+        b.effective_name(e)
+            .or_else(|| self.table_name(b, b.elements[e].id))
+    }
+
+    fn table_name(&mut self, b: &Builder, id: Uuid) -> Option<String> {
+        let tables = self.table_names.get_or_insert_with(|| {
+            let frozen_only = self.frozen.is_some()
+                && b.lib_qnames.len() == b.lib_qnames.base_len()
+                && b.lib_qnames.base_untouched()
+                && b.lib_mem_qnames.len() == b.lib_mem_qnames.base_len()
+                && b.lib_mem_qnames.base_untouched();
+            if frozen_only {
+                let shared = &b.prefix_table_names;
+                if shared.get().is_none() {
+                    note_library_names_built();
+                }
+                Arc::clone(shared.get_or_init(|| Arc::new(b.library_table_names())))
+            } else {
+                note_library_names_built();
+                Arc::new(b.library_table_names())
+            }
+        });
+        tables.get(&id).cloned()
+    }
+}
+
+#[cfg(test)]
+thread_local! {
+    static PREFIX_IDS_SERVED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    static ID_INDEX_TABLED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    static LIBRARY_NAMES_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+/// How many rows the id index tabled itself, over every build.
+#[cfg(test)]
+pub(crate) fn id_index_tabled() -> usize {
+    ID_INDEX_TABLED.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_id_index_tabled(rows: usize) {
+    ID_INDEX_TABLED.with(|c| c.set(c.get() + rows));
+}
+#[cfg(not(test))]
+fn note_id_index_tabled(_rows: usize) {}
+/// How many times the library name tables were made by id.
+#[cfg(test)]
+pub(crate) fn library_names_built() -> usize {
+    LIBRARY_NAMES_BUILT.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_library_names_built() {
+    LIBRARY_NAMES_BUILT.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+fn note_library_names_built() {}
+/// How many identity assignments read the frozen rows through a kept table.
+#[cfg(test)]
+pub(crate) fn prefix_ids_served() -> usize {
+    PREFIX_IDS_SERVED.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_prefix_ids_served() {
+    PREFIX_IDS_SERVED.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+fn note_prefix_ids_served() {}
+
+/// The passes the redo loop takes against the graph of the previous
+/// pass's outcomes before concluding that they oscillate.
+const REDO_PASSES: usize = 4;
+
+/// What a pass records beside its outcomes, as lowering left it: restored
+/// before every pass, so that each pass records its own.
+struct SideState {
+    unresolved: Vec<(usize, QualifiedName)>,
+    ambiguous: Vec<(usize, QualifiedName)>,
+    blocked: Vec<BlockedSite>,
+    sites: Vec<RefSite>,
+    used: crate::layered::IdSet<usize>,
+}
+
+impl SideState {
+    fn capture(b: &Builder) -> Self {
+        Self {
+            unresolved: b.unresolved.clone(),
+            ambiguous: b.ambiguous.clone(),
+            blocked: b.blocked.clone(),
+            sites: b.ref_sites.clone(),
+            used: b.used_imports.clone(),
+        }
+    }
+
+    fn restore(&self, b: &mut Builder) {
+        b.unresolved = self.unresolved.clone();
+        b.ambiguous = self.ambiguous.clone();
+        b.blocked = self.blocked.clone();
+        b.ref_sites = self.sites.clone();
+        b.used_imports = self.used.clone();
+    }
+}
+
+/// A pass's outcomes: the pending references' values and the
+/// specialization outcomes.
+type PassOutcomes = (Vec<Option<crate::properties::Atom>>, Vec<Option<usize>>);
+
+/// A library's recorded fixed point, for a redo pass to replay again.
+type LibraryReplay = (Vec<(Option<Uuid>, Vec<String>)>, HashSet<String>);
+
+#[cfg(test)]
+thread_local! {
+    static PASSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+/// How many resolution passes ran.
+#[cfg(test)]
+pub(crate) fn passes() -> usize {
+    PASSES.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_pass() {
+    PASSES.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+fn note_pass() {}
+
 /// One pending reference paired with cache bookkeeping before resolution is
 /// reordered to put specialization outcomes first.
 struct PendingWork {
     source_order: usize,
     pending: PendingRef,
-    lib_hint: Option<Option<Uuid>>,
+    /// A replayed outcome and the root misses recorded with it.
+    lib_hint: Option<(Option<Uuid>, Vec<String>)>,
     record_pos: Option<usize>,
 }
 
-#[derive(Clone, serde::Serialize)]
+#[derive(Clone)]
 pub(crate) struct Elem {
     pub(crate) ty: &'static str,
     id: Uuid,
-    /// Ownership path used to derive `id` and children's ids.
+    /// Ownership path used to derive `id` and children's ids: the whole
+    /// path, or under a `path_parent` only the segment this element adds
+    /// to that element's path (see [`whole_path`]).
     path: String,
+    /// The element whose ownership path this one's extends. Holding the
+    /// segment alone keeps a path's cost its own length rather than its
+    /// depth, which grows by one segment per ownership level.
+    path_parent: Option<usize>,
     pub(crate) props: crate::properties::Properties,
     pub(crate) owned_relationships: crate::flat::Row<usize>,
     pub(crate) children: crate::flat::Row<usize>,
@@ -1012,6 +1573,7 @@ impl<'de> serde::Deserialize<'de> for Elem {
                 .ok_or_else(|| serde::de::Error::custom("unknown metaclass"))?,
             id: w.id,
             path: w.path,
+            path_parent: None,
             props: w.props,
             owned_relationships: w.owned_relationships,
             children: w.children,
@@ -1020,6 +1582,59 @@ impl<'de> serde::Deserialize<'de> for Elem {
     }
 }
 
+/// The whole ownership path of element `i`: the segments of its path
+/// parents and its own, joined by `/`. Each parent precedes its children
+/// in the table, so the walk ends.
+fn whole_path(elements: &crate::layered::LayeredVec<Elem>, i: usize) -> String {
+    let mut segments = vec![elements[i].path.as_str()];
+    let mut at = i;
+    while let Some(parent) = elements[at].path_parent {
+        segments.push(elements[parent].path.as_str());
+        at = parent;
+    }
+    segments.reverse();
+    segments.join("/")
+}
+
+/// The version-5 identity of the name `hash` has read after the identity
+/// namespace — what [`Uuid::new_v5`] computes in one pass.
+fn path_id(hash: &sha1_smol::Sha1) -> Uuid {
+    let mut bytes = [0; 16];
+    bytes.copy_from_slice(&hash.digest().bytes()[..16]);
+    uuid::Builder::from_sha1_bytes(bytes).into_uuid()
+}
+
+#[cfg(test)]
+thread_local! {
+    static PATH_BYTES_HASHED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Bytes the current thread has hashed deriving element identities from
+/// ownership paths.
+#[cfg(test)]
+pub(crate) fn path_bytes_hashed() -> usize {
+    PATH_BYTES_HASHED.with(|c| c.get())
+}
+
+/// Hash `bytes` into an identity's path state.
+fn hash_path(hash: &mut sha1_smol::Sha1, bytes: &[u8]) {
+    #[cfg(test)]
+    PATH_BYTES_HASHED.with(|c| c.set(c.get() + bytes.len()));
+    hash.update(bytes);
+}
+
+/// The hash states that ownership paths leave, kept while a build lowers
+/// sources: a child's identity then hashes its own segment onto its
+/// parent's state instead of its whole path again.
+#[derive(Clone, Default)]
+struct PathHashes {
+    /// The first element with a slot.
+    base: usize,
+    /// The state after the identity namespace and the element's whole
+    /// path, by element index from `base`.
+    states: Vec<Option<sha1_smol::Sha1>>,
+}
+
 #[derive(Clone, Default, serde::Serialize, serde::Deserialize)]
 struct Scope {
     parent: Option<usize>,
@@ -1041,6 +1656,10 @@ struct Scope {
     /// one with that owner excluded, sibling inferred names in its parent
     /// cannot establish the target they themselves are derived from.
     redefinition_names: HashSet<String>,
+    /// Every name-spelled redefinition target of this scope's owner. Keep
+    /// qualification so positional slot reduction can distinguish same-named
+    /// inherited features without consulting a partially built target index.
+    redefinition_spellings: Vec<QualifiedName>,
     /// Namespace imports (`P::*` / `P::*::**`) visible in this scope, with
     /// the recursive flag and the indices (into [`Builder::filter_exprs`])
     /// of the import's own bracket filters (`import P::*[@Safety]`).
@@ -1053,7 +1672,7 @@ struct Scope {
     /// ElementFilterMembership).
     filters: Vec<usize>,
     /// `alias a for X` members.
-    aliases: Vec<(String, QualifiedName, bool)>,
+    aliases: Vec<(String, QualifiedName, usize)>,
     /// Implied end-feature names of a binary connector-family usage: its two
     /// ends implicitly redefine `source`/`target` (SysML 8.4.2, the ends of
     /// `Connections::BinaryConnection`), so those names resolve — in the
@@ -1068,12 +1687,12 @@ struct Scope {
     /// members of these resolve as inherited members.
     bases: Vec<QualifiedName>,
     /// *Implied* heritage (resolution only, never emitted to JSON): the SysML
-    /// Tables 31/32 library bases of the owner's kind, the binary
-    /// connector/interface library base, and the implicit parameter
-    /// redefinition's own-name base. Split from [`Self::bases`] so
+    /// Tables 31/32 library bases of the owner's kind and the binary
+    /// connector/interface library base (the scopes of what a parameter,
+    /// end or result redefines by position join them when the bases are
+    /// read, [`Builder::base_scopes_split`]). Split from [`Self::bases`] so
     /// inherited-member enumeration can distinguish explicit heritage
-    /// from implied ([`Builder::base_scopes_split`]); lookup treats both
-    /// alike.
+    /// from implied; lookup treats both alike.
     implied_bases: Vec<QualifiedName>,
     /// Specialization/typing targets written as feature chains — the
     /// chain's last link contributes inherited members exactly like a
@@ -1084,6 +1703,7 @@ struct Scope {
 
 impl Builder {
     fn build(&mut self, unit: &SourceUnit) {
+        self.keep_path_hashes();
         let root_scope = self.push_scope(None);
         let root = self.new_element("Namespace", None, "$root".to_string());
         for (i, member) in unit.members.iter().enumerate() {
@@ -1091,27 +1711,37 @@ impl Builder {
         }
         self.resolve_pending();
         self.assign_user_ids(0, &[root]);
+        self.path_hashes = None;
     }
 
     /// Build all units of a model into one graph (library units first) and
     /// return the element index where non-library output starts.
     pub(crate) fn build_model(&mut self, model: &crate::model::Model) -> usize {
+        self.graph_format = model.graph_format();
         if let Some(library) = &model.prepared {
-            if !top_level_shadowing(model) && !library.builder.user_completes_library(model) {
+            if library.graph_format() == self.graph_format
+                && !top_level_shadowing(model)
+                && !library.builder.user_completes_library(model)
+            {
                 return self.build_on_library(model, &library.builder);
             }
+            // A prepared library's own recording stands in for the prepared
+            // graph this build cannot reuse.
+            model.arm_prepared_recording();
         }
         match self.build_model_inner(model, false) {
             Ok(boundary) => boundary,
             // Sealed-snapshot validation failed (a lowering change at the
             // same crate version — possible during development). Rebuild
-            // cold; the model's slot flips to Record so the next save
-            // overwrites the stale cache file.
+            // cold, recording: the model's slot flips to Record, so the
+            // rebuild makes the cache the next save overwrites the stale
+            // file with, and a library prepared from this model keeps it.
             Err(()) => {
                 *self = Builder::default();
+                self.graph_format = model.graph_format();
                 model.rerecord_library_cache();
-                self.build_model_inner(model, true)
-                    .expect("cold build cannot fail snapshot validation")
+                self.build_model_inner(model, false)
+                    .expect("a build without a snapshot cannot fail snapshot validation")
             }
         }
     }
@@ -1136,6 +1766,7 @@ impl Builder {
                 let id = match &member.kind {
                     MemberKind::Import(import) | MemberKind::Expose(import) => {
                         names.extend(self.imported_root_names(model, import)?);
+                        names.insert(ROOT_IMPORTS.to_owned());
                         None
                     }
                     // A root filter also constrains the library's own root
@@ -1147,7 +1778,14 @@ impl Builder {
                     // binding from its redefinition/reference target.
                     MemberKind::Usage(u) => {
                         if u.declaration.id.name.is_none() {
-                            names.extend(effective_ref_name(&u.declaration));
+                            names.extend(effective_ref_name(
+                                &u.declaration,
+                                matches!(
+                                    u.kind,
+                                    UsageKind::Perform | UsageKind::Exhibit | UsageKind::Include
+                                ),
+                                u.prefix.is_variant,
+                            ));
                         }
                         Some(&u.declaration.id)
                     }
@@ -1213,12 +1851,18 @@ impl Builder {
                 user_member_names(
                     member_body(member).unwrap_or(&[]),
                     import.is_recursive,
+                    import.is_import_all,
                     &mut names,
                 )?;
             } else {
                 member_names(member, &mut names)?;
                 if import.is_recursive {
-                    user_member_names(member_body(member).unwrap_or(&[]), true, &mut names)?;
+                    user_member_names(
+                        member_body(member).unwrap_or(&[]),
+                        true,
+                        import.is_import_all,
+                        &mut names,
+                    )?;
                 }
             }
             return Some(names);
@@ -1336,6 +1980,7 @@ impl Builder {
 
     fn build_on_library(&mut self, model: &crate::model::Model, library: &Builder) -> usize {
         *self = library.clone();
+        self.keep_path_hashes();
         self.semantic_ready = false;
         let boundary = self.elements.len();
         // Query outcomes are local to this model. In particular a root miss
@@ -1355,12 +2000,48 @@ impl Builder {
             for (i, member) in unit.unit.members.iter().enumerate() {
                 self.build_member(member, root, 0, i);
             }
+            self.restore_payload_flags(model, orig, root);
         }
+        // The outcomes the previous build settled on, where this build's
+        // units resolve the references they did then (see `settled`).
+        self.seed = model
+            .take_settled()
+            .and_then(|settled| self.seed_from(&self.pending, &settled));
+        self.keep_settled = model.keeps_settled();
         self.resolve_pending();
+        if let Some(settled) = self.settled.take() {
+            model.deposit_settled(settled);
+        }
         self.assign_user_ids(boundary, &roots);
+        self.path_hashes = None;
         boundary
     }
 
+    fn restore_payload_flags(&mut self, model: &crate::model::Model, unit: usize, start: usize) {
+        let Some(records) = model.payload_source_flags(unit) else {
+            return;
+        };
+        self.payload_source_units.insert(unit);
+        if records.is_empty() {
+            return;
+        }
+        for i in start..self.elements.len() {
+            let Some(record) = records
+                .get(&whole_path(&self.elements, i))
+                .filter(|record| record.metaclass == self.elements[i].ty)
+            else {
+                continue;
+            };
+            for &key in crate::model::PAYLOAD_USAGE_FLAGS {
+                if let Some(value) = record.flags.get(key) {
+                    self.elements[i]
+                        .props
+                        .insert_payload_flag(key, value.to_json());
+                }
+            }
+        }
+    }
+
     pub(crate) fn prepare_facts(&mut self) -> crate::check::facts::Facts {
         let used = self.used_imports.clone();
         let facts = crate::check::facts::Facts::new(self);
@@ -1369,36 +2050,101 @@ impl Builder {
     }
 
     pub(crate) fn reset_lookup_caches(&mut self) {
+        self.parameter_signatures = None;
         let n = self.scopes.len();
         self.import_cache = vec![None; n];
+        self.recursive_subs.clear();
         self.base_cache = vec![None; n];
-        self.visit_stamp = vec![[0; 3]; n];
-        self.visit_result = vec![[None; 3]; n];
+        self.import_misses = vec![FillMisses::None; n];
+        self.base_misses = vec![FillMisses::None; n];
+        self.semantic_metadata_misses = FillMisses::None;
+        self.fill_frames.clear();
+        self.visit_stamp = vec![[0; 6]; n];
+        self.visit_result = vec![[None; 6]; n];
         self.query_stamp = 0;
         self.import_targets.clear();
+        self.recorded_lookup_graph = None;
         self.semantic_metadata = None;
-        self.id_index = None;
+        // `id_index` stays: the ids it tables change only where identities
+        // are assigned, which discards it itself.
         self.spec_index = None;
         self.mult_index = None;
+        self.positional_redefinitions = None;
+        self.supported_implied = None;
         self.inherited_cache.clear();
         self.inherited_by_heritage.clear();
         self.filters_active = vec![false; self.filter_exprs.len()];
         self.member_import_active.clear();
     }
 
+    pub(crate) fn suppress_semantic_publication(&mut self) {
+        self.publication.suppress();
+    }
+
     pub(crate) fn freeze_library(&mut self) {
-        for i in 0..self.elements.len() {
-            if !self.elements[i].path.is_empty() && self.elements[i].path != "first" {
-                let first = self.elements[i].path.ends_with("first");
-                self.elements[i].path = if first { "first".into() } else { String::new() };
-            }
+        assert!(
+            self.implied.is_none() && self.implied_from.is_none(),
+            "prepared libraries contain source rows only"
+        );
+        self.publication.suppress();
+        if self.recorded_lookup_candidate
+            && !self.recorded_lookup_incomplete
+            && self.lib_boundary == self.elements.len()
+            && !self.library_refs_to_users
+        {
+            let mut graph = self
+                .recorded_lookup_graph
+                .take()
+                .unwrap_or_else(|| recorded_lookup::Graph::build(self));
+            graph.freeze();
+            self.recorded_lookup_prefix = Some(Arc::new(graph));
+        } else {
+            self.recorded_lookup_prefix = None;
         }
+        for i in 0..self.elements.len() {
+            let row = &self.elements[i];
+            // A whole path under a parent holds a `/`, so it is neither empty
+            // nor `first`; it ends as its own segment does.
+            if row.path_parent.is_some() || (!row.path.is_empty() && row.path != "first") {
+                let first = row.path.ends_with("first");
+                let row = &mut self.elements[i];
+                row.path = if first { "first".into() } else { String::new() };
+                row.path_parent = None;
+            }
+        }
+        self.recorded_lookup_graph = None;
+        // Builds on a prepared library never record resolution outcomes, and
+        // each one starts from a copy of this builder.
+        self.spec_misses.clear();
+        self.ref_misses.clear();
+        self.base_misses = Vec::new();
+        self.import_misses = Vec::new();
         self.elements.freeze();
+        // the frozen rows' structural scan, shared by every build on them
+        self.prefix_structure = structural_index::StoredStructure::prefix_of(self);
+        // the frozen rows by id, shared with the kept lookup graph
+        self.prefix_ids = Some(
+            self.recorded_lookup_prefix
+                .as_ref()
+                .and_then(|graph| graph.frozen_ids())
+                .unwrap_or_else(|| {
+                    Arc::new(
+                        self.elements
+                            .iter()
+                            .enumerate()
+                            .map(|(i, e)| (e.id, i))
+                            .collect(),
+                    )
+                }),
+        );
+        self.prefix_table_names = Arc::new(std::sync::OnceLock::new());
         self.scopes.freeze();
         self.semantic_memo.freeze();
         self.id_index = None;
         self.spec_index = None;
         self.mult_index = None;
+        self.positional_redefinitions = None;
+        self.supported_implied = None;
         self.inherited_cache.clear();
         self.inherited_by_heritage.clear();
         self.elem_scope.freeze();
@@ -1409,12 +2155,15 @@ impl Builder {
         self.transition_guards.freeze();
         self.decl_spans.freeze();
         self.member_spans.freeze();
-        self.in_params.freeze();
         self.ctor_fields.freeze();
         self.return_params.freeze();
         self.usage_featuring.freeze();
         self.prefix_meta_next.freeze();
         self.metadata_of.freeze();
+        if let Some(intrinsic) = &mut self.metadata_intrinsic {
+            intrinsic.freeze();
+        }
+        self.explicit_metadata_annotations.freeze();
         self.conjugated_defs.freeze();
         self.lib_qnames.freeze();
         self.lib_mem_qnames.freeze();
@@ -1460,10 +2209,38 @@ impl Builder {
                     && e.owning_relationship
                         .is_none_or(|r| self.elements[r].children.contains(&i))
             })
+            && self
+                .metadata_of
+                .iter()
+                .all(|(&target, sources)| target < n && sources.iter().all(|&source| source < n))
+            && self.metadata_intrinsic.as_ref().is_none_or(|map| {
+                map.iter().all(|(&target, sources)| {
+                    target < n && sources.iter().all(|&source| source < n)
+                })
+            })
+            && self
+                .metadata_about
+                .iter()
+                .all(|(&target, sources)| target < n && sources.iter().all(|&source| source < n))
+            && (self.metadata_about.is_empty() || self.metadata_intrinsic.is_some())
+            && self
+                .explicit_metadata_annotations
+                .iter()
+                .all(|&annotation| {
+                    annotation < n
+                        && crate::metaclass::conforms(self.elements[annotation].ty, "Annotation")
+                })
             && self.semantic_memo.valid(n, ns)
             && self.scopes.iter().enumerate().all(|(s, scope)| {
                 scope.parent.is_none_or(|p| p < s)
                     && scope.owner.is_none_or(|e| e < n)
+                    && scope.filters.iter().all(|&f| f < self.filter_exprs.len())
+                    && scope.imports.iter().all(|i| {
+                        i.relationship < n && i.filters.iter().all(|&f| f < self.filter_exprs.len())
+                    })
+                    && scope.member_imports.iter().all(|i| {
+                        i.relationship < n && i.filters.iter().all(|&f| f < self.filter_exprs.len())
+                    })
                     && scope
                         .names
                         .values()
@@ -1487,6 +2264,8 @@ impl Builder {
                 .multiplicities
                 .iter()
                 .all(|(e, s, _)| *e < n && *s < ns)
+            && self.filter_exprs.iter().all(|(e, s, _)| *e < n && *s < ns)
+            && self.filters_active.len() == self.filter_exprs.len()
     }
 
     fn build_model_inner(
@@ -1494,6 +2273,7 @@ impl Builder {
         model: &crate::model::Model,
         no_cache: bool,
     ) -> Result<usize, ()> {
+        self.keep_path_hashes();
         let root_scope = self.push_scope(None);
         let mut ordered: Vec<_> = model
             .units()
@@ -1523,7 +2303,9 @@ impl Builder {
         };
         let mut snapshot: Option<Arc<crate::libcache::LibraryCache>> = None;
         match slot {
-            crate::model::LibCacheSlot::Use(cache) if !top_level_shadowing(model) => {
+            crate::model::LibCacheSlot::Use(cache)
+                if cache.graph_format == self.graph_format && !top_level_shadowing(model) =>
+            {
                 self.lib_ids_in = Some((Arc::clone(&cache), 0));
                 snapshot = Some(cache);
             }
@@ -1555,6 +2337,7 @@ impl Builder {
             for (m, member) in mu.unit.members.iter().enumerate() {
                 self.build_member(member, root, root_scope, m);
             }
+            self.restore_payload_flags(model, *orig, root);
         }
         if boundary_units == ordered.len() {
             boundary = self.elements.len();
@@ -1585,6 +2368,7 @@ impl Builder {
                 .zip(cache.outcome_misses.iter().cloned())
                 .collect();
             self.lib_hints = Some(hints.into_iter());
+            self.lib_hints_fixed_point = cache.fixed_point;
             // Recorded outcomes are replayed only where the user units cannot
             // have changed them; an unlocatable root contribution disables
             // replay for this build.
@@ -1620,6 +2404,8 @@ impl Builder {
         if let Some(recorded) = self.lib_record.take() {
             let (outcomes, outcome_misses) = recorded.into_iter().unzip();
             model.deposit_recorded(crate::libcache::LibraryCache {
+                graph_format: self.graph_format,
+                fixed_point: boundary_units == ordered.len() && !self.recorded_lookup_incomplete,
                 outcomes,
                 outcome_misses,
                 fingerprint: lib_fingerprint,
@@ -1628,6 +2414,7 @@ impl Builder {
                 lib_mem_qnames: self.lib_mem_qnames.iter().cloned().collect(),
             });
         }
+        self.path_hashes = None;
         Ok(boundary)
     }
 
@@ -1726,6 +2513,7 @@ impl Builder {
                 }
             }
         }
+        self.id_index = None;
     }
 
     /// Extend `lib_qnames` with redefinition-named library members
@@ -1885,7 +2673,7 @@ impl Builder {
     }
 
     /// The declared half of the naming rule: an element's own declared
-    /// (short) name, with no derivation. `Self::graph_effective_name`
+    /// (short) name, with no derivation. `Self::graph_identity_name`
     /// carries the derived half; see it for the rule and its other
     /// implementations.
     pub(crate) fn effective_name(&self, e: usize) -> Option<String> {
@@ -1913,30 +2701,29 @@ impl Builder {
         }
     }
 
-    /// The graph-effective name of an unnamed element (KerML 8.2.3.5):
-    /// the first `Redefinition`/`ReferenceSubsetting` target's name in
-    /// `ownedRelationship` order, read from the *graph* — a resolved
-    /// `{"@id"}` target names through `names`, a hermetic `{"@ref"}`
-    /// placeholder carries the name itself (last qualification segment).
-    ///
-    /// One naming rule, four representations — an element is named by
-    /// its declaration (`Self::effective_name`), else by its *naming
-    /// feature*: the first feature it redefines, else the one it
-    /// references, else the last link of its chain, each followed
-    /// transitively. The implementations are this one (over the lowered
-    /// element graph), `lift::Lifter::effective_name` (over payload
-    /// JSON), `full::effective_name_of` (over the full form's element
-    /// maps, which also derives the positional implied names), and the
-    /// fixpoint inside `ids::walk` (over a compact payload, for id
-    /// segments). They agree by construction and by the differential test
-    /// in the round-trip gate; a change to one belongs in all of them.
-    fn graph_effective_name(
-        &self,
-        e: usize,
-        by_id: &HashMap<Uuid, usize>,
-        names: &[Option<String>],
-    ) -> Option<String> {
+    /// Versioned identity label used only by ID scheme 2. Its historical
+    /// generic ReferenceSubsetting fallback is retained for decoder parity;
+    /// it does not confer a semantic name. Keep this algorithm synchronized
+    /// with `ids::walk`, independently of the public naming projection.
+    fn graph_identity_name(&self, e: usize, tables: &mut IdentityTables) -> Option<String> {
+        let named_reference = naming::reference_names_feature(
+            self.elements[e].ty,
+            self.elements[e]
+                .owning_relationship
+                .map(|r| self.elements[r].ty),
+        )
+        .then(|| {
+            self.elements[e]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&r| self.elements[r].ty == "ReferenceSubsetting")
+        })
+        .flatten();
         for &r in &self.elements[e].owned_relationships {
+            if named_reference.is_some() && Some(r) != named_reference {
+                continue;
+            }
             let rel = &self.elements[r];
             let key = match rel.ty {
                 "Redefinition" => "redefinedFeature",
@@ -1947,14 +2734,36 @@ impl Builder {
             if let Some(s) = target.get("@ref").and_then(|v| v.as_str()) {
                 return Some(s.rsplit("::").next().unwrap_or(s).to_string());
             }
-            let t = *by_id.get(&target.as_reference()?)?;
-            return names[t].clone();
+            let mut t = tables.index_of(&target.as_reference()?)?;
+            if key == "referencedFeature"
+                && naming::reference_names_feature_target(
+                    self.elements[e].ty,
+                    self.elements[e]
+                        .owning_relationship
+                        .map(|r| self.elements[r].ty),
+                )
+            {
+                if let Some(last) = self.elements[t]
+                    .owned_relationships
+                    .iter()
+                    .rev()
+                    .find(|&&r| self.elements[r].ty == "FeatureChaining")
+                {
+                    t = tables.index_of(
+                        &self.elements[*last]
+                            .props
+                            .get("chainingFeature")?
+                            .as_reference()?,
+                    )?;
+                }
+            }
+            return tables.name(self, t);
         }
         None
     }
 
     /// Reassign user-element ids to the graph-derived scheme (IDS.md;
-    /// id scheme 1): `id(child) = uuid5(id(parent),
+    /// id scheme 2): `id(child) = uuid5(id(parent),
     /// segment)`, chained from each unit root (whose id stays assigned
     /// — the root names the source unit, which the interchange graph
     /// does not carry). Segments: a single-member membership with a
@@ -1970,38 +2779,58 @@ impl Builder {
         if boundary >= n || roots.is_empty() {
             return;
         }
-        // Relationship → owned elements, creation (= array) order.
-        let mut owned_by_rel: Vec<Vec<usize>> = vec![Vec::new(); n];
-        for (i, e) in self.elements.iter().enumerate() {
-            if let Some(r) = e.owning_relationship {
-                owned_by_rel[r].push(i);
-            }
-        }
+        // The rows read by id and by name: a build on frozen rows reads
+        // the frozen rows' ids through the table their freeze kept and
+        // their names on demand, and tables only its own rows; any other
+        // build tables every row.
+        let frozen = self
+            .prefix_ids
+            .clone()
+            .filter(|ids| ids.len() == boundary && self.elements.base_untouched());
+        let start = if frozen.is_some() { boundary } else { 0 };
+        if frozen.is_some() {
+            note_prefix_ids_served();
+        }
+        let mut tables = IdentityTables {
+            start,
+            by_id: crate::layered::IdMap::with_capacity_and_hasher(n - start, Default::default()),
+            names: Vec::with_capacity(n - start),
+            frozen,
+            table_names: None,
+        };
         // Pre-reassignment id → index, for resolved reference targets.
-        let mut by_id: HashMap<Uuid, usize> = HashMap::with_capacity(n);
-        for (i, e) in self.elements.iter().enumerate() {
-            by_id.insert(e.id, i);
+        for (i, e) in self.elements.iter().enumerate().skip(start) {
+            tables.by_id.insert(e.id, i);
         }
         // Names: declared everywhere; library elements additionally
         // through the effective-name tables; unnamed user elements by
         // the graph-effective fixpoint (`:>>` chains may pass through
         // other effectively named members).
-        let mut names: Vec<Option<String>> = (0..n).map(|i| self.effective_name(i)).collect();
-        for (id, segs) in self.lib_qnames.iter().chain(self.lib_mem_qnames.iter()) {
-            if let Some(&i) = by_id.get(id) {
-                if names[i].is_none() {
-                    names[i] = segs.last().cloned();
-                }
+        for i in start..n {
+            let id = self.elements[i].id;
+            let mut name = self.effective_name(i);
+            // The tables name the last row carrying an id of theirs, and
+            // theirs are the frozen rows' ids.
+            if name.is_none()
+                && tables.by_id.get(&id) == Some(&i)
+                && tables
+                    .frozen
+                    .as_ref()
+                    .is_none_or(|frozen| frozen.contains_key(&id))
+            {
+                name = tables.table_name(self, id);
             }
+            tables.names.push(name);
         }
         loop {
             let mut changed = false;
             for e in boundary..n {
-                if names[e].is_some() || self.elements[e].ty.ends_with("Membership") {
+                if tables.names[e - start].is_some() || self.elements[e].ty.ends_with("Membership")
+                {
                     continue;
                 }
-                if let Some(name) = self.graph_effective_name(e, &by_id, &names) {
-                    names[e] = Some(name);
+                if let Some(name) = self.graph_identity_name(e, &mut tables) {
+                    tables.names[e - start] = Some(name);
                     changed = true;
                 }
             }
@@ -2009,6 +2838,14 @@ impl Builder {
                 break;
             }
         }
+        // Relationship → owned elements, creation (= array) order, for the
+        // relationships the walk reaches: those owned from `boundary`.
+        let mut owned_by_rel: Vec<Vec<usize>> = vec![Vec::new(); n - boundary];
+        for (i, e) in self.elements.iter().enumerate().skip(boundary) {
+            if let Some(r) = e.owning_relationship.filter(|&r| r >= boundary) {
+                owned_by_rel[r - boundary].push(i);
+            }
+        }
         // Top-down walk: parents carry their final ids before children
         // derive from them.
         let mut remap: HashMap<Uuid, Uuid> = HashMap::new();
@@ -2018,8 +2855,31 @@ impl Builder {
             let rels = self.elements[owner].owned_relationships.clone();
             let mut used: HashSet<String> = HashSet::new();
             for (i, rel) in rels.into_iter().enumerate() {
-                let kids = owned_by_rel[rel].clone();
+                let kids = if rel >= boundary {
+                    owned_by_rel[rel - boundary].clone()
+                } else {
+                    // A frozen relationship claimed by a row of this build,
+                    // which no production writer makes: its owned rows, as
+                    // a table over every row lists them.
+                    (0..n)
+                        .filter(|&i| self.elements[i].owning_relationship == Some(rel))
+                        .collect()
+                };
                 let membership = self.elements[rel].ty.ends_with("Membership");
+                // The constructor result is a structural role, independent of
+                // effective names and argument ordinals. In particular it must
+                // not capture a legacy first argument's positional identity.
+                if self.elements[owner].ty == "ConstructorExpression"
+                    && self.elements[rel].ty == "ReturnParameterMembership"
+                    && kids.len() == 1
+                    && self.elements[kids[0]].ty == "Feature"
+                {
+                    let rel_id = Uuid::new_v5(&owner_id, b"result");
+                    self.reassign_id(rel, rel_id, &mut remap);
+                    self.reassign_id(kids[0], Uuid::new_v5(&rel_id, b"e0"), &mut remap);
+                    stack.extend([rel, kids[0]]);
+                    continue;
+                }
                 // A single-member membership whose member has an
                 // id-name chains **past the membership**:
                 // the member takes the owner-scope named segment, and
@@ -2029,8 +2889,8 @@ impl Builder {
                 // (duplicate member names, aliases) drop the pair
                 // back to the positional chain.
                 if membership && kids.len() == 1 {
-                    if let Some(name) = &names[kids[0]] {
-                        let named = format!("::{}", escape_name(name));
+                    if let Some(name) = tables.name(self, kids[0]) {
+                        let named = format!("::{}", escape_name(&name));
                         if used.insert(named.clone()) {
                             let kid = kids[0];
                             let kid_id = Uuid::new_v5(&owner_id, named.as_bytes());
@@ -2065,8 +2925,8 @@ impl Builder {
                 for (j, kid) in kids.into_iter().enumerate() {
                     let mut kseg = format!("e{j}");
                     if membership {
-                        if let Some(name) = &names[kid] {
-                            let named = format!("::{}", escape_name(name));
+                        if let Some(name) = tables.name(self, kid) {
+                            let named = format!("::{}", escape_name(&name));
                             if kid_used.insert(named.clone()) {
                                 kseg = named;
                             }
@@ -2080,14 +2940,54 @@ impl Builder {
         if remap.is_empty() {
             return;
         }
-        // Re-point every captured reference (library elements never
-        // reference user elements, so the sweep stays in user range).
-        for i in boundary..self.elements.len() {
-            let e = &mut self.elements[i];
-            for v in e.props.values_mut() {
-                v.remap(&remap);
-            }
+        self.id_index = None;
+        self.supported_implied = None;
+        // A library reference can resolve a root supplied by user units.
+        // Remap those captured endpoints as well as user-owned references.
+        fn needs_remap(atom: &crate::properties::Atom, remap: &HashMap<Uuid, Uuid>) -> bool {
+            use crate::properties::Atom;
+            match atom {
+                Atom::Reference(_) => atom
+                    .as_reference()
+                    .is_some_and(|id| remap.contains_key(&id)),
+                Atom::Array(values) => values.iter().any(|v| needs_remap(v, remap)),
+                Atom::Object(values) => values.values().any(|v| needs_remap(v, remap)),
+                _ => false,
+            }
+        }
+        let reference_start = if self.library_refs_to_users {
+            0
+        } else {
+            boundary
+        };
+        for i in reference_start..self.elements.len() {
+            if i < boundary
+                && !self.elements[i]
+                    .props
+                    .entries
+                    .iter()
+                    .any(|(_, v)| needs_remap(v, &remap))
+            {
+                continue;
+            }
+            let e = &mut self.elements[i];
+            for v in e.props.values_mut() {
+                v.remap(&remap);
+            }
+        }
+        if let Some(record) = self.lib_record.as_mut() {
+            for (target, _) in record {
+                if let Some(id) = target.as_mut() {
+                    if let Some(&new) = remap.get(id) {
+                        *id = new;
+                    }
+                }
+            }
         }
+        // Final user identity assignment can expose UUID collisions that were
+        // absent in the provisional lowering graph. Revalidate associations
+        // before publishing immutable metadata navigation.
+        self.refresh_metadata_associations();
     }
 
     fn finish(self, boundary: usize) -> Value {
@@ -2095,7 +2995,7 @@ impl Builder {
         self.finish_range(boundary, end)
     }
 
-    fn finish_range(self, start: usize, end: usize) -> Value {
+    fn finish_range(&self, start: usize, end: usize) -> Value {
         // Materialize relationship arrays as {"@id"} references.
         let ids: Vec<Uuid> = self.elements.iter().map(|e| e.id).collect();
         let mut out = Vec::with_capacity(end - start);
@@ -2111,21 +3011,21 @@ impl Builder {
                 Value::Array(
                     elem.owned_relationships
                         .iter()
-                        .map(|&i| id_ref(ids[i]))
+                        .map(|&i| id_value(ids[i]))
                         .collect(),
                 ),
             );
             obj.insert(
                 "owningRelationship".into(),
                 elem.owning_relationship
-                    .map(|i| id_ref(ids[i]))
+                    .map(|i| id_value(ids[i]))
                     .unwrap_or(Value::Null),
             );
             obj.extend(elem.props.to_json());
             if !elem.children.is_empty() {
                 obj.insert(
                     "ownedRelatedElement".into(),
-                    Value::Array(elem.children.iter().map(|&i| id_ref(ids[i])).collect()),
+                    Value::Array(elem.children.iter().map(|&i| id_value(ids[i])).collect()),
                 );
             }
             out.push(Value::Object(obj));
@@ -2142,8 +3042,10 @@ impl Builder {
         });
         self.import_cache.push(None);
         self.base_cache.push(None);
-        self.visit_stamp.push([0; 3]);
-        self.visit_result.push([None; 3]);
+        self.import_misses.push(FillMisses::None);
+        self.base_misses.push(FillMisses::None);
+        self.visit_stamp.push([0; 6]);
+        self.visit_result.push([None; 6]);
         self.scopes.len() - 1
     }
 
@@ -2200,13 +3102,20 @@ impl Builder {
     }
 
     fn new_element(&mut self, ty: &'static str, owner_rel: Option<usize>, path: String) -> usize {
-        let id = self
-            .next_lib_id()
-            .unwrap_or_else(|| Uuid::new_v5(&ID_NAMESPACE, path.as_bytes()));
+        let id = match self.next_lib_id() {
+            Some(id) => id,
+            None => {
+                let mut hash = sha1_smol::Sha1::new();
+                hash_path(&mut hash, ID_NAMESPACE.as_bytes());
+                hash_path(&mut hash, path.as_bytes());
+                self.keep_path_hash(hash)
+            }
+        };
         self.elements.push(Elem {
             ty,
             id,
             path,
+            path_parent: None,
             props: crate::properties::Properties::new(),
             owned_relationships: Default::default(),
             children: Default::default(),
@@ -2232,20 +3141,66 @@ impl Builder {
         self.implied_from.unwrap_or(self.elements.len())
     }
 
+    /// Keep the ownership-path hash state of each element created from
+    /// here on, until the build ends.
+    fn keep_path_hashes(&mut self) {
+        self.path_hashes = Some(PathHashes {
+            base: self.elements.len(),
+            states: Vec::new(),
+        });
+    }
+
+    /// The identity of the element about to be created, whose whole path
+    /// `hash` has read after the identity namespace. Its state is kept for
+    /// the element's children while a build lowers.
+    fn keep_path_hash(&mut self, hash: sha1_smol::Sha1) -> Uuid {
+        let id = path_id(&hash);
+        let i = self.elements.len();
+        if let Some(kept) = &mut self.path_hashes {
+            if let Some(slot) = i.checked_sub(kept.base) {
+                if kept.states.len() <= slot {
+                    kept.states.resize(slot + 1, None);
+                }
+                kept.states[slot] = Some(hash);
+            }
+        }
+        id
+    }
+
+    /// The identity of the element about to be created with `segment`
+    /// appended to `parent`'s ownership path: the version-5 identity of the
+    /// whole path, hashing only `/` and the segment onto the parent's kept
+    /// state. Without a kept state the parent's whole path is hashed first.
+    fn child_path_id(&mut self, parent: usize, segment: &str) -> Uuid {
+        let kept = self
+            .path_hashes
+            .as_ref()
+            .and_then(|kept| kept.states.get(parent.checked_sub(kept.base)?)?.clone());
+        let mut hash = kept.unwrap_or_else(|| {
+            let mut hash = sha1_smol::Sha1::new();
+            hash_path(&mut hash, ID_NAMESPACE.as_bytes());
+            hash_path(&mut hash, whole_path(&self.elements, parent).as_bytes());
+            hash
+        });
+        hash_path(&mut hash, b"/");
+        hash_path(&mut hash, segment.as_bytes());
+        self.keep_path_hash(hash)
+    }
+
     fn new_relationship(&mut self, ty: &'static str, owner: usize, path_seg: &str) -> usize {
-        let (path, id) = match self.next_lib_id() {
+        let (path, path_parent, id) = match self.next_lib_id() {
             // Sealed snapshot: paths only feed id derivation, so skip both.
-            Some(id) => (String::new(), id),
+            Some(id) => (String::new(), None, id),
             None => {
-                let path = format!("{}/{}", self.elements[owner].path, path_seg);
-                let id = Uuid::new_v5(&ID_NAMESPACE, path.as_bytes());
-                (path, id)
+                let id = self.child_path_id(owner, path_seg);
+                (path_seg.to_owned(), Some(owner), id)
             }
         };
         self.elements.push(Elem {
             ty,
             id,
             path,
+            path_parent,
             props: crate::properties::Properties::new(),
             owned_relationships: Default::default(),
             children: Default::default(),
@@ -2263,19 +3218,19 @@ impl Builder {
 
     /// Create an element owned via `rel` (`ownedRelatedElement`).
     fn new_owned_element(&mut self, ty: &'static str, rel: usize, name_seg: &str) -> usize {
-        let (path, id) = match self.next_lib_id() {
+        let (path, path_parent, id) = match self.next_lib_id() {
             // Sealed snapshot: paths only feed id derivation, so skip both.
-            Some(id) => (String::new(), id),
+            Some(id) => (String::new(), None, id),
             None => {
-                let path = format!("{}/{}", self.elements[rel].path, name_seg);
-                let id = Uuid::new_v5(&ID_NAMESPACE, path.as_bytes());
-                (path, id)
+                let id = self.child_path_id(rel, name_seg);
+                (name_seg.to_owned(), Some(rel), id)
             }
         };
         self.elements.push(Elem {
             ty,
             id,
             path,
+            path_parent,
             props: crate::properties::Properties::new(),
             owned_relationships: Default::default(),
             children: Default::default(),
@@ -2286,7 +3241,7 @@ impl Builder {
         idx
     }
 
-    fn set(&mut self, elem: usize, key: &str, value: Value) {
+    fn set(&mut self, elem: usize, key: &str, value: impl Into<crate::properties::Atom>) {
         self.elements[elem].props.insert(key, value);
     }
 
@@ -2497,14 +3452,15 @@ impl Builder {
         self.set(e, "isVariation", json!(false));
         let ft = self.new_relationship("FeatureTyping", e, "typing");
         self.set(ft, "isImplied", json!(false));
+        // Record before creating the pending reference so its outcome is
+        // indexed just like an explicitly written metadata typing.
+        self.spec_targets
+            .push((e, "FeatureTyping", scope, m.clone()));
+        self.pending_spec_idx = Some(self.spec_targets.len() - 1);
         self.set_ref(ft, "type", scope, &TargetRef::Name(m.clone()));
         let e_id = self.elements[e].id;
         self.set(ft, "typedFeature", id_ref(e_id));
-        // Recorded like declared typings so the semantic checks (and
-        // explicit-supertype walks) see prefix metadata too.
-        self.spec_targets
-            .push((e, "FeatureTyping", scope, m.clone()));
-        self.metadata_of.entry(owner).or_default().push(e);
+        self.record_intrinsic_metadata(owner, e);
     }
 
     fn build_member(&mut self, member: &Member, owner: usize, scope: usize, index: usize) {
@@ -2614,7 +3570,7 @@ impl Builder {
                     scope,
                     visibility: member.visibility,
                 });
-                let fids = self.record_filters(&imp.filters, scope);
+                let fids = self.record_filters(&imp.filters, rel, scope);
                 let is_public =
                     member.visibility.is_none() || member.visibility == Some(Visibility::Public);
                 if imp.is_namespace {
@@ -2674,13 +3630,20 @@ impl Builder {
                     scope,
                     &TargetRef::Name(a.target.clone()),
                 );
-                if let Some(name) = &a.id.name {
-                    self.scopes[scope].aliases.push((
-                        name.value.clone(),
-                        a.target.clone(),
-                        member.visibility.is_none()
-                            || member.visibility == Some(Visibility::Public),
-                    ));
+                for name in a.id.name.iter().chain(a.id.short_name.iter()) {
+                    if self.scopes[scope]
+                        .aliases
+                        .last()
+                        .is_some_and(|entry| entry.2 == rel && entry.0 == name.value)
+                    {
+                        continue;
+                    }
+                    let index = self.scopes[scope].aliases.len();
+                    self.alias_origins
+                        .insert((scope, index), self.unit_of_elem(rel));
+                    self.scopes[scope]
+                        .aliases
+                        .push((name.value.clone(), a.target.clone(), rel));
                 }
             }
             MemberKind::Comment(c) => {
@@ -2743,7 +3706,7 @@ impl Builder {
                 self.build_expr(expr, rel, scope, "condition");
                 // A namespace's filter conditions apply to every membership
                 // it imports (resolution-side of ElementFilterMembership).
-                let fids = self.record_filters(std::slice::from_ref(expr), scope);
+                let fids = self.record_filters(std::slice::from_ref(expr), rel, scope);
                 self.scopes[scope].filters.extend(fids);
             }
             MemberKind::Definition(d) => self.build_definition(d, member, owner, scope, index),
@@ -2909,7 +3872,7 @@ impl Builder {
                 );
                 // An expose is an import for name resolution: exposed
                 // members are referencable within the view body.
-                let fids = self.record_filters(&imp.filters, scope);
+                let fids = self.record_filters(&imp.filters, rel, scope);
                 if imp.is_namespace {
                     self.scopes[scope].imports.push(NamespaceImport {
                         target: imp.target.clone(),
@@ -3009,6 +3972,7 @@ impl Builder {
                     self.set_ref(s, "subsettedFeature", scope, subsets);
                 }
                 if let Some(range) = &m.range {
+                    self.multiplicities.push((e, scope, range.clone()));
                     // A multiplicity declaration owns its bound expressions
                     // directly (it *is* the MultiplicityRange).
                     if let Some(lower) = &range.lower {
@@ -3121,6 +4085,11 @@ impl Builder {
             }
             self.in_enum_body = false;
         }
+        // SysML binary definition rules count owned ends. Their library
+        // heritage must be available before resolving end redefinitions.
+        if let Some((base, true)) = self.binary_owned_base(e) {
+            self.scopes[body_scope].implied_bases.push(lib_qn(base));
+        }
         // Every port definition owns its implicit conjugated definition
         // (pilot ConjugatedPortDefinitionMember, after the body): an
         // OwningMembership → ConjugatedPortDefinition `~P` whose
@@ -3287,17 +4256,6 @@ impl Builder {
             .as_ref()
             .map(|n| n.value.clone())
             .unwrap_or_else(|| format!("#{index}"));
-        if matches!(
-            u.prefix.direction,
-            Some(FeatureDirection::In | FeatureDirection::InOut)
-        ) {
-            if let Some(n) = &u.declaration.id.name {
-                self.in_params
-                    .entry(owner)
-                    .or_default()
-                    .push(n.value.clone());
-            }
-        }
         let e = self.build_usage_element(u, rel, scope, &seg, class_override);
         if let Some(n) = &u.declaration.id.name {
             self.ctor_fields
@@ -3310,7 +4268,7 @@ impl Builder {
         if u.kind == UsageKind::Metadata
             && matches!(&u.detail, UsageDetail::Metadata { about } if about.is_empty())
         {
-            self.metadata_of.entry(owner).or_default().push(e);
+            self.record_intrinsic_metadata(owner, e);
         }
         (rel, e)
     }
@@ -3339,6 +4297,7 @@ impl Builder {
         let owner_ty = self.pending_owner_ty.take();
         self.set_identification(e, &u.declaration.id);
         self.emit_prefix_metadata(e, &u.prefix.metadata, scope);
+        let body_scope = self.push_scope(Some(scope));
         if let Some(cross) = &u.prefix.end_cross {
             let om = self.new_relationship("OwningMembership", e, "crossFeature");
             self.set(om, "isImplied", json!(false));
@@ -3378,9 +4337,11 @@ impl Builder {
                 self.set(cf, "isVariable", json!(true));
             }
             self.set_identification(cf, &cross.decl.id);
-            self.emit_specializations(cf, &cross.decl, scope);
+            // The cross feature is an owned member of the end feature, so
+            // its references see that end's members and inherited types.
+            self.emit_specializations(cf, &cross.decl, body_scope);
             if let Some(mult) = &cross.decl.multiplicity {
-                self.emit_multiplicity(cf, mult, scope);
+                self.emit_multiplicity(cf, mult, body_scope);
             }
         }
         // A variation is implicitly abstract (pilot `UsageAdapter.postProcess`).
@@ -3458,7 +4419,6 @@ impl Builder {
             );
         }
 
-        let body_scope = self.push_scope(Some(scope));
         self.register(scope, &u.declaration.id.clone(), e, body_scope);
         // Unnamed features take an effective name from the first feature
         // they redefine (KerML 8.2.3.5) or reference (SysML variant/perform/
@@ -3466,7 +4426,11 @@ impl Builder {
         // `:>> mass = 5;` are findable by those names. Resolution-only —
         // declaredName stays null.
         if u.declaration.id.name.is_none() && u.declaration.id.short_name.is_none() {
-            if let Some(name) = effective_ref_name(&u.declaration) {
+            if let Some(name) = effective_ref_name(
+                &u.declaration,
+                naming::reference_names_feature_target(ty, Some(self.elements[rel].ty)),
+                self.elements[rel].ty == "VariantMembership",
+            ) {
                 self.effective_hint.insert(e, name.clone());
                 self.scopes[scope].effective_names.push(
                     name,
@@ -3502,13 +4466,15 @@ impl Builder {
             for t in targets {
                 match t {
                     TargetRef::Name(qn) => {
-                        if matches!(spec, FeatureSpecialization::Redefines(_))
-                            && !qn.is_global
-                            && qn.segments.len() == 1
-                        {
+                        if matches!(spec, FeatureSpecialization::Redefines(_)) {
                             self.scopes[body_scope]
-                                .redefinition_names
-                                .insert(qn.segments[0].value.clone());
+                                .redefinition_spellings
+                                .push(qn.clone());
+                            if !qn.is_global && qn.segments.len() == 1 {
+                                self.scopes[body_scope]
+                                    .redefinition_names
+                                    .insert(qn.segments[0].value.clone());
+                            }
                         }
                         self.scopes[body_scope].bases.push(qn.clone());
                     }
@@ -3537,21 +4503,19 @@ impl Builder {
                 self.scopes[body_scope].implied_bases.push(lib_qn(base));
             }
         }
-        // Implicit parameter redefinition (SysML 8.3): a named directed
-        // parameter redefines the same-named parameter of its owner's type.
-        // Its own name as a base resolves — with the owner excluded — to
-        // that inherited parameter, making its members visible
-        // (`focus.image.isWellFocused` with `out item image;`).
-        if u.prefix.direction.is_some() {
-            if let Some(name) = &u.declaration.id.name {
-                self.scopes[body_scope].implied_bases.push(QualifiedName {
-                    is_global: false,
-                    segments: vec![name.clone()],
-                    span: name.span,
-                });
-            }
+        // Every Step specializes the Kernel Semantic Library performance
+        // feature, including untyped KerML steps.
+        if crate::metaclass::conforms(ty, "Step") {
+            self.scopes[body_scope]
+                .implied_bases
+                .push(lib_qn("Performances::performances"));
         }
-
+        // Every Feature specializes Base::things, including ordinary KerML
+        // features whose syntax kind has no SysML-specific implied base.
+        // Its nested `that` feature must therefore participate in lookup.
+        self.scopes[body_scope]
+            .implied_bases
+            .push(lib_qn("Base::things"));
         self.emit_specializations(e, &u.declaration, scope);
 
         if let Some(mult) = &u.declaration.multiplicity {
@@ -3798,56 +4762,77 @@ impl Builder {
         }
         let end_elems = self.build_usage_detail(e, &detail, scope);
 
-        // A *binary* connector-family usage (exactly two ends): its body
-        // additionally bases on the library's binary variant (SysML 8.4.2
-        // Table 32 — BinaryConnection/BinaryInterface declare the end
-        // features `source`/`target`; the n-ary bases don't), and its own
-        // two ends implicitly redefine those ends, so `source`/`target` in
-        // the body resolve to the end features themselves. Each end gets a
-        // scope basing on its connected feature, so chain members
-        // (`flow … from source.x to target.y`) resolve through the ends.
-        // The base resolves from the end scope's parent — the owning scope,
-        // where the end target itself resolves.
+        // Connector-part end declarations own the same lookup bindings as
+        // ordinary end members. Their scopes inherit the connected feature,
+        // with target names resolved outside the connector's body to avoid
+        // capturing the end currently being declared.
         if matches!(
             u.kind,
             UsageKind::Connection
                 | UsageKind::Interface
                 | UsageKind::Allocation
                 | UsageKind::Connector
-        ) && end_elems.len() == 2
-        {
-            if self.dialect == Dialect::Sysml {
-                let binary = match u.kind {
-                    UsageKind::Connection => Some("Connections::binaryConnections"),
-                    UsageKind::Interface => Some("Interfaces::binaryInterfaces"),
-                    _ => None,
-                };
-                if let Some(base) = binary {
-                    self.scopes[body_scope].implied_bases.push(lib_qn(base));
+        ) {
+            if let UsageDetail::Connector { ends } = &detail {
+                let binary = end_elems.len() == 2;
+                if binary && self.dialect == Dialect::Sysml {
+                    let base = match u.kind {
+                        UsageKind::Connection => Some("Connections::binaryConnections"),
+                        UsageKind::Interface => Some("Interfaces::binaryInterfaces"),
+                        _ => None,
+                    };
+                    if let Some(base) = base {
+                        self.scopes[body_scope].implied_bases.push(lib_qn(base));
+                    }
                 }
-            }
-            let UsageDetail::Connector { ends } = &detail else {
-                unreachable!()
-            };
-            for ((name, &end_elem), end) in [("source", &end_elems[0]), ("target", &end_elems[1])]
-                .into_iter()
-                .zip(ends)
-            {
-                let end_scope = self.push_scope(Some(scope));
-                self.scopes[end_scope].owner = Some(end_elem);
-                if let Some(qn) = flat_target_qn(&end.target) {
-                    self.scopes[end_scope].bases.push(qn);
+                for (i, (&end_elem, end)) in end_elems.iter().zip(ends).enumerate() {
+                    let end_scope = self.push_scope(Some(scope));
+                    if let Some(qn) = flat_target_qn(&end.target) {
+                        self.scopes[end_scope].bases.push(qn);
+                    }
+                    self.register(
+                        body_scope,
+                        &Identification {
+                            name: end.name.clone(),
+                            short_name: None,
+                        },
+                        end_elem,
+                        end_scope,
+                    );
+                    // The binary positional aliases remain a fallback after
+                    // declared names, including a declared source or target.
+                    if binary {
+                        self.scopes[body_scope].implied_ends.push((
+                            ["source", "target"][i],
+                            end_elem,
+                            end_scope,
+                        ));
+                    }
                 }
-                self.elem_scope.insert(end_elem, end_scope);
-                self.scopes[body_scope]
-                    .implied_ends
-                    .push((name, end_elem, end_scope));
             }
         }
 
         for (i, m) in body_members.into_iter().enumerate() {
             self.build_member(m, e, body_scope, i);
         }
+        // Flow's narrower library base applies only when it owns ends.
+        // Keep lookup heritage aligned with the materialized requirements.
+        if crate::metaclass::conforms(self.elements[e].ty, "Flow")
+            && self.owned_member_elems(e, true).into_iter().any(|feature| {
+                self.elements[feature]
+                    .props
+                    .get("isEnd")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+            })
+        {
+            let base = if crate::metaclass::conforms(self.elements[e].ty, "FlowUsage") {
+                "Flows::flows"
+            } else {
+                "Transfers::flowTransfers"
+            };
+            self.scopes[body_scope].implied_bases.push(lib_qn(base));
+        }
         e
     }
 
@@ -3930,7 +4915,11 @@ impl Builder {
             self.set(ru, "declaredName", json!(name.value));
         }
         if let Some(mult) = &end.multiplicity {
-            self.emit_multiplicity(ru, mult, scope);
+            // The bound expression is owned inside the connector and can
+            // reference members declared in its body. End target lookup
+            // keeps the outer scope so it cannot capture the end itself.
+            let bound_scope = self.elem_scope.get(&parent).copied().unwrap_or(scope);
+            self.emit_multiplicity(ru, mult, bound_scope);
         }
         // Empty targets occur for implicit source ends of successions.
         let is_empty = end.target.is_unspelled();
@@ -4147,6 +5136,7 @@ impl Builder {
             UsageDetail::Metadata { about } => {
                 for (i, target) in about.iter().enumerate() {
                     let ann = self.new_relationship("Annotation", e, &format!("about{i}"));
+                    self.explicit_metadata_annotations.push(ann);
                     self.set(ann, "isImplied", json!(false));
                     self.set_ref(
                         ann,
@@ -4453,14 +5443,24 @@ impl Builder {
             } => {
                 let e = self.operator_expr(rel, seg, "if");
                 self.operand(e, cond, scope, 0);
-                self.operand(e, then_branch, scope, 1);
-                self.operand(e, else_branch, scope, 2);
+                self.conditional_operand(e, then_branch, scope, 1);
+                self.conditional_operand(e, else_branch, scope, 2);
                 e
             }
             ExprKind::Binary { op, lhs, rhs } => {
                 let e = self.operator_expr(rel, seg, binary_op_str(*op));
                 self.operand(e, lhs, scope, 0);
-                self.operand(e, rhs, scope, 1);
+                if matches!(
+                    op,
+                    BinaryOp::NullCoalescing
+                        | BinaryOp::Implies
+                        | BinaryOp::CondOr
+                        | BinaryOp::CondAnd
+                ) {
+                    self.conditional_operand(e, rhs, scope, 1);
+                } else {
+                    self.operand(e, rhs, scope, 1);
+                }
                 e
             }
             ExprKind::Unary { op, operand } => {
@@ -4767,8 +5767,18 @@ impl Builder {
                 let m = self.new_relationship("Membership", e, "type");
                 self.set(m, "isImplied", json!(false));
                 self.set_ref(m, "memberElement", scope, ty);
+                let argument_owner = if self.graph_format == crate::model::GraphFormat::CanonicalV3
+                {
+                    let member = self.new_relationship("ReturnParameterMembership", e, "result");
+                    self.set(member, "isImplied", json!(false));
+                    let result = self.new_owned_element("Feature", member, "result");
+                    self.set(result, "direction", json!("out"));
+                    result
+                } else {
+                    e
+                };
                 for (i, a) in args.iter().enumerate() {
-                    self.argument(e, a, scope, i, ty);
+                    self.argument(argument_owner, a, scope, i, ty);
                 }
                 e
             }
@@ -4782,7 +5792,6 @@ impl Builder {
                 }
                 e
             }
-            ExprKind::BodyTerminator => self.new_owned_element("Expression", rel, seg),
             ExprKind::Sequence(items) => {
                 // Comma sequences are right-nested OperatorExpressions
                 // (operator ",").
@@ -4831,6 +5840,24 @@ impl Builder {
         self.param_wrapped_expr(m, operand, scope, true);
     }
 
+    fn conditional_operand(&mut self, parent: usize, expr: &Expr, scope: usize, i: usize) {
+        if self.graph_format == crate::model::GraphFormat::LegacyV2 {
+            self.operand(parent, expr, scope, i);
+            return;
+        }
+        let m = self.new_relationship("ParameterMembership", parent, &format!("operand{i}"));
+        self.set(m, "isImplied", json!(false));
+        self.set(m, "visibility", json!("private"));
+        let f = self.new_owned_element("Feature", m, "param");
+        self.set(f, "direction", json!("in"));
+        let fv = self.new_relationship("FeatureValue", f, "value");
+        self.set(fv, "isImplied", json!(false));
+        let reference = self.new_owned_element("FeatureReferenceExpression", fv, "expr");
+        let member = self.new_relationship("FeatureMembership", reference, "expression");
+        self.set(member, "isImplied", json!(false));
+        self.build_expr(expr, member, scope, "expr");
+    }
+
     /// A positional argument expression (same shape/segments as
     /// [`Self::argument`] without a name).
     fn arg_expr(&mut self, parent: usize, expr: &Expr, scope: usize, i: usize) {
@@ -4858,6 +5885,13 @@ impl Builder {
                 TargetRef::Chain(links) if !links.is_empty() => Some(links.clone()),
                 TargetRef::Chain(_) => None,
             };
+            // The stored relationship already identifies this specialization.
+            // Record its callee-context pending outcome in the same identity
+            // index as declaration-written redefinitions; never rediscover its
+            // bare parameter name in the lexical scope later.
+            let spec_idx = self.spec_targets.len();
+            self.spec_targets
+                .push((f, "Redefinition", scope, name.clone()));
             self.pending.push(PendingRef {
                 elem: rd,
                 key: "redefinedFeature".to_string(),
@@ -4865,7 +5899,7 @@ impl Builder {
                 qn: name.clone(),
                 exclude: None,
                 declared_only: false,
-                spec_idx: None,
+                spec_idx: Some(spec_idx),
                 chain,
             });
             let fv = self.new_relationship("FeatureValue", f, "value");
@@ -4879,10 +5913,235 @@ impl Builder {
     // ---- name resolution ----
 
     fn resolve_pending(&mut self) {
+        self.recorded_lookup_ready = false;
+        self.recorded_lookup_graph = None;
+        self.recorded_lookup_candidate = recorded_lookup::Graph::needed(self);
+        if !self.recorded_lookup_candidate && self.explicit_metadata_annotations.is_empty() {
+            self.seed = None;
+            self.resolve_pending_pass();
+            return;
+        }
+        let pending = self.pending.clone();
+        let side = SideState::capture(self);
+        // The bootstrap pass consumes the recorded library outcomes; keep a
+        // recorded fixed point for replaying the library again below.
+        let library_replay: Option<LibraryReplay> = self
+            .lib_hints
+            .as_ref()
+            .zip(self.replay_completions.as_ref())
+            .filter(|_| self.lib_hints_fixed_point)
+            .map(|(hints, completions)| (hints.as_slice().to_vec(), completions.clone()));
+        // Kept outcomes stand in for the bootstrap pass: the loop starts
+        // against the graph of theirs, confirms them in one pass when the
+        // units resolve as they did, and starts over cold when it does not
+        // settle (see `settled`). A build replaying a library recording
+        // resolves cold: the replay belongs to the bootstrap pass.
+        if let Some(seed) = self.seed.take().filter(|_| self.lib_hints.is_none()) {
+            let cold = recorded_lookup::Checkpoint::capture(self, &pending);
+            self.apply_seed(&pending, &seed);
+            self.refresh_metadata_associations();
+            self.recorded_lookup_ready = self.recorded_lookup_candidate;
+            let graph = recorded_lookup::Graph::build(self);
+            self.note_root_imports_absent(&graph);
+            let seeded = recorded_lookup::Checkpoint::capture(self, &pending);
+            let previous = self.pass_outcomes(&pending);
+            let passes = settled::seeded_passes();
+            if self.resolve_pending_redo(
+                &pending, &side, &seeded, graph, previous, None, false, passes,
+            ) {
+                return;
+            }
+            settled::note_seed_abandoned();
+            cold.restore(self);
+            self.pending = pending.clone();
+            self.recorded_lookup_ready = false;
+            self.recorded_lookup_graph = None;
+        }
+        self.resolve_pending_pass();
+        let library_replayed = self.lib_replayed_all;
+        let metadata_changed = self.refresh_metadata_associations();
+        if self.recorded_lookup_incomplete {
+            if !self.explicit_metadata_annotations.is_empty() {
+                self.discard_unstable_metadata_associations();
+            }
+            return;
+        }
+        self.recorded_lookup_ready = self.recorded_lookup_candidate;
+        let mut graph = recorded_lookup::Graph::build(self);
+        self.note_root_imports_absent(&graph);
+        if pending.is_empty() || (!graph.has_replay_context() && !metadata_changed) {
+            self.recorded_lookup_graph = Some(graph);
+            return;
+        }
+        // Each pass reads one complete snapshot. Never feed partially updated
+        // endpoints back into inherited selection in the same pass.
+        let bootstrap = recorded_lookup::Checkpoint::capture(self, &pending);
+        let previous = self.pass_outcomes(&pending);
+        if self.resolve_pending_redo(
+            &pending,
+            &side,
+            &bootstrap,
+            graph,
+            previous,
+            library_replay.as_ref(),
+            library_replayed,
+            REDO_PASSES,
+        ) {
+            return;
+        }
+        // Selection is non-monotone: circular references can oscillate.
+        // Restore all bootstrap outputs together, never the last partial pass.
+        bootstrap.restore(self);
+        if !self.explicit_metadata_annotations.is_empty() {
+            self.discard_unstable_metadata_associations();
+        }
+        self.recorded_lookup_ready = false;
+        self.recorded_lookup_graph = None;
+        self.recorded_lookup_incomplete = true;
+    }
+
+    /// A pass's outcomes for `pending`: the value of each reference and
+    /// the specialization outcomes.
+    fn pass_outcomes(&self, pending: &[PendingRef]) -> PassOutcomes {
+        let values = pending
+            .iter()
+            .map(|p| {
+                let key = p.key.split_once('#').map_or(p.key.as_str(), |(key, _)| key);
+                self.elements[p.elem].props.get(key).cloned()
+            })
+            .collect();
+        (values, self.spec_resolved.iter().copied().collect())
+    }
+
+    /// The redo passes, each against the lookup graph of the previous
+    /// pass's outcomes (`graph`, built from `previous`), from the state
+    /// `checkpoint` holds, until a pass changes no outcome: the graph it
+    /// read is settled and kept, and the outcomes recorded. `false` when
+    /// `passes` ran out, the builder holding the last pass's state.
+    #[allow(clippy::too_many_arguments)]
+    fn resolve_pending_redo(
+        &mut self,
+        pending: &[PendingRef],
+        side: &SideState,
+        checkpoint: &recorded_lookup::Checkpoint,
+        mut graph: recorded_lookup::Graph,
+        mut previous: PassOutcomes,
+        library_replay: Option<&LibraryReplay>,
+        library_replayed: bool,
+        passes: usize,
+    ) -> bool {
+        for _ in 0..passes {
+            let metadata = self.metadata_snapshot();
+            checkpoint.restore(self);
+            self.restore_metadata_snapshot(&metadata);
+            self.recorded_lookup_graph = Some(graph);
+            self.recorded_lookup_ready = self.recorded_lookup_candidate;
+            side.restore(self);
+            self.pending = pending.to_vec();
+            // A library the bootstrap took entirely from its recorded fixed
+            // point stays there while user units cannot change its outcomes:
+            // replay it again rather than re-resolve every library reference.
+            (self.lib_hints, self.replay_completions) = match library_replay {
+                Some((hints, completions))
+                    if library_replayed && self.library_outcomes_are_own() =>
+                {
+                    self.lib_replay_targets_only = true;
+                    (Some(hints.clone().into_iter()), Some(completions.clone()))
+                }
+                _ => (None, None),
+            };
+            for p in pending {
+                if let Some((key, _)) = p.key.split_once('#') {
+                    self.elements[p.elem].props.insert(key, json!([]));
+                }
+            }
+            self.resolve_pending_pass();
+            // A recorded-only selection can avoid lexical walks that proved
+            // implicit/structural roots absent during bootstrap. Retain those
+            // cache invalidation dependencies even when the final target hit.
+            if let (Some(before), Some(after)) = (&checkpoint.lib_record, &mut self.lib_record) {
+                for ((_, prior_misses), (_, misses)) in before.iter().zip(after) {
+                    for name in prior_misses {
+                        if !misses.contains(name) {
+                            misses.push(name.clone());
+                        }
+                    }
+                }
+            }
+            let current = self.pass_outcomes(pending);
+            // A pass that changed no outcome leaves the rows as the previous
+            // pass left them, so the associations it would recompute and the
+            // graph it would build are the ones it read: settle that graph
+            // instead of building it again.
+            if current == previous {
+                let mut graph = self
+                    .recorded_lookup_graph
+                    .take()
+                    .expect("a redo pass reads the graph the previous pass built");
+                graph.settle(self);
+                self.note_root_imports_absent(&graph);
+                self.recorded_lookup_graph = Some(graph);
+                self.record_settled(pending);
+                return true;
+            }
+            self.refresh_metadata_associations();
+            graph = recorded_lookup::Graph::build(self);
+            self.note_root_imports_absent(&graph);
+            previous = current;
+        }
+        false
+    }
+
+    /// A graph that takes implied roots as absent holds only while the root
+    /// namespace imports nothing: a root import completes that miss, so a
+    /// model adding one resolves jointly rather than on this library.
+    fn note_root_imports_absent(&mut self, graph: &recorded_lookup::Graph) {
+        if graph.takes_implied_roots_absent() && !self.root_misses.contains(ROOT_IMPORTS) {
+            self.root_misses.insert(ROOT_IMPORTS.to_owned());
+        }
+    }
+
+    /// Whether library resolution sees what it saw when its outcomes were
+    /// recorded, root names aside (the recorded misses cover those): the
+    /// library annotates nothing by association itself, no annotation
+    /// reaches the metadata of a library element, and no external name
+    /// stands in for an implied library root.
+    fn library_outcomes_are_own(&self) -> bool {
+        let boundary = self.lib_boundary;
+        self.external_implied_names.is_empty()
+            && self
+                .explicit_metadata_annotations
+                .iter()
+                .all(|&annotation| annotation >= boundary)
+            && self.metadata_about.keys().all(|&target| target >= boundary)
+    }
+
+    fn resolve_pending_pass(&mut self) {
+        note_pass();
         let pending = std::mem::take(&mut self.pending);
+        if self.id_spelled_targets.is_empty() {
+            self.id_binding_pending.clear();
+        }
+        if self.id_spelled_targets.is_empty()
+            && pending.iter().any(|p| {
+                p.elem >= self.lib_boundary
+                    && p.qn
+                        .segments
+                        .iter()
+                        .any(|s| s.value.len() >= 32 && Uuid::parse_str(&s.value).is_ok())
+            })
+        {
+            self.id_binding_pending = pending
+                .iter()
+                .filter(|p| p.elem >= self.lib_boundary)
+                .cloned()
+                .collect();
+        }
         let mut hints = self.lib_hints.take();
         let completions = self.replay_completions.take();
         let mut replay_active = hints.is_some() && completions.is_some();
+        let mut replayed_all = replay_active;
+        let targets_only = std::mem::take(&mut self.lib_replay_targets_only);
         let completions = completions.unwrap_or_default();
         let recording = self.lib_record.is_some();
         let mut lib_pos = 0usize;
@@ -4902,7 +6161,9 @@ impl Builder {
                         // now supply is resolved afresh; the entry is still
                         // consumed to keep the positional alignment.
                         Some((outcome, misses)) => {
-                            (!misses.iter().any(|m| completions.contains(m))).then_some(outcome)
+                            (!misses.iter().any(|m| completions.contains(m))
+                                && (outcome.is_some() || !targets_only))
+                                .then_some((outcome, misses))
                         }
                         None => {
                             replay_active = false;
@@ -4912,6 +6173,7 @@ impl Builder {
                 } else {
                     None
                 };
+                replayed_all &= !is_lib_ref || hint.is_some();
                 let record_pos = if is_lib_ref && recording {
                     let pos = lib_pos;
                     lib_pos += 1;
@@ -4955,7 +6217,7 @@ impl Builder {
             let is_lib_ref = self.lib_boundary > 0 && elem < self.lib_boundary;
             if is_lib_ref {
                 match lib_hint {
-                    Some(Some(id)) => {
+                    Some((Some(id), misses)) => {
                         let ids = lib_ids.get_or_insert_with(|| {
                             self.elements
                                 .iter()
@@ -4973,18 +6235,21 @@ impl Builder {
                             // resolution through inherited-merge shadowing
                             // would differ across cache states.
                             if let Some(si) = spec_idx {
-                                if self.spec_resolved.len() <= si {
-                                    self.spec_resolved.resize(si + 1, None);
-                                }
-                                self.spec_resolved[si] = Some(target);
+                                self.record_spec_outcome(si, Some(target), &misses);
                             }
+                            self.record_ref_misses(elem, &key, &misses);
                             self.set_pending_value(elem, &key, id_ref(id));
                             continue;
                         }
                         // Unknown target — cache/content skew; fall through
                         // to a full resolve of this entry.
+                        replayed_all = false;
                     }
-                    Some(None) => {
+                    Some((None, misses)) => {
+                        if let Some(si) = spec_idx {
+                            self.record_spec_outcome(si, None, &misses);
+                        }
+                        self.record_ref_misses(elem, &key, &misses);
                         self.unresolved.push((elem, qn.clone()));
                         let v = json!({ "@ref": qn.to_ref_string() });
                         self.set_pending_value(elem, &key, v);
@@ -4993,8 +6258,16 @@ impl Builder {
                     None => {}
                 }
             }
+            let saved_identity_origin = self.set_identity_origin(elem);
             let (saved, saved_mode) = (self.exclude, self.declared_only);
             self.query_imports.clear();
+            let saved_header = self.redefinition_lookup_owner;
+            let saved_base = self.redefinition_lookup_base.take();
+            self.recorded_lookup_suppressed = false;
+            self.redefinition_lookup_owner = (key == "redefinedFeature"
+                && crate::metaclass::conforms(self.elements[elem].ty, "Redefinition"))
+            .then(|| exclude.and_then(|feature| self.owner_elem(feature)))
+            .flatten();
             self.exclude = exclude;
             self.current_misses.clear();
             // Contextual chain-step resolution first (effective names are
@@ -5002,6 +6275,7 @@ impl Builder {
             // lexical mode as fallback.
             self.declared_only = false;
             let mut was_ambiguous = false;
+            let mut imported_membership = None;
             let mut resolved = if key == "importedNamespace" {
                 // A namespace import's own target takes the outcome the
                 // resolution machinery computed (entry self-excluded); a
@@ -5042,8 +6316,17 @@ impl Builder {
             let chained = chain.as_deref().is_some_and(|c| !c.is_empty());
             if resolved.is_none() && key != "importedNamespace" {
                 self.declared_only = declared_only;
-                let lexical = match self.resolve_result(scope, &qn, 0, false) {
-                    LookupResult::Found(found, _) => Some(found),
+                let import_all = key == "importedMembership"
+                    && self.elements[elem]
+                        .props
+                        .get("isImportAll")
+                        .and_then(|v| v.as_bool())
+                        == Some(true);
+                let lexical = match self.resolve_result(scope, &qn, 0, import_all) {
+                    LookupResult::Found(found, _, membership) => {
+                        imported_membership = membership;
+                        Some(found)
+                    }
                     LookupResult::Ambiguous => {
                         was_ambiguous = true;
                         None
@@ -5065,6 +6348,7 @@ impl Builder {
                     None
                 };
             }
+            let semantically_suppressed = self.recorded_lookup_suppressed;
             // Record the reference site while `resolved` is still the
             // element the name *denotes* (before the serialization
             // substitutions below). Library-internal sites are skipped:
@@ -5074,7 +6358,10 @@ impl Builder {
                 if let Some(target) = resolved {
                     let kind = key.split_once('#').map_or(key.as_str(), |(b, _)| b);
                     let unit = self.unit_of_elem(elem);
-                    let plain = chain.is_none() && !declared_only && key != "importedNamespace";
+                    let plain = chain.is_none()
+                        && !declared_only
+                        && key != "importedNamespace"
+                        && self.id_spelled_target(scope, &qn).is_none();
                     // Chain-root provenance: re-resolve the spine's first
                     // link under the spine's own rules (contextual mode,
                     // caller's exclusion) — `resolve_chain_member` resolved
@@ -5120,20 +6407,24 @@ impl Builder {
                 // its own site even when a later segment makes the whole
                 // reference unresolved or ambiguous.
                 let unit = self.unit_of_elem(elem);
+                // Prefixes name namespaces/types, not the Feature expected
+                // by the complete header. Preserve its selected base context.
+                let qualifier_scope = self.redefinition_lookup_base.unwrap_or(scope);
+                let header = self.redefinition_lookup_owner.take();
                 for k in 1..qn.segments.len() {
                     let prefix = QualifiedName {
                         is_global: qn.is_global,
                         segments: qn.segments[..k].to_vec(),
                         span: qn.span,
                     };
-                    if let Some(t) = self.resolve(scope, &prefix, 0) {
+                    if let Some(t) = self.resolve(qualifier_scope, &prefix, 0) {
                         self.ref_sites.push(RefSite {
                             unit,
                             span: qn.span,
                             name_span: qn.segments[k - 1].span,
                             target: ElementRef(t),
                             kind: "qualifier".to_string(),
-                            scope: ScopeRef(scope),
+                            scope: ScopeRef(qualifier_scope),
                             exclude: None,
                             plain: false,
                             owner: ElementRef(elem),
@@ -5142,25 +6433,32 @@ impl Builder {
                         });
                     }
                 }
+                self.redefinition_lookup_owner = header;
             }
             // `importedMembership` is Membership-typed (KerML 7.2.5.2): a
             // membership import references the resolved member's owning
-            // Membership, not the member element itself. (An import through
-            // an alias canonicalizes to the target's own membership.)
+            // Membership, retaining the named alias Membership when present.
             if key == "importedMembership" {
-                resolved = resolved.map(|t| self.elements[t].owning_relationship.unwrap_or(t));
+                resolved = resolved.map(|t| {
+                    imported_membership
+                        .or(self.elements[t].owning_relationship)
+                        .unwrap_or(t)
+                });
             }
             // A `~P` typing references P's implicit ConjugatedPortDefinition.
             if self.elements[elem].ty == "ConjugatedPortTyping" && key == "type" {
                 resolved = resolved.map(|t| self.conjugated_defs.get(&t).copied().unwrap_or(t));
             }
+            if is_lib_ref && resolved.is_some_and(|target| target >= self.lib_boundary) {
+                self.library_refs_to_users = true;
+            }
             let value = match resolved {
                 Some(target) => id_ref(self.elements[target].id),
                 None => {
                     if was_ambiguous {
                         self.ambiguous.push((elem, qn.clone()));
                     } else {
-                        if !is_lib_ref {
+                        if !is_lib_ref && !semantically_suppressed {
                             if let Some(site) =
                                 self.blocked_site(scope, chain.as_deref(), &qn, elem)
                             {
@@ -5169,16 +6467,19 @@ impl Builder {
                         }
                         self.unresolved.push((elem, qn.clone()));
                     }
-                    json!({ "@ref": qn.to_ref_string() })
+                    crate::properties::Atom::from(json!({ "@ref": qn.to_ref_string() }))
                 }
             };
+            self.redefinition_lookup_owner = saved_header;
+            self.redefinition_lookup_base = saved_base;
             (self.exclude, self.declared_only) = (saved, saved_mode);
+            self.identity_origin_unit = saved_identity_origin;
+            let misses = std::mem::take(&mut self.current_misses);
             if let Some(si) = spec_idx {
-                if self.spec_resolved.len() <= si {
-                    self.spec_resolved.resize(si + 1, None);
-                }
-                self.spec_resolved[si] = resolved;
+                self.record_spec_outcome(si, resolved, &misses);
             }
+            self.record_ref_misses(elem, &key, &misses);
+            self.current_misses = misses;
             if let Some(pos) = record_pos {
                 self.lib_record.as_mut().unwrap()[pos] = (
                     resolved.map(|t| self.elements[t].id),
@@ -5187,6 +6488,7 @@ impl Builder {
             }
             self.set_pending_value(elem, &key, value);
         }
+        self.lib_replayed_all = replayed_all;
         self.ref_sites.sort_by_key(|site| {
             (
                 site.unit,
@@ -5198,9 +6500,46 @@ impl Builder {
         });
     }
 
+    /// Record a specialization reference's outcome with the root misses
+    /// behind it, for resolutions that read it later.
+    fn record_spec_outcome(&mut self, si: usize, target: Option<usize>, misses: &[String]) {
+        if self.spec_resolved.len() <= si {
+            self.spec_resolved.resize(si + 1, None);
+        }
+        self.spec_resolved[si] = target;
+        // Only a build that records its library outcomes reads the misses.
+        if self.lib_record.is_none() {
+            return;
+        }
+        self.spec_misses.set(si, misses);
+    }
+
+    /// Record the root misses behind a relationship's single-valued outcome.
+    fn record_ref_misses(&mut self, elem: usize, key: &str, misses: &[String]) {
+        if key.contains('#') || self.lib_record.is_none() {
+            return;
+        }
+        self.ref_misses.set(elem, misses);
+    }
+
+    /// A resolution read the recorded outcomes of these specialization
+    /// entries: it depends on the root names their references missed.
+    fn note_spec_misses(&mut self, entries: impl IntoIterator<Item = usize>) {
+        for i in entries {
+            if let Some(misses) = self.spec_misses.get(i) {
+                note_misses(&mut self.current_misses, misses.iter());
+            }
+        }
+    }
+
     /// Store a resolved (or `@ref`) value under a pending ref's key —
     /// `key#n` spellings append to the `key` array property.
-    fn set_pending_value(&mut self, elem: usize, key: &str, value: Value) {
+    fn set_pending_value(
+        &mut self,
+        elem: usize,
+        key: &str,
+        value: impl Into<crate::properties::Atom>,
+    ) {
         if let Some((base, _)) = key.split_once('#') {
             self.elements[elem].props.append(base, value);
         } else {
@@ -5212,18 +6551,58 @@ impl Builder {
     pub(crate) fn element_index_of_uuid(&mut self, id: Uuid) -> Option<usize> {
         let stale = self.id_index.is_none() || self.id_index_built_for != self.elements.len();
         if stale {
-            self.id_index_built_for = self.elements.len();
-            self.id_index = Some(
-                self.elements
-                    .iter()
-                    .enumerate()
-                    .map(|(i, el)| (el.id, i))
-                    .collect(),
-            );
+            let n = self.elements.len();
+            self.id_index_built_for = n;
+            // The frozen rows through the table their freeze kept, copied,
+            // and the rows after them tabled here; every row otherwise.
+            let (mut index, start) = match self.prefix_ids.as_deref() {
+                // (an identity override writes a frozen row's id: then every
+                // row is tabled)
+                Some(frozen)
+                    if frozen.len() == self.lib_boundary
+                        && self.lib_boundary <= n
+                        && self.elements.base_untouched() =>
+                {
+                    (frozen.clone(), self.lib_boundary)
+                }
+                _ => (
+                    crate::layered::IdMap::with_capacity_and_hasher(n, Default::default()),
+                    0,
+                ),
+            };
+            note_id_index_tabled(n - start);
+            for (i, el) in self.elements.iter().enumerate().skip(start) {
+                index.insert(el.id, i);
+            }
+            self.id_index = Some(Arc::new(index));
         }
         self.id_index.as_ref().unwrap().get(&id).copied()
     }
 
+    /// The identity tables of a build on this builder's frozen rows, for a
+    /// test to read a library name through.
+    #[cfg(test)]
+    fn identity_tables_for_test(&self) -> IdentityTables {
+        IdentityTables {
+            start: self.lib_boundary,
+            by_id: crate::layered::IdMap::default(),
+            names: Vec::new(),
+            frozen: self.prefix_ids.clone(),
+            table_names: None,
+        }
+    }
+
+    /// The library name tables by id, the first entry of an id winning.
+    fn library_table_names(&self) -> HashMap<Uuid, String> {
+        let mut tables = HashMap::new();
+        for (id, segments) in self.lib_qnames.iter().chain(self.lib_mem_qnames.iter()) {
+            if let Some(last) = segments.last() {
+                tables.entry(*id).or_insert_with(|| last.clone());
+            }
+        }
+        tables
+    }
+
     /// The multiplicity `e` declares of its own — the scope it was
     /// written in and its clause — through the owner index. `None` when
     /// `e` declares none; inherited ones are not walked.
@@ -5232,6 +6611,11 @@ impl Builder {
         if self.mult_index.as_ref().is_none_or(|(n, _)| *n != rows) {
             let mut map = HashMap::with_capacity(rows);
             for (i, (owner, _, _)) in self.multiplicities.iter().enumerate() {
+                // A named/body range's numeric domain is not a declaration of
+                // that Multiplicity Feature's own cardinality.
+                if crate::metaclass::conforms(self.elements[*owner].ty, "Multiplicity") {
+                    continue;
+                }
                 // First row wins, as the scan this replaces did.
                 map.entry(*owner).or_insert(i);
             }
@@ -5276,6 +6660,10 @@ impl Builder {
 
     /// Original unit index of the unit that built element `elem`.
     pub(crate) fn unit_of_elem(&self, elem: usize) -> usize {
+        let elem = self
+            .semantic_ownership
+            .as_ref()
+            .map_or(elem, |view| view.source_anchor(elem));
         match self.unit_starts.binary_search_by_key(&elem, |&(e, _)| e) {
             Ok(i) => self.unit_starts[i].1,
             Err(0) => 0,
@@ -5296,9 +6684,18 @@ impl Builder {
     fn check_aliases(&mut self) -> Vec<(usize, QualifiedName)> {
         let mut out = Vec::new();
         for s in 0..self.scopes.len() {
-            for (_, qn, _) in self.scopes[s].aliases.clone() {
-                if self.resolve(s, &qn, 0).is_none() {
-                    out.push((self.unit_of_scope(s), qn));
+            for (i, (_, qn, _)) in self.scopes[s].aliases.clone().into_iter().enumerate() {
+                let origin = self.identity_origin_unit;
+                let unit = self
+                    .alias_origins
+                    .get(&(s, i))
+                    .copied()
+                    .unwrap_or_else(|| self.unit_of_scope(s));
+                self.identity_origin_unit = Some(unit);
+                let missing = self.resolve(s, &qn, 0).is_none();
+                self.identity_origin_unit = origin;
+                if missing {
+                    out.push((unit, qn));
                 }
             }
         }
@@ -5330,8 +6727,8 @@ impl Builder {
         collisions.sort_by(|a, b| a.0.cmp(&b.0));
         for (name, bindings) in collisions {
             let (library_elem, resolves_to_library) =
-                match self.binding_result(Some(&bindings), LookupAccess::All, None) {
-                    LookupResult::Found(elem, _) if elem < boundary => (elem, true),
+                match self.binding_result(Some(&bindings), LookupAccess::All, None, false) {
+                    LookupResult::Found(elem, _, _) if elem < boundary => (elem, true),
                     LookupResult::Found(..) => continue,
                     LookupResult::Ambiguous | LookupResult::Missing => {
                         let Some(first) = bindings.iter().find(|b| b.elem < boundary) else {
@@ -5369,7 +6766,10 @@ impl Builder {
         for s in 0..self.scopes.len() {
             let imports = self.scopes[s].imports.clone();
             for entry in imports {
-                if let Some(elem) = self.resolve(s, &entry.target, 0) {
+                let origin = self.set_identity_origin(entry.relationship);
+                let resolved = self.resolve(s, &entry.target, 0);
+                self.identity_origin_unit = origin;
+                if let Some(elem) = resolved {
                     if let Some(&target) = self.elem_scope.get(&elem) {
                         if self.imports_reach(target, s) {
                             out.push((self.unit_of_scope(s), entry.target));
@@ -5393,7 +6793,7 @@ impl Builder {
             if !seen.insert(s) {
                 continue;
             }
-            for imported in self.import_scopes(s) {
+            for imported in self.import_scopes(s).iter() {
                 stack.push(imported.scope);
             }
         }
@@ -5531,7 +6931,7 @@ impl Builder {
         let saved = self.exclude;
         self.exclude = None;
         let out = match self.resolve_rest_result(scope, elem, sub, &segments, 0, false) {
-            LookupResult::Found(found, _) => Some(found),
+            LookupResult::Found(found, _, _) => Some(found),
             LookupResult::Missing | LookupResult::Ambiguous => None,
         };
         self.exclude = saved;
@@ -5549,11 +6949,40 @@ impl Builder {
         depth: usize,
     ) -> Option<usize> {
         match self.resolve_result(scope, qn, depth, false) {
-            LookupResult::Found(elem, _) => Some(elem),
+            LookupResult::Found(elem, _, _) => Some(elem),
             LookupResult::Missing | LookupResult::Ambiguous => None,
         }
     }
 
+    pub(crate) fn intrinsic_function_name(
+        &mut self,
+        scope: usize,
+        qn: &QualifiedName,
+    ) -> Option<String> {
+        match self.resolve_result(scope, qn, 0, false) {
+            LookupResult::Found(elem, _, _) if elem < self.lib_boundary => {
+                crate::eval::library_intrinsic_for_id(self.elem_id(elem)).map(str::to_owned)
+            }
+            LookupResult::Missing
+                if !qn.is_global
+                    && qn.segments.len() == 1
+                    && crate::eval::intrinsic_spelling(&qn.segments[0].value) =>
+            {
+                // A visibility failure is not an absent convenience name.
+                // Probe with widened access without recording import usage.
+                let probing = self.probing;
+                self.probing = true;
+                let absent = matches!(
+                    self.resolve_result(scope, qn, 0, false),
+                    LookupResult::Missing
+                );
+                self.probing = probing;
+                absent.then(|| qn.segments[0].value.clone())
+            }
+            _ => None,
+        }
+    }
+
     /// Tooling lookup by absolute model path. Unlike source-language
     /// resolution, model introspection is allowed to address private and
     /// protected members; ambiguity is still an error.
@@ -5566,8 +6995,12 @@ impl Builder {
         let stamp = self.next_stamp();
         while let Some(s) = current {
             match self.lookup_at(s, &first, 0, stamp, LookupAccess::All) {
-                LookupResult::Found(elem, sub_scope) => {
-                    return self.resolve_rest_unrestricted(elem, sub_scope, &qn.segments[1..], 0);
+                hit @ LookupResult::Found(elem, sub_scope, _) => {
+                    return if qn.segments.len() == 1 {
+                        hit
+                    } else {
+                        self.resolve_rest_unrestricted(elem, sub_scope, &qn.segments[1..], 0)
+                    };
                 }
                 LookupResult::Ambiguous => return LookupResult::Ambiguous,
                 LookupResult::Missing => {}
@@ -5585,20 +7018,53 @@ impl Builder {
         depth: usize,
     ) -> LookupResult {
         if rest.is_empty() {
-            return LookupResult::Found(elem, scope);
+            return LookupResult::Found(elem, scope, None);
         }
         let Some(scope) = scope else {
             return LookupResult::Missing;
         };
         let stamp = self.next_stamp();
         match self.lookup_at(scope, &rest[0].value, depth + 1, stamp, LookupAccess::All) {
-            LookupResult::Found(next, next_scope) => {
-                self.resolve_rest_unrestricted(next, next_scope, &rest[1..], depth + 1)
+            hit @ LookupResult::Found(next, next_scope, _) => {
+                if rest.len() == 1 {
+                    hit
+                } else {
+                    self.resolve_rest_unrestricted(next, next_scope, &rest[1..], depth + 1)
+                }
             }
             other => other,
         }
     }
 
+    /// Switch source provenance for expression and runtime-parameter queries.
+    /// Return the previous origin for the caller to restore on every exit.
+    #[inline]
+    pub(crate) fn set_identity_origin(&mut self, element: usize) -> Option<usize> {
+        let previous = self.identity_origin_unit;
+        self.identity_origin_unit = Some(self.unit_of_elem(element));
+        previous
+    }
+
+    /// An identity carried through textual lifting is tied to its source
+    /// site, not to its spelling: a different site can legitimately use
+    /// that UUID as an ordinary declared name.
+    #[inline]
+    fn id_spelled_target(&self, _scope: usize, qn: &QualifiedName) -> Option<Uuid> {
+        self.id_spelled_name(qn.segments.first()?)
+    }
+
+    #[inline]
+    fn id_spelled_name(&self, first: &Name) -> Option<Uuid> {
+        if self.id_spelled_targets.is_empty() {
+            return None;
+        }
+        let (spelling, target) = self
+            .id_spelled_targets
+            .get(&(self.identity_origin_unit?, first.span.start, first.span.end))
+            .copied()?;
+        (Uuid::parse_str(&first.value).ok() == Some(spelling)).then_some(target)
+    }
+
     /// Resolution with ambiguity retained. `allow_last_non_public` is used
     /// only by `import all` membership imports: intermediate qualifiers
     /// still obey normal visibility, while the imported membership itself
@@ -5613,13 +7079,83 @@ impl Builder {
         if depth > MAX_RESOLUTION_DEPTH || qn.segments.is_empty() {
             return LookupResult::Missing;
         }
+        // Redefinition headers resolve from each direct general Type, in
+        // declaration order, without admitting the declaring Type's members.
+        // Starting contexts use frozen explicit endpoints even when lookup
+        // inside those contexts still needs the contextual resolver.
+        if self.recorded_lookup_ready
+            && !self.recorded_lookup_incomplete
+            && self.id_spelled_target(scope, qn).is_none()
+        {
+            if let Some(owner) = self.redefinition_lookup_owner {
+                if let Some(&owner_scope) = self.elem_scope.get(&owner) {
+                    if self.recorded_lookup_graph.is_none() {
+                        self.recorded_lookup_graph = Some(recorded_lookup::Graph::build(self));
+                    }
+                    let graph = self.recorded_lookup_graph.as_mut().unwrap();
+                    let complete = graph
+                        .direct_bases(owner_scope, &mut self.current_misses)
+                        .is_some();
+                    let bases = graph.header_bases(owner_scope, &mut self.current_misses);
+                    if let Some(bases) = bases {
+                        let saved = self.redefinition_lookup_owner.take();
+                        let mut result = LookupResult::Missing;
+                        for base in bases {
+                            let hit =
+                                self.resolve_result(base, qn, depth + 1, allow_last_non_public);
+                            match hit {
+                                LookupResult::Found(e, _, _)
+                                    if crate::metaclass::conforms(
+                                        self.elements[e].ty,
+                                        "Feature",
+                                    ) =>
+                                {
+                                    result = hit;
+                                    self.redefinition_lookup_base = Some(base);
+                                    break;
+                                }
+                                LookupResult::Ambiguous => result = LookupResult::Ambiguous,
+                                _ => {}
+                            }
+                        }
+                        self.redefinition_lookup_owner = saved;
+                        if complete || matches!(result, LookupResult::Found(..)) {
+                            return result;
+                        }
+                    }
+                }
+                // An unsupported header keeps the contextual fallback, but
+                // nested alias/base resolution must not restart this header.
+                let saved = self.redefinition_lookup_owner.take();
+                let result = self.resolve_result(scope, qn, depth, allow_last_non_public);
+                self.redefinition_lookup_owner = saved;
+                return result;
+            }
+        }
         let first = qn.segments[0].value.clone();
+        if let Some(id) = self.id_spelled_target(scope, qn) {
+            let Some(elem) = self.element_index_of_uuid(id) else {
+                return LookupResult::Missing;
+            };
+            let sub_scope = self.elem_scope.get(&elem).copied();
+            return self.resolve_rest_result(
+                scope,
+                elem,
+                sub_scope,
+                &qn.segments[1..],
+                depth,
+                allow_last_non_public,
+            );
+        }
         // `$::` roots resolution at the global namespace (scope 0).
         let mut current = Some(if qn.is_global { 0 } else { scope });
         let stamp = self.next_stamp();
         while let Some(s) = current {
             match self.lookup_at(s, &first, depth, stamp, LookupAccess::All) {
-                LookupResult::Found(elem, sub_scope) => {
+                hit @ LookupResult::Found(elem, sub_scope, _) => {
+                    if qn.segments.len() == 1 {
+                        return hit;
+                    }
                     return self.resolve_rest_result(
                         scope,
                         elem,
@@ -5668,17 +7204,32 @@ impl Builder {
         depth: usize,
         stamp: u64,
         access: LookupAccess,
+    ) -> LookupResult {
+        self.lookup_at_with_names(s, name, depth, stamp, access, false)
+    }
+
+    /// Semantic import lookup excludes compatibility locators before merging
+    /// candidates. Separate memo slots preserve replay lookup within the same
+    /// query (for example while an alias resolves its target).
+    fn lookup_at_with_names(
+        &mut self,
+        s: usize,
+        name: &str,
+        depth: usize,
+        stamp: u64,
+        access: LookupAccess,
+        semantic_names: bool,
     ) -> LookupResult {
         let hit = if depth > MAX_RESOLUTION_DEPTH {
             LookupResult::Missing
         } else {
-            let mode = access as usize;
+            let mode = access as usize + usize::from(semantic_names) * 3;
             if self.visit_stamp[s][mode] == stamp {
                 self.visit_result[s][mode].unwrap_or(LookupResult::Missing)
             } else {
                 self.visit_stamp[s][mode] = stamp;
                 self.visit_result[s][mode] = None;
-                let hit = self.lookup_body(s, name, depth, stamp, access);
+                let hit = self.lookup_body(s, name, depth, stamp, access, semantic_names);
                 self.visit_result[s][mode] = Some(hit);
                 hit
             }
@@ -5703,24 +7254,154 @@ impl Builder {
         }
     }
 
-    fn merge_lookup(&self, left: LookupResult, right: LookupResult) -> LookupResult {
-        match (left, right) {
-            (LookupResult::Ambiguous, _) | (_, LookupResult::Ambiguous) => LookupResult::Ambiguous,
-            (LookupResult::Missing, hit) | (hit, LookupResult::Missing) => hit,
-            (LookupResult::Found(a, ascope), LookupResult::Found(b, bscope)) if a == b => {
-                LookupResult::Found(a, ascope.or(bscope))
-            }
-            (LookupResult::Found(a, ascope), LookupResult::Found(b, _))
-                if !metaclasses_overlap(self.elements[a].ty, self.elements[b].ty) =>
-            {
-                // KerML Membership::isDistinguishableFrom: concrete sibling
-                // metaclasses with equal names do not make the namespace
-                // ambiguous. Context-sensitive selection is a later stage;
-                // retain the earlier candidate here for stable traversal.
-                LookupResult::Found(a, ascope)
-            }
-            (LookupResult::Found(..), LookupResult::Found(..)) => LookupResult::Ambiguous,
+    /// Set aside the lookup state of the query in progress before computing
+    /// a lookup-cache entry. The entry outlives the query, so it must not
+    /// depend on it: a probe's or a widened member's access, an excluded
+    /// element, a chain step's declared names only, a redefinition header,
+    /// a membership import or filter resolving its own target. Otherwise
+    /// whichever reference first reads the entry decides it for all later
+    /// ones — and a replayed build, which reads it from another reference,
+    /// would resolve differently from a cold one.
+    fn enter_fill_mode(&mut self) -> QueryMode {
+        let filters = self.filters_active.contains(&true).then(|| {
+            let idle = vec![false; self.filters_active.len()];
+            std::mem::replace(&mut self.filters_active, idle)
+        });
+        QueryMode {
+            probing: std::mem::replace(&mut self.probing, false),
+            widen: self.widen.take(),
+            exclude: self.exclude.take(),
+            declared_only: std::mem::replace(&mut self.declared_only, false),
+            header_owner: self.redefinition_lookup_owner.take(),
+            header_base: self.redefinition_lookup_base.take(),
+            member_imports: std::mem::take(&mut self.member_import_active),
+            filters,
+            suppressed: std::mem::replace(&mut self.recorded_lookup_suppressed, false),
+        }
+    }
+
+    /// Restore the query state [`Self::enter_fill_mode`] set aside.
+    fn leave_fill_mode(&mut self, query: QueryMode) {
+        self.probing = query.probing;
+        self.widen = query.widen;
+        self.exclude = query.exclude;
+        self.declared_only = query.declared_only;
+        self.redefinition_lookup_owner = query.header_owner;
+        self.redefinition_lookup_base = query.header_base;
+        self.member_import_active = query.member_imports;
+        if let Some(filters) = query.filters {
+            self.filters_active = filters;
+        }
+        self.recorded_lookup_suppressed = query.suppressed;
+    }
+
+    /// Start computing a lookup-cache entry: the misses noted from here to
+    /// [`Self::end_fill`] are the entry's own. The returned number marks
+    /// the entry as [`FillMisses::Filling`] meanwhile.
+    fn begin_fill(&mut self) -> usize {
+        let interrupted = std::mem::take(&mut self.current_misses);
+        self.fill_frames.push(interrupted);
+        self.fill_frames.len()
+    }
+
+    /// Finish the innermost fill: its misses are also the misses of the
+    /// resolution it interrupted, which read the entry it computed.
+    fn end_fill(&mut self) -> FillMisses {
+        let interrupted = self.fill_frames.pop().unwrap_or_default();
+        let noted = std::mem::replace(&mut self.current_misses, interrupted);
+        if noted.is_empty() {
+            return FillMisses::None;
+        }
+        note_misses(&mut self.current_misses, &noted);
+        FillMisses::Missed(noted.into())
+    }
+
+    fn set_base_misses(&mut self, s: usize, misses: FillMisses) {
+        if self.base_misses.len() <= s {
+            self.base_misses.resize(s + 1, FillMisses::None);
+        }
+        self.base_misses[s] = misses;
+    }
+
+    fn set_import_misses(&mut self, s: usize, misses: FillMisses) {
+        if self.import_misses.len() <= s {
+            self.import_misses.resize(s + 1, FillMisses::None);
         }
+        self.import_misses[s] = misses;
+    }
+
+    /// A read of a lookup-cache entry notes the misses behind it: all of
+    /// them once computed, and those noted so far while a fill that the
+    /// reader runs inside computes it.
+    #[inline]
+    fn note_fill_misses(
+        noted: &mut Vec<String>,
+        frames: &[Vec<String>],
+        misses: Option<&FillMisses>,
+    ) {
+        match misses {
+            None | Some(FillMisses::None) => {}
+            Some(FillMisses::Missed(names)) => note_misses(noted, names.iter()),
+            // The fill's own misses sit in the frame of the first fill it
+            // started; while it has none running they are `noted` itself.
+            Some(&FillMisses::Filling(fill)) => {
+                if let Some(own) = frames.get(fill) {
+                    note_misses(noted, own);
+                }
+            }
+        }
+    }
+
+    fn merge_lookup(&self, left: LookupResult, right: LookupResult) -> LookupResult {
+        match (left, right) {
+            (LookupResult::Ambiguous, _) | (_, LookupResult::Ambiguous) => LookupResult::Ambiguous,
+            (LookupResult::Missing, hit) | (hit, LookupResult::Missing) => hit,
+            (LookupResult::Found(a, ascope, am), LookupResult::Found(b, bscope, bm)) if a == b => {
+                // Two import paths to one Membership agree. Distinct
+                // aliases with this spelling remain indistinguishable even
+                // when they happen to denote the same member element.
+                let owning = self.elements[a].owning_relationship;
+                if am.or(owning) == bm.or(owning) {
+                    LookupResult::Found(a, ascope.or(bscope), am)
+                } else {
+                    LookupResult::Ambiguous
+                }
+            }
+            (LookupResult::Found(a, ascope, am), LookupResult::Found(b, _, _))
+                if !metaclasses_overlap(self.elements[a].ty, self.elements[b].ty) =>
+            {
+                // KerML Membership::isDistinguishableFrom: concrete sibling
+                // metaclasses with equal names do not make the namespace
+                // ambiguous. Context-sensitive selection is a later stage;
+                // retain the earlier candidate here for stable traversal.
+                LookupResult::Found(a, ascope, am)
+            }
+            (LookupResult::Found(..), LookupResult::Found(..)) => LookupResult::Ambiguous,
+        }
+    }
+
+    /// The features `e` redefines as lookup reads them: the recorded
+    /// written ones, those the positional plan materialized once the model
+    /// is semantically ready, and — before that, while references are
+    /// still being resolved — those its position pairs it with, read off
+    /// its owner's heritage (`positional_redefinition_targets`), so that a
+    /// usage's `out fuelEconomy` shadows the definition's it redefines by
+    /// position whenever a chain reaches both.
+    fn shadowing_redefinition_targets(
+        &mut self,
+        e: usize,
+        read: &mut Vec<usize>,
+        memo: &mut parameters::SlotMemo,
+    ) -> Vec<usize> {
+        let mut targets = self.recorded_redefinition_targets(e, read);
+        if let Some(owner) = self.owner_elem(e) {
+            for target in self.positional_targets(e, owner, memo) {
+                if !targets.contains(&target) {
+                    targets.push(target);
+                }
+            }
+        }
+        targets
     }
 
     /// Distinct same-named hits inherited from different bases are not
@@ -5730,7 +7411,7 @@ impl Builder {
     /// overriding usage `part :>> c : N;` inherits `d` both through the
     /// redefinition target's type (the original) and through `N` (the
     /// override); the override wins.
-    fn drop_redefined_hits(&self, hits: &mut Vec<LookupResult>) {
+    fn drop_redefined_hits(&mut self, hits: &mut Vec<LookupResult>) {
         let mut found: Vec<usize> = hits
             .iter()
             .filter_map(|h| h.option().map(|(e, _)| e))
@@ -5740,9 +7421,16 @@ impl Builder {
         if found.len() < 2 {
             return;
         }
+        // Only a competing inherited lookup needs semantic redefinitions.
+        // Ordinary owned-name lookups must not initialize the entire graph.
+        self.ensure_positional_redefinitions();
+        // The specialization entries whose recorded outcomes decide the
+        // shadowing: this lookup depends on what their references missed.
+        let mut read = Vec::new();
+        let mut memo = parameters::SlotMemo::default();
         let mut shadowed: Vec<usize> = Vec::new();
         for &e in &found {
-            let mut stack = self.recorded_redefinition_targets(e);
+            let mut stack = self.shadowing_redefinition_targets(e, &mut read, &mut memo);
             let mut seen = HashSet::new();
             while let Some(t) = stack.pop() {
                 if !seen.insert(t) {
@@ -5751,7 +7439,7 @@ impl Builder {
                 if found.contains(&t) && !shadowed.contains(&t) {
                     shadowed.push(t);
                 }
-                stack.extend(self.recorded_redefinition_targets(t));
+                stack.extend(self.shadowing_redefinition_targets(t, &mut read, &mut memo));
             }
         }
         // Implicit redefinition by name (SysML): a usage owned by a type
@@ -5767,9 +7455,13 @@ impl Builder {
             .copied()
             .filter(|e| !shadowed.contains(e))
             .collect();
+        // Not a parameter of a behavior or step, a result or an end: those
+        // redefine by position (`redefines_by_position`), and a reused
+        // name at another position is a collision, which the enumeration
+        // keeps and the distinguishability check reports.
         if remaining.len() > 1 {
             for &x in &remaining {
-                if !self.elements[x].ty.ends_with("Usage") {
+                if !self.elements[x].ty.ends_with("Usage") || self.redefines_by_position(x) {
                     continue;
                 }
                 let Some(ox) = self.owner_elem(x) else {
@@ -5782,13 +7474,16 @@ impl Builder {
                     let Some(oy) = self.owner_elem(y) else {
                         continue;
                     };
-                    if ox != oy && self.recorded_conforms(ox, oy) && !self.recorded_conforms(oy, ox)
+                    if ox != oy
+                        && self.recorded_conforms(ox, oy, &mut read)
+                        && !self.recorded_conforms(oy, ox, &mut read)
                     {
                         shadowed.push(y);
                     }
                 }
             }
         }
+        self.note_spec_misses(read);
         if shadowed.is_empty() {
             return;
         }
@@ -5879,7 +7574,8 @@ impl Builder {
     /// specialization outcomes? Like [`Self::recorded_redefinition_targets`],
     /// a direct scan with no resolution and no index — this runs inside
     /// `lookup_body` (see that method's doc for why both are off-limits).
-    fn recorded_conforms(&self, sub: usize, sup: usize) -> bool {
+    /// The entries whose outcomes it read are added to `read`.
+    fn recorded_conforms(&self, sub: usize, sup: usize, read: &mut Vec<usize>) -> bool {
         if sub == sup {
             return true;
         }
@@ -5896,6 +7592,7 @@ impl Builder {
                         "FeatureTyping" | "Subclassification" | "Subsetting" | "Redefinition"
                     )
                 {
+                    read.push(i);
                     if let Some(t) = self.spec_resolved.get(i).copied().flatten() {
                         if t == sup {
                             return true;
@@ -5917,10 +7614,12 @@ impl Builder {
     /// nor build the permanent `spec_index` mid-lowering while
     /// `spec_targets` is still growing. The scan is linear but only runs
     /// on the rare multi-candidate merges.
-    fn recorded_redefinition_targets(&self, e: usize) -> Vec<usize> {
+    /// The entries whose outcomes it read are added to `read`.
+    fn recorded_redefinition_targets(&self, e: usize, read: &mut Vec<usize>) -> Vec<usize> {
         let mut out = Vec::new();
         for (i, (owner, kind, _, _)) in self.spec_targets.iter().enumerate() {
             if *owner == e && *kind == "Redefinition" {
+                read.push(i);
                 if let Some(t) = self.spec_resolved.get(i).copied().flatten() {
                     if t != e && !out.contains(&t) {
                         out.push(t);
@@ -5928,6 +7627,15 @@ impl Builder {
                 }
             }
         }
+        if self.semantic_ready {
+            if let Some(plan) = self.effective_positional_redefinitions() {
+                for &target in plan.targets.get(&e).into_iter().flatten() {
+                    if !out.contains(&target) {
+                        out.push(target);
+                    }
+                }
+            }
+        }
         out
     }
 
@@ -6034,10 +7742,13 @@ impl Builder {
         bindings: Option<&[Binding]>,
         access: LookupAccess,
         exclude: Option<usize>,
+        semantic_names: bool,
     ) -> LookupResult {
         let mut result = LookupResult::Missing;
         for binding in bindings.into_iter().flatten().copied() {
-            if Some(binding.elem) == exclude {
+            if Some(binding.elem) == exclude
+                || (semantic_names && self.reference_locator_has_no_semantic_name(binding.elem))
+            {
                 continue;
             }
             let widened =
@@ -6045,8 +7756,10 @@ impl Builder {
             if !access.admits(binding.visibility) && !widened {
                 continue;
             }
-            result =
-                self.merge_lookup(result, LookupResult::Found(binding.elem, binding.sub_scope));
+            result = self.merge_lookup(
+                result,
+                LookupResult::Found(binding.elem, binding.sub_scope, None),
+            );
         }
         result
     }
@@ -6058,13 +7771,15 @@ impl Builder {
         depth: usize,
         stamp: u64,
         access: LookupAccess,
+        semantic_names: bool,
     ) -> LookupResult {
         let access = if self.probing {
             LookupAccess::All
         } else {
             access
         };
-        let direct = self.binding_result(self.scopes[s].names.get(name), access, self.exclude);
+        let direct =
+            self.binding_result(self.scopes[s].names.get(name), access, self.exclude, false);
         if direct != LookupResult::Missing {
             return direct;
         }
@@ -6085,6 +7800,7 @@ impl Builder {
                 self.scopes[s].effective_names.get(name),
                 access,
                 self.exclude,
+                semantic_names,
             );
             if effective != LookupResult::Missing {
                 return effective;
@@ -6096,16 +7812,31 @@ impl Builder {
         let mut aliases = LookupResult::Missing;
         for i in 0..self.scopes[s].aliases.len() {
             if self.scopes[s].aliases[i].0 != name
-                || (access == LookupAccess::Public && !self.scopes[s].aliases[i].2)
+                || !self.import_admitted(self.scopes[s].aliases[i].2, access)
             {
                 continue;
             }
             let target = self.scopes[s].aliases[i].1.clone();
-            match self.resolve_result(s, &target, depth + 1, false) {
-                LookupResult::Found(elem, _) => {
+            let origin = self.identity_origin_unit;
+            if !self.id_spelled_targets.is_empty() {
+                self.identity_origin_unit = Some(
+                    self.alias_origins
+                        .get(&(s, i))
+                        .copied()
+                        .unwrap_or_else(|| self.unit_of_scope(s)),
+                );
+            }
+            let resolved = self.resolve_result(s, &target, depth + 1, false);
+            self.identity_origin_unit = origin;
+            match resolved {
+                LookupResult::Found(elem, _, _) => {
                     aliases = self.merge_lookup(
                         aliases,
-                        LookupResult::Found(elem, self.elem_scope.get(&elem).copied()),
+                        LookupResult::Found(
+                            elem,
+                            self.elem_scope.get(&elem).copied(),
+                            Some(self.scopes[s].aliases[i].2),
+                        ),
                     );
                 }
                 LookupResult::Ambiguous => aliases = LookupResult::Ambiguous,
@@ -6118,7 +7849,7 @@ impl Builder {
         let mut implied = LookupResult::Missing;
         for &(end_name, elem, sub) in &self.scopes[s].implied_ends {
             if end_name == name && Some(elem) != self.exclude {
-                implied = self.merge_lookup(implied, LookupResult::Found(elem, Some(sub)));
+                implied = self.merge_lookup(implied, LookupResult::Found(elem, Some(sub), None));
             }
         }
         if implied != LookupResult::Missing {
@@ -6138,18 +7869,22 @@ impl Builder {
                 continue;
             }
             let entry = self.scopes[s].member_imports[i].clone();
+            let origin = self.set_identity_origin(entry.relationship);
             let resolved = self.resolve_result(s, &entry.target, depth + 1, entry.is_import_all);
+            self.identity_origin_unit = origin;
             self.member_import_active.remove(&(s, i));
             match resolved {
-                LookupResult::Found(elem, _) => {
+                LookupResult::Found(elem, _, membership) => {
                     if self.filters_admit(s, &entry.filters, elem, depth) {
                         if !self.probing {
                             self.used_imports.insert(entry.relationship);
                             self.query_imports.push((entry.relationship, access));
                         }
                         let sub = self.elem_scope.get(&elem).copied();
-                        imported_members =
-                            self.merge_lookup(imported_members, LookupResult::Found(elem, sub));
+                        imported_members = self.merge_lookup(
+                            imported_members,
+                            LookupResult::Found(elem, sub, membership),
+                        );
                     }
                 }
                 LookupResult::Ambiguous => imported_members = LookupResult::Ambiguous,
@@ -6159,9 +7894,39 @@ impl Builder {
         if imported_members != LookupResult::Missing {
             return imported_members;
         }
+        if self.recorded_lookup_ready
+            && !self.recorded_lookup_incomplete
+            && !self.probing
+            && self.widen.is_none()
+            && !self.declared_only
+        {
+            if self.recorded_lookup_graph.is_none() {
+                self.recorded_lookup_graph = Some(recorded_lookup::Graph::build(self));
+            }
+            if let Some((hits, suppressed)) = self.recorded_lookup_graph.as_mut().unwrap().select(
+                s,
+                name,
+                access,
+                self.exclude,
+                false,
+                &mut self.current_misses,
+            ) {
+                self.recorded_lookup_suppressed |= suppressed;
+                return hits.into_iter().fold(LookupResult::Missing, |result, hit| {
+                    self.merge_lookup(result, hit)
+                });
+            }
+        }
         let mut hits: Vec<LookupResult> = Vec::new();
         for base in self.base_scopes(s) {
-            hits.push(self.lookup_at(base, name, depth + 1, stamp, access.inherited()));
+            hits.push(self.lookup_at_with_names(
+                base,
+                name,
+                depth + 1,
+                stamp,
+                access.inherited(),
+                semantic_names,
+            ));
         }
         self.drop_redefined_hits(&mut hits);
         let mut inherited = LookupResult::Missing;
@@ -6172,7 +7937,8 @@ impl Builder {
             return inherited;
         }
         let mut imported = LookupResult::Missing;
-        for entry in self.import_scopes(s) {
+        let imports = self.import_scopes(s);
+        for entry in imports.iter() {
             if access == LookupAccess::Public && !entry.is_public {
                 continue;
             }
@@ -6189,7 +7955,7 @@ impl Builder {
                     },
                 )
             } else {
-                self.lookup_at(
+                self.lookup_at_with_names(
                     entry.scope,
                     name,
                     depth + 1,
@@ -6199,16 +7965,18 @@ impl Builder {
                     } else {
                         LookupAccess::Public
                     },
+                    true,
                 )
             };
             match hit {
-                LookupResult::Found(elem, sub) => {
+                LookupResult::Found(elem, sub, membership) => {
                     if self.filters_admit(s, &entry.filters, elem, depth) {
                         if !self.probing {
                             self.used_imports.insert(entry.relationship);
                             self.query_imports.push((entry.relationship, access));
                         }
-                        imported = self.merge_lookup(imported, LookupResult::Found(elem, sub));
+                        imported =
+                            self.merge_lookup(imported, LookupResult::Found(elem, sub, membership));
                     }
                 }
                 LookupResult::Ambiguous => imported = LookupResult::Ambiguous,
@@ -6237,17 +8005,26 @@ impl Builder {
         } else {
             access
         };
-        let mut result = self.lookup_at(s, name, depth, stamp, access);
-        let mut subs: Vec<usize> = self.scopes[s]
-            .names
-            .values()
-            .flatten()
-            .filter(|binding| access.admits(binding.visibility))
-            .filter_map(|binding| binding.sub_scope)
-            .collect();
-        subs.sort_unstable();
-        subs.dedup();
-        for sub in subs {
+        let mut result = self.lookup_at_with_names(s, name, depth, stamp, access, true);
+        let key = (s, access as u8);
+        let subs = match self.recursive_subs.get(&key) {
+            Some(subs) => Arc::clone(subs),
+            None => {
+                let mut subs: Vec<usize> = self.scopes[s]
+                    .names
+                    .values()
+                    .flatten()
+                    .filter(|binding| access.admits(binding.visibility))
+                    .filter_map(|binding| binding.sub_scope)
+                    .collect();
+                subs.sort_unstable();
+                subs.dedup();
+                let subs: Arc<[usize]> = subs.into();
+                self.recursive_subs.insert(key, Arc::clone(&subs));
+                subs
+            }
+        };
+        for &sub in subs.iter() {
             let hit = self.lookup_recursive(sub, name, depth + 1, stamp, access);
             result = self.merge_lookup(result, hit);
         }
@@ -6263,23 +8040,29 @@ impl Builder {
     /// poison the cache with an empty set — making resolution outcomes
     /// depend on file order). Cycle safety comes from the placeholder seed
     /// below and the per-query visit stamps, not from inherited depth.
-    fn import_scopes(&mut self, s: usize) -> Vec<ImportedScope> {
+    fn import_scopes(&mut self, s: usize) -> Arc<Vec<ImportedScope>> {
         if let Some(cached) = &self.import_cache[s] {
-            return cached.clone();
+            Self::note_fill_misses(
+                &mut self.current_misses,
+                &self.fill_frames,
+                self.import_misses.get(s),
+            );
+            return Arc::clone(cached);
         }
         // The cache outlives any query: it must never hold what a
-        // visibility-blind probe or a widened member would resolve.
-        let (probing, widen) = (
-            std::mem::replace(&mut self.probing, false),
-            self.widen.take(),
-        );
+        // visibility-blind probe, a widened member or another query's mode
+        // would resolve.
+        let query = self.enter_fill_mode();
+        let fill = self.begin_fill();
+        self.set_import_misses(s, FillMisses::Filling(fill));
         let result = self.import_scopes_uncached(s);
-        self.probing = probing;
-        self.widen = widen;
+        let misses = self.end_fill();
+        self.set_import_misses(s, misses);
+        self.leave_fill_mode(query);
         result
     }
 
-    fn import_scopes_uncached(&mut self, s: usize) -> Vec<ImportedScope> {
+    fn import_scopes_uncached(&mut self, s: usize) -> Arc<Vec<ImportedScope>> {
         // Placeholder breaks cycles while computing. An import target may
         // itself be visible only through an earlier import of the same
         // scope (`import P::*; import P_Member::*;`), and resolving it
@@ -6289,7 +8072,7 @@ impl Builder {
         // owns a member also named `Domain` must not capture that member
         // through the import itself on the second pass — the
         // namespace-import analogue of `member_import_active`.
-        self.import_cache[s] = Some(Vec::new());
+        self.import_cache[s] = Some(Arc::new(Vec::new()));
         let imports = self.scopes[s].imports.clone();
         let mut outcomes: Vec<Option<(usize, ImportedScope)>> = vec![None; imports.len()];
         let mut walked: Vec<ImportWalks> = vec![Vec::new(); imports.len()];
@@ -6305,8 +8088,9 @@ impl Builder {
                 let entry = imports[i].clone();
                 let at = outcomes[..i].iter().filter(|o| o.is_some()).count();
                 let mine = outcomes[i].as_ref().map(|_| seeds.remove(at));
-                self.import_cache[s] = Some(std::mem::take(&mut seeds));
+                self.import_cache[s] = Some(Arc::new(std::mem::take(&mut seeds)));
                 let mark = self.query_imports.len();
+                let origin = self.set_identity_origin(entry.relationship);
                 let next = self.resolve(s, &entry.target, 0).and_then(|elem| {
                     self.elem_scope.get(&elem).map(|&sc| {
                         (
@@ -6322,10 +8106,14 @@ impl Builder {
                         )
                     })
                 });
+                self.identity_origin_unit = origin;
                 walked[i] = self.query_imports.drain(mark..).collect();
                 // Re-entry into this scope reads the seed; it never
                 // replaces it, so the vector comes back as it was left.
-                seeds = self.import_cache[s].take().unwrap_or_default();
+                seeds = self.import_cache[s]
+                    .take()
+                    .map(|seeds| Arc::try_unwrap(seeds).unwrap_or_else(|shared| (*shared).clone()))
+                    .unwrap_or_default();
                 if next != outcomes[i] {
                     if let Some((_, scope)) = &next {
                         seeds.insert(at, scope.clone());
@@ -6357,18 +8145,19 @@ impl Builder {
                 }
             }
         }
-        self.import_cache[s] = Some(result.clone());
+        let result = Arc::new(result);
+        self.import_cache[s] = Some(Arc::clone(&result));
         result
     }
 
     /// Record import filter expressions and return their indices into
     /// [`Self::filter_exprs`]. `scope` is where the expressions' names
     /// (metaclass references like `Safety`) resolve from.
-    fn record_filters(&mut self, filters: &[Expr], scope: usize) -> Vec<usize> {
+    fn record_filters(&mut self, filters: &[Expr], owner: usize, scope: usize) -> Vec<usize> {
         filters
             .iter()
             .map(|f| {
-                self.filter_exprs.push((scope, f.clone()));
+                self.filter_exprs.push((owner, scope, f.clone()));
                 self.filters_active.push(false);
                 self.filter_exprs.len() - 1
             })
@@ -6404,8 +8193,10 @@ impl Builder {
             return Tri::Unknown;
         }
         self.filters_active[fid] = true;
-        let (scope, expr) = self.filter_exprs[fid].clone();
+        let (owner, scope, expr) = self.filter_exprs[fid].clone();
+        let origin = self.set_identity_origin(owner);
         let out = self.filter_expr_verdict(&expr, scope, elem, depth);
+        self.identity_origin_unit = origin;
         self.filters_active[fid] = false;
         out
     }
@@ -6477,11 +8268,7 @@ impl Builder {
                 let TargetRef::Name(attr) = member else {
                     return Tri::Unknown;
                 };
-                if attr.segments.len() != 1 {
-                    return Tri::Unknown;
-                }
-                let attr = attr.segments[0].value.clone();
-                self.metadata_attr_verdict(scope, meta_qn, &attr, elem, depth)
+                self.metadata_attr_verdict(scope, meta_qn, attr, elem, depth)
             }
             _ => Tri::Unknown,
         }
@@ -6517,9 +8304,16 @@ impl Builder {
             }
         }
         if self.is_reflection_target(target) {
-            return self.metaclass_test(target, elem);
+            let result = self.metaclass_test(target, elem);
+            if result != Tri::False || !self.metadata_associations_incomplete {
+                return result;
+            }
+        }
+        if self.metadata_associations_incomplete {
+            Tri::Unknown
+        } else {
+            Tri::False
         }
-        Tri::False
     }
 
     /// Is `@target` a *reflection* test — one against the candidate's own
@@ -6614,40 +8408,87 @@ impl Builder {
         &mut self,
         scope: usize,
         meta_qn: &QualifiedName,
-        attr: &str,
+        attr: &QualifiedName,
         elem: usize,
         depth: usize,
     ) -> Tri {
+        // A missing incoming annotation can change the cardinality of this
+        // cast and its selected attribute values, even beside a known value.
+        if self.metadata_associations_incomplete {
+            return Tri::Unknown;
+        }
         let Some(target) = self.resolve(scope, meta_qn, depth + 1) else {
             return Tri::Unknown;
         };
-        let metas = self.metadata_of.get(&elem).cloned().unwrap_or_default();
-        for m in metas {
-            if !self.conforms_upward(m, target) {
-                continue;
-            }
-            // The annotation's `attr` member — declared (`isMandatory =
-            // true;`) or redefining (`:>> isMandatory = true;`, findable
-            // by its effective name).
-            let Some(&ms) = self.elem_scope.get(&m) else {
+        // Interchange spells a chain member by its declaration identity. A
+        // qualified or identity-bound spelling must name the same member of
+        // the cast metadata type before its key can select an annotation value.
+        // Merely taking the final segment could capture an unrelated feature.
+        let key = if attr.is_global
+            || attr.segments.len() != 1
+            || self.id_spelled_target(scope, attr).is_some()
+        {
+            let LookupResult::Found(declaration, _, _) =
+                self.resolve_result(scope, attr, depth + 1, false)
+            else {
                 return Tri::Unknown;
             };
-            let f = self.scopes[ms]
-                .names
-                .get(attr)
-                .or_else(|| self.scopes[ms].effective_names.get(attr))
-                .and_then(|bindings| bindings.first())
-                .map(|binding| binding.elem);
-            let Some(f) = f else {
+            if !crate::metaclass::conforms(self.elements[declaration].ty, "Feature") {
+                return Tri::Unknown;
+            }
+            let Some(key) = self.effective_name(declaration) else {
                 return Tri::Unknown;
             };
-            return match self.values.get(&f).map(|(_, e)| &e.kind) {
-                Some(ExprKind::Literal(Literal::Bool(true))) => Tri::True,
-                Some(ExprKind::Literal(Literal::Bool(false))) => Tri::False,
-                _ => Tri::Unknown,
+            let member = Name {
+                value: key.clone(),
+                span: Span::default(),
             };
+            let target_scope = self.elem_scope.get(&target).copied();
+            if !matches!(
+                self.resolve_rest_result(scope, target, target_scope, &[member], depth + 1, false),
+                LookupResult::Found(found, _, _) if found == declaration
+            ) {
+                return Tri::Unknown;
+            }
+            key
+        } else {
+            attr.segments[0].value.clone()
+        };
+        let metas = self.metadata_of.get(&elem).cloned().unwrap_or_default();
+        let mut selected = None;
+        for metadata in metas {
+            if self.conforms_upward(metadata, target) && selected.replace(metadata).is_some() {
+                // This scalar filter evaluator cannot choose one member of a
+                // multi-valued metadata cast by declaration order.
+                return Tri::Unknown;
+            }
+        }
+        let Some(m) = selected else {
+            return Tri::False;
+        };
+        // The annotation's `attr` member — declared (`isMandatory =
+        // true;`) or redefining (`:>> isMandatory = true;`, findable
+        // by its effective name).
+        let Some(&ms) = self.elem_scope.get(&m) else {
+            return Tri::Unknown;
+        };
+        let f = self.scopes[ms]
+            .names
+            .get(&key)
+            .or_else(|| self.scopes[ms].effective_names.get(&key))
+            .and_then(|bindings| match bindings {
+                [binding] => Some(binding),
+                _ => None,
+            })
+            .map(|binding| binding.elem);
+        let Some(f) = f else {
+            return Tri::Unknown;
+        };
+        match self.values.get(&f).map(|(_, e)| &e.kind) {
+            Some(ExprKind::Literal(Literal::Bool(true))) => Tri::True,
+            Some(ExprKind::Literal(Literal::Bool(false))) => Tri::False,
+            _ => Tri::Unknown,
         }
-        Tri::False
     }
 
     /// The body scopes of the specialization bases of the element owning
@@ -6661,27 +8502,59 @@ impl Builder {
     /// returned `usize` is the count of leading entries resolved from
     /// *written* heritage (specializations, typings, chain bases); the
     /// remainder are implied (Tables 31/32 library bases, binary connector
-    /// bases, implicit parameter redefinition, semantic metadata).
+    /// bases, positional parameter, end and result redefinitions, semantic
+    /// metadata).
     pub(crate) fn base_scopes_split(&mut self, s: usize) -> (Vec<usize>, usize) {
         if let Some(cached) = &self.base_cache[s] {
-            return cached.clone();
-        }
-        // As for `import_scopes`: cached bases never come from a probe,
-        // and the import walks that resolve the base names belong to the
-        // specialization's own reference sites, not to whichever lookup
-        // first fills the cache — a prepared library rebuilds its base
-        // caches under the user's lookups, and cold and warm builds must
-        // record identical sites.
-        let (probing, widen) = (
-            std::mem::replace(&mut self.probing, false),
-            self.widen.take(),
-        );
+            Self::note_fill_misses(
+                &mut self.current_misses,
+                &self.fill_frames,
+                self.base_misses.get(s),
+            );
+            return self.with_dynamic_scope_bases(s, cached.clone());
+        }
+        // As for `import_scopes`: cached bases never come from a probe or
+        // another query's mode, and the import walks that resolve the base
+        // names belong to the specialization's own reference sites, not to
+        // whichever lookup first fills the cache — a prepared library
+        // rebuilds its base caches under the user's lookups, and cold and
+        // warm builds must record identical sites.
+        let query = self.enter_fill_mode();
         let mark = self.query_imports.len();
+        let origin = self.identity_origin_unit;
+        if let Some(owner) = self.scopes[s].owner {
+            self.set_identity_origin(owner);
+        }
+        let fill = self.begin_fill();
+        self.set_base_misses(s, FillMisses::Filling(fill));
         let result = self.base_scopes_uncached(s);
+        let misses = self.end_fill();
+        self.set_base_misses(s, misses);
+        self.identity_origin_unit = origin;
         self.query_imports.truncate(mark);
-        self.probing = probing;
-        self.widen = widen;
-        result
+        self.leave_fill_mode(query);
+        self.with_dynamic_scope_bases(s, result)
+    }
+
+    fn with_dynamic_scope_bases(
+        &self,
+        scope: usize,
+        (mut bases, explicit): (Vec<usize>, usize),
+    ) -> (Vec<usize>, usize) {
+        // Keep cached construction bases static. The read-only accepted overlay
+        // adds real existing scopes without contaminating later static planning.
+        if let Some(owner) = self.scopes[scope].owner {
+            if let Some(plan) = self.effective_dynamic_plan() {
+                for target in plan.added_bases.get(&owner).into_iter().flatten() {
+                    if let Some(&target_scope) = self.elem_scope.get(target) {
+                        if target_scope != scope && !bases.contains(&target_scope) {
+                            bases.push(target_scope);
+                        }
+                    }
+                }
+            }
+        }
+        (bases, explicit)
     }
 
     fn base_scopes_uncached(&mut self, s: usize) -> (Vec<usize>, usize) {
@@ -6694,10 +8567,52 @@ impl Builder {
         // A base name must never resolve to the element being specialized
         // itself (its effective name may equal the base's name).
         let saved = self.exclude;
+        let saved_header = self.redefinition_lookup_owner.take();
+        let saved_header_base = self.redefinition_lookup_base.take();
         self.exclude = self.scopes[s].owner;
+        // A redefinition remains a base even when the declaring Type's
+        // filtered inherited view suppresses its target. Use the same header
+        // context as the stored relationship, not ordinary member lookup.
+        let redefinitions: Vec<_> = if let Some(owner) = self.scopes[s].owner.filter(|&owner| {
+            self.elements[owner]
+                .owned_relationships
+                .iter()
+                .any(|&r| self.elements[r].ty == "Redefinition")
+        }) {
+            if self.semantic_ready {
+                self.ensure_spec_index();
+                self.spec_index
+                    .as_ref()
+                    .unwrap()
+                    .get(&owner)
+                    .into_iter()
+                    .flatten()
+                    .filter(|&&i| self.spec_targets[i].1 == "Redefinition")
+                    .map(|&i| self.spec_targets[i].3.clone())
+                    .collect()
+            } else {
+                // Lowering can still append specialization declarations;
+                // never establish its permanent index from a partial prefix.
+                self.spec_targets
+                    .iter()
+                    .filter(|(source, kind, _, _)| *source == owner && *kind == "Redefinition")
+                    .map(|(_, _, _, qn)| qn.clone())
+                    .collect()
+            }
+        } else {
+            Vec::new()
+        };
+        let header_owner = self.scopes[s]
+            .owner
+            .and_then(|owner| self.owner_elem(owner));
         // Fresh depth budget: the cache is permanent, so outcomes must not
         // depend on the first caller's recursion depth (see import_scopes).
         for qn in &bases {
+            self.redefinition_lookup_owner = redefinitions
+                .iter()
+                .any(|target| target == qn)
+                .then_some(header_owner)
+                .flatten();
             if let Some(elem) = self.resolve(from, qn, 0) {
                 if let Some(&sc) = self.elem_scope.get(&elem) {
                     if sc != s {
@@ -6706,6 +8621,8 @@ impl Builder {
                 }
             }
         }
+        self.redefinition_lookup_owner = None;
+        self.redefinition_lookup_base = None;
         // A chain-written base contributes the chain's *last* link: the
         // spine resolves like any reference (member steps in the previous
         // target's scope), and the landed feature's members are inherited.
@@ -6726,6 +8643,13 @@ impl Builder {
         let explicit = result.len();
         for qn in &implied_bases {
             if let Some(elem) = self.resolve(from, qn, 0) {
+                if let [package, member] = qn.segments.as_slice() {
+                    if let Some(role) = implied::binary_role_name(&package.value, &member.value) {
+                        if !self.binary_lookup_target(elem, role) {
+                            continue;
+                        }
+                    }
+                }
                 if let Some(&sc) = self.elem_scope.get(&elem) {
                     if sc != s && !result.contains(&sc) {
                         result.push(sc);
@@ -6733,6 +8657,26 @@ impl Builder {
                 }
             }
         }
+        // A parameter, end or result redefines its general's feature at the
+        // same position by implication (KerML
+        // `checkFeatureParameterRedefinition`, `checkFeatureEndRedefinition`,
+        // `checkFeatureResultRedefinition`), and a redefining feature inherits
+        // the members of what it redefines: `in q;` declared first under
+        // `action def Swapped :> A` reads the members of `A`'s first
+        // parameter, whatever that one is named. The pairing is read off the
+        // owning type's heritage here; the implied relationships materialize
+        // the same edges for the whole model later.
+        if let Some(feature) = self.scopes[s].owner {
+            if let Some(owner) = self.owner_elem(feature) {
+                for target in self.positional_redefinition_targets(feature, owner) {
+                    if let Some(&sc) = self.elem_scope.get(&target) {
+                        if sc != s && !result.contains(&sc) {
+                            result.push(sc);
+                        }
+                    }
+                }
+            }
+        }
         self.exclude = saved;
         // Semantic metadata (KerML 9.2 metaobject semantics): an element
         // annotated with a SemanticMetadata subtype implicitly specializes
@@ -6748,6 +8692,8 @@ impl Builder {
                 }
             }
         }
+        self.redefinition_lookup_owner = saved_header;
+        self.redefinition_lookup_base = saved_header_base;
         self.base_cache[s] = Some((result.clone(), explicit));
         (result, explicit)
     }
@@ -6756,10 +8702,9 @@ impl Builder {
     /// the resolver's own walk ([`Self::base_scopes_split`]) run for
     /// enumeration instead of name lookup. Returns
     /// `(member element, contributing scope)` pairs — the heritage scope
-    /// or import that made the member visible — in breadth-first heritage
-    /// order, members within a level in creation (document) order (the
-    /// lowest-numbered contributing scope wins a tie, so the pairs are
-    /// deterministic), plus the inherited **alias Membership**
+    /// or import that made the member visible — in direct-base order,
+    /// composing each base's public/protected contributions and already
+    /// filtered inheritance, plus the inherited **alias Membership**
     /// relationship indices from the heritage scopes and from every
     /// imported scope the walk visited, and whether a depth guard cut
     /// the walk short. Memoized per (scope, `include_implied`).
@@ -6783,22 +8728,24 @@ impl Builder {
     ///   retained (name lookup answers ambiguous; the memberships still
     ///   inherit);
     /// - `include_implied` extends the walk over the implied heritage
-    ///   (Tables 31/32 library bases, binary connector bases, implicit
-    ///   parameter redefinition, semantic metadata) at *every* level.
+    ///   (Tables 31/32 library bases, binary connector bases, positional
+    ///   parameter, end and result redefinitions, semantic metadata) at
+    ///   *every* level.
     ///
-    /// Deliberate deviations from the normative operation: member
-    /// *elements* are returned, not Membership relationships; the
-    /// `excluded` namespace/type parameters are not taken; alias
-    /// memberships are not enumerated (they denote members declared
-    /// elsewhere — resolve them through lookup). Nearer-level direct
-    /// redefinitions are pooled across heritage branches for the
-    /// intersection condition (the same cross-branch approximation
-    /// lookup's `drop_redefined_hits` makes).
+    /// Ordinary member identities and alias memberships are kept separately
+    /// internally, then projected to Membership handles by the public API.
+    /// Redefinition removal compares their distinct Membership identities;
+    /// aliases to Features participate as both candidates and blockers.
+    /// Acyclic inheritance is evaluated bottom-up without a depth cap;
+    /// cycles use a bounded partial walk and are reported as incomplete.
     pub(crate) fn inherited_bindings(
         &mut self,
         s: usize,
         include_implied: bool,
     ) -> Arc<InheritedBindings> {
+        if include_implied && self.semantic_ready {
+            self.ensure_positional_redefinitions();
+        }
         if let Some(hit) = self.inherited_cache.get(&(s, include_implied)) {
             return Arc::clone(hit);
         }
@@ -6817,7 +8764,10 @@ impl Builder {
                 && sc.imports.is_empty()
                 && sc.member_imports.is_empty()
                 && sc.aliases.is_empty()
-                && sc.implied_ends.is_empty())
+                && sc.implied_ends.is_empty()
+                && sc
+                    .owner
+                    .is_none_or(|e| self.owned_member_elems(e, false).is_empty()))
             .then(|| (self.base_scopes_split(s).0, include_implied))
         };
         let result = match heritage_key
@@ -6827,16 +8777,20 @@ impl Builder {
             Some(hit) => Arc::clone(hit),
             None => {
                 let result = Arc::new(self.inherited_bindings_uncached(s, include_implied));
-                if let Some(k) = heritage_key {
-                    self.inherited_by_heritage.insert(k, Arc::clone(&result));
+                if !result.truncated && !result.incomplete {
+                    if let Some(k) = heritage_key {
+                        self.inherited_by_heritage.insert(k, Arc::clone(&result));
+                    }
                 }
                 result
             }
         };
         self.used_imports = used_imports;
         self.query_imports = query_imports;
-        self.inherited_cache
-            .insert((s, include_implied), Arc::clone(&result));
+        if !result.truncated && !result.incomplete {
+            self.inherited_cache
+                .insert((s, include_implied), Arc::clone(&result));
+        }
         result
     }
 
@@ -6844,6 +8798,59 @@ impl Builder {
         &mut self,
         s: usize,
         include_implied: bool,
+    ) -> InheritedBindings {
+        // Build dependencies iteratively, then let each base contribute its
+        // already-filtered inherited memberships. Pooling raw ancestors loses
+        // removals made by intermediate types and changes positional ordering.
+        let mut state = HashMap::new();
+        let mut order = Vec::new();
+        let mut pending = vec![(s, false)];
+        while let Some((scope, exiting)) = pending.pop() {
+            if self.inherited_cache.contains_key(&(scope, include_implied)) {
+                continue;
+            }
+            if exiting {
+                state.insert(scope, 2);
+                order.push(scope);
+                continue;
+            }
+            match state.get(&scope) {
+                Some(2) => continue,
+                Some(1) => {
+                    let mut result = self.inherited_bindings_walk(s, include_implied, true);
+                    // Cycle exclusions depend on the requested root. Never
+                    // reuse a root-relative partial result as a base's closure.
+                    result.incomplete = true;
+                    return result;
+                }
+                _ => {}
+            }
+            state.insert(scope, 1);
+            pending.push((scope, true));
+            let (mut bases, explicit) = self.base_scopes_split(scope);
+            if !include_implied {
+                bases.truncate(explicit);
+            }
+            pending.extend(bases.into_iter().rev().map(|b| (b, false)));
+        }
+        let mut result = InheritedBindings::default();
+        for scope in order {
+            let value = self.inherited_bindings_walk(scope, include_implied, false);
+            if scope == s {
+                result = value;
+            } else {
+                self.inherited_cache
+                    .insert((scope, include_implied), Arc::new(value));
+            }
+        }
+        result
+    }
+
+    fn inherited_bindings_walk(
+        &mut self,
+        s: usize,
+        include_implied: bool,
+        recursive: bool,
     ) -> InheritedBindings {
         let heritage = |b: &mut Self, sc: usize| {
             let (all, explicit) = b.base_scopes_split(sc);
@@ -6854,24 +8861,49 @@ impl Builder {
             }
         };
         let mut visited: HashSet<usize> = HashSet::from([s]);
-        let mut level: Vec<usize> = heritage(self, s)
+        let mut pending: Vec<(usize, usize)> = heritage(self, s)
             .into_iter()
-            .filter(|&b| visited.insert(b))
+            .rev()
+            .map(|b| (b, 1))
             .collect();
-        // (element, contributing scope), breadth-first.
+        // (element, contributing scope), each direct base before the next.
         let mut collected: Vec<(usize, usize)> = Vec::new();
         let mut seen_elems: HashSet<usize> = HashSet::new();
         let mut alias_rels: Vec<usize> = Vec::new();
+        let mut membership_order = Vec::new();
         let mut truncated = false;
-        for _depth in 1..=MAX_RESOLUTION_DEPTH {
-            if level.is_empty() {
-                break;
+        let mut incomplete = false;
+        while let Some((base, depth)) = pending.pop() {
+            if visited.contains(&base) {
+                continue;
             }
-            // This level's visible bindings, deterministically ordered by
-            // element creation index, then contributing scope (HashMap
-            // iteration order must never reach the result).
+            if depth > MAX_RESOLUTION_DEPTH {
+                truncated = true;
+                continue;
+            }
+            visited.insert(base);
+            // Preserve direct-base order; order each base's own members by
+            // declaration, including members with no declared name.
             let mut found: Vec<(usize, usize)> = Vec::new();
-            for &b in &level {
+            {
+                let b = base;
+                let begin = found.len();
+                if let Some(owner) = self.scopes[b].owner {
+                    found.extend(
+                        self.owned_member_elems(owner, false)
+                            .into_iter()
+                            .filter(|&e| {
+                                self.elements[e].owning_relationship.is_none_or(|r| {
+                                    self.elements[r]
+                                        .props
+                                        .get("visibility")
+                                        .and_then(|v| v.as_str())
+                                        != Some("private")
+                                })
+                            })
+                            .map(|e| (e, b)),
+                    );
+                }
                 for map in [&self.scopes[b].names, &self.scopes[b].effective_names] {
                     for bindings in map.values() {
                         for binding in bindings {
@@ -6882,102 +8914,259 @@ impl Builder {
                         }
                     }
                 }
-                // Public imported memberships re-export through
-                // heritage (KerML nonPrivateMemberships); alias
-                // memberships inherit at inherited access.
-                let mut imported = InheritedBindings::default();
-                self.imported_bindings(b, include_implied, LookupAccess::Protected, &mut imported);
-                found.extend(imported.members);
-                alias_rels.extend(imported.alias_rels);
-                truncated |= imported.truncated;
-                self.scope_alias_rels(b, LookupAccess::Protected, &[], &mut alias_rels);
-            }
-            found.sort_unstable();
+                found[begin..].sort_by_key(|&(e, scope)| {
+                    let protected = self.elements[e].owning_relationship.is_some_and(|r| {
+                        self.elements[r]
+                            .props
+                            .get("visibility")
+                            .and_then(|v| v.as_str())
+                            == Some("protected")
+                    });
+                    (protected, e, scope)
+                });
+                // nonPrivateMemberships unions public owned/imported,
+                // protected owned/imported, then inherited memberships. An
+                // import's visibility controls admission, not its target's.
+                let owned = std::mem::take(&mut found);
+                for access in [LookupAccess::Public, LookupAccess::Protected] {
+                    let own: Vec<_> = owned
+                        .iter()
+                        .copied()
+                        .filter(|&(e, _)| {
+                            self.elements[e]
+                                .owning_relationship
+                                .is_none_or(|r| self.import_admitted(r, access))
+                        })
+                        .collect();
+                    let mut own_order: Vec<_> = own
+                        .iter()
+                        .filter_map(|&(e, _)| self.elements[e].owning_relationship)
+                        .collect();
+                    let mut aliases = Vec::new();
+                    self.scope_alias_rels(b, access, &[], &mut aliases);
+                    own_order.extend(aliases.iter().copied());
+                    own_order.sort_unstable();
+                    own_order.dedup();
+                    membership_order.extend(own_order);
+                    alias_rels.extend(aliases);
+                    found.extend(own);
+                    let mut imported = InheritedBindings::default();
+                    membership_order.extend(self.imported_bindings(
+                        b,
+                        include_implied,
+                        access,
+                        &mut imported,
+                    ));
+                    found.extend(imported.members);
+                    alias_rels.extend(imported.alias_rels);
+                    truncated |= imported.truncated;
+                    incomplete |= imported.incomplete;
+                }
+                if !recursive {
+                    if let Some(inherited) = self.inherited_cache.get(&(b, include_implied)) {
+                        membership_order.extend(inherited.membership_order.iter().copied());
+                        found.extend(inherited.members.iter().copied());
+                        alias_rels.extend(inherited.alias_rels.iter().copied());
+                        truncated |= inherited.truncated;
+                        incomplete |= inherited.incomplete;
+                    }
+                }
+            }
             for (elem, scope) in found {
                 if seen_elems.insert(elem) {
                     collected.push((elem, scope));
                 }
             }
-            level = level
-                .clone()
-                .into_iter()
-                .flat_map(|b| heritage(self, b))
-                .filter(|&b| visited.insert(b))
-                .collect();
+            if recursive {
+                pending.extend(
+                    heritage(self, base)
+                        .into_iter()
+                        .rev()
+                        .map(|b| (b, depth + 1)),
+                );
+            }
         }
-        // Heritage still pending after the last level means the budget,
-        // not the model, ended the walk.
-        truncated |= !level.is_empty();
-        // Redefinition-driven removal (KerML removeRedefinedFeatures +
-        // the owned-features intersection condition + SysML implicit
-        // same-name usage redefinition). Owned members participate as
-        // depth 0.
-        let owned: Vec<usize> = {
-            let mut o: Vec<usize> = self.scopes[s]
-                .names
-                .values()
-                .chain(self.scopes[s].effective_names.values())
-                .flatten()
-                .map(|b| b.elem)
-                .collect();
-            o.sort_unstable();
-            o.dedup();
-            o
-        };
-        // (a) KerML removeRedefinedFeatures, first condition: a candidate
-        //     included in the redefined Features of *another inherited
-        //     candidate* (its member plus everything it transitively
-        //     redefines) is removed. Owned features do not seed this
-        //     condition — they act through condition (b) only.
-        let mut shadow: HashSet<usize> = HashSet::new();
-        let mut closures: HashMap<usize, HashSet<usize>> = HashMap::new();
-        for &(e, _) in &collected {
-            let mut cl = HashSet::new();
-            let mut stack = self.indexed_redefinition_targets(e);
-            while let Some(t) = stack.pop() {
-                if cl.insert(t) {
-                    stack.extend(self.indexed_redefinition_targets(t));
+        self.reduce_inherited_bindings(
+            self.scopes[s].owner,
+            include_implied,
+            InheritedBindings {
+                members: collected,
+                alias_rels,
+                membership_order,
+                truncated,
+                incomplete,
+                implicit_redefinitions: Vec::new(),
+            },
+            None,
+        )
+    }
+
+    /// Preserve compatibility bookkeeping around the shared identity reducer.
+    fn reduce_inherited_bindings(
+        &mut self,
+        owner: Option<usize>,
+        include_implied: bool,
+        mut candidates: InheritedBindings,
+        steps: Option<&mut usize>,
+    ) -> InheritedBindings {
+        let reduced = self.reduce_membership_projection(
+            owner,
+            include_implied,
+            MembershipProjection {
+                membership_order: std::mem::take(&mut candidates.membership_order),
+                truncated: candidates.truncated,
+                incomplete: candidates.incomplete,
+                implicit_redefinitions: Vec::new(),
+            },
+            steps,
+        );
+        let retained: HashSet<_> = reduced.membership_order.iter().copied().collect();
+        let mut seen_members = HashSet::new();
+        candidates.members.retain(|(member, _)| {
+            self.elements[*member]
+                .owning_relationship
+                .is_some_and(|membership| retained.contains(&membership))
+                && seen_members.insert(*member)
+        });
+        let mut seen_aliases = HashSet::new();
+        candidates
+            .alias_rels
+            .retain(|membership| retained.contains(membership) && seen_aliases.insert(*membership));
+        candidates.membership_order = reduced.membership_order;
+        candidates.truncated = reduced.truncated;
+        candidates.incomplete = reduced.incomplete;
+        candidates.implicit_redefinitions = reduced.implicit_redefinitions;
+        candidates
+    }
+
+    /// One redefinition reducer for global and context-sensitive candidates.
+    fn reduce_membership_projection(
+        &mut self,
+        owner: Option<usize>,
+        include_implied: bool,
+        candidates: MembershipProjection,
+        mut steps: Option<&mut usize>,
+    ) -> MembershipProjection {
+        let MembershipProjection {
+            mut membership_order,
+            truncated,
+            mut incomplete,
+            ..
+        } = candidates;
+        macro_rules! charge {
+            ($count:expr) => {
+                if let Some(steps) = steps.as_deref_mut() {
+                    *steps = steps.saturating_add($count);
+                    if *steps > crate::eval::MAX_STEPS {
+                        return MembershipProjection {
+                            truncated: true,
+                            incomplete: true,
+                            ..Default::default()
+                        };
+                    }
                 }
-            }
-            shadow.extend(cl.iter().copied());
-            closures.insert(e, cl);
+            };
         }
-        // (b) Intersection condition (KerML removeRedefinedFeatures,
-        //     second condition — owned features only): an inherited
-        //     member whose redefinition closure meets a feature
-        //     *directly* redefined by an **owned** feature is not
-        //     inherited (owned `z :>> A::x` removes the sibling
-        //     `y :>> x` arriving from farther up). Redefiners inherited
-        //     from unrelated branches never suppress one another.
-        let mut owned_direct: HashSet<usize> = HashSet::new();
-        for &e in &owned {
-            owned_direct.extend(self.indexed_redefinition_targets(e));
+        charge!(membership_order.len());
+        if include_implied {
+            incomplete |= owner.is_some_and(|e| {
+                !self.dynamic_evidence_current(e)
+                    || self
+                        .effective_positional_redefinitions()
+                        .is_some_and(|plan| plan.incomplete.contains(&e))
+            });
         }
-        for &(e, _) in &collected {
-            if shadow.contains(&e) {
-                continue;
+        // An empty inherited projection cannot be shadowed by an owned member.
+        // Keep the readiness side effect of the ordinary path when planning
+        // has not yet run; once ready, no owned-feature scan is necessary.
+        if membership_order.is_empty()
+            && (!include_implied
+                || !self.semantic_ready
+                || self.effective_positional_redefinitions().is_some())
+        {
+            return MembershipProjection {
+                membership_order,
+                truncated,
+                incomplete,
+                implicit_redefinitions: Vec::new(),
+            };
+        }
+        // Membership identity, not memberElement identity, distinguishes
+        // contributors. Resolve each unique relationship's target once; the
+        // same target may intentionally participate through distinct aliases.
+        let mut seen_memberships = HashSet::new();
+        membership_order.retain(|m| seen_memberships.insert(*m));
+        let resolved: Vec<_> = membership_order
+            .iter()
+            .map(|&membership| (membership, self.stored_membership_member(membership)))
+            .collect();
+        let mut seen_members = HashSet::new();
+        let collected: Vec<_> = resolved
+            .iter()
+            .filter_map(|&(membership, member)| {
+                let member = member?;
+                (self.elements[member].owning_relationship == Some(membership)
+                    && seen_members.insert(member))
+                .then_some(member)
+            })
+            .collect();
+        let mut feature_memberships: HashMap<usize, usize> = HashMap::new();
+        for &(_, member) in &resolved {
+            charge!(1);
+            if let Some(e) = member {
+                if crate::metaclass::conforms(self.elements[e].ty, "Feature") {
+                    *feature_memberships.entry(e).or_default() += 1;
+                }
+            } else {
+                incomplete = true;
             }
-            // The member itself counts among its redefined Features
-            // (OCL allRedefinedFeaturesOf includes the memberElement).
-            if owned_direct.contains(&e) {
-                shadow.insert(e);
-                continue;
+        }
+        // Only actual owned Features seed the direct-target intersection.
+        // An owned alias of a redefining Feature is not an ownedFeature.
+        let owned = owner
+            .map(|owner| self.owned_member_elems(owner, true))
+            .unwrap_or_default();
+        let mut owned_direct = HashSet::new();
+        for &e in &owned {
+            charge!(1);
+            owned_direct.extend(self.semantic_redefinition_targets(e, include_implied));
+        }
+        let mut shadow = HashSet::new();
+        // Reuse traversal storage; closures are consumed immediately rather
+        // than retained once per Feature. Every candidate remains a blocker
+        // even when another candidate or an owned Feature removes it.
+        let mut closure = HashSet::new();
+        let mut stack = Vec::new();
+        for (&e, &count) in &feature_memberships {
+            closure.clear();
+            stack.push(e);
+            let mut intersects_owned = false;
+            while let Some(t) = stack.pop() {
+                charge!(1);
+                if !closure.insert(t) {
+                    continue;
+                }
+                // Exclude only the candidate's own Membership, including in
+                // a cycle. Another Membership of the same Feature still counts.
+                if t != e || count > 1 {
+                    shadow.insert(t);
+                }
+                intersects_owned |= owned_direct.contains(&t);
+                stack.extend(self.semantic_redefinition_targets(t, include_implied));
             }
-            let Some(cl) = closures.get(&e) else { continue };
-            if cl.iter().any(|t| owned_direct.contains(t)) {
+            if intersects_owned {
                 shadow.insert(e);
             }
         }
         // (c) SysML implicit same-name usage redefinition: a usage-family
         //     member whose owning type strictly conforms over another
         //     candidate's owner redefines the same-named candidate
-        //     without a spelled `:>>`.
+        //     without a spelled `:>>`. Not a parameter of a behavior or
+        //     step, a result or an end: those redefine by position
+        //     (`redefines_by_position`), and a reused name at another
+        //     position is a collision, not a redefinition.
         let mut by_name: HashMap<&str, Vec<usize>> = HashMap::new();
-        for e in owned
-            .iter()
-            .copied()
-            .chain(collected.iter().map(|&(e, _)| e))
-        {
+        for e in owned.iter().copied().chain(collected.iter().copied()) {
             // Both spellings share the lookup name space: a short name can
             // shadow (or be shadowed by) a declared name, as in lookup.
             for key in ["declaredName", "declaredShortName"] {
@@ -6990,13 +9179,17 @@ impl Builder {
         let mut implicit_redefinitions: Vec<(usize, usize)> = Vec::new();
         for group in groups {
             for &x in &group {
-                if !self.elements[x].ty.ends_with("Usage") || shadow.contains(&x) {
+                if !self.elements[x].ty.ends_with("Usage")
+                    || shadow.contains(&x)
+                    || self.redefines_by_position(x)
+                {
                     continue;
                 }
                 let Some(ox) = self.owner_elem(x) else {
                     continue;
                 };
                 for &y in &group {
+                    charge!(1);
                     if x == y || shadow.contains(&y) {
                         continue;
                     }
@@ -7010,16 +9203,18 @@ impl Builder {
                 }
             }
         }
-        let members = collected
-            .into_iter()
-            .filter(|&(e, _)| !shadow.contains(&e))
-            .collect();
+        membership_order.clear();
+        membership_order.extend(resolved.into_iter().filter_map(|(membership, member)| {
+            member
+                .is_none_or(|member| !shadow.contains(&member))
+                .then_some(membership)
+        }));
         implicit_redefinitions.sort_unstable();
         implicit_redefinitions.dedup();
-        InheritedBindings {
-            members,
-            alias_rels,
+        MembershipProjection {
+            membership_order,
             truncated,
+            incomplete,
             implicit_redefinitions,
         }
     }
@@ -7031,53 +9226,186 @@ impl Builder {
     /// `nonPrivateMemberships`), `All` for the namespace's own
     /// `importedMembership` (every owned import, whatever its
     /// visibility). Member elements, alias Membership relationship
-    /// indices and the truncation flag land in `out`.
+    /// indices and the truncation flag land in `out`; the returned indices
+    /// retain Membership discovery order for the ordered import closure.
     fn imported_bindings(
         &mut self,
         b: usize,
         include_implied: bool,
         admitted: LookupAccess,
         out: &mut InheritedBindings,
-    ) {
-        let member_imports = self.scopes[b].member_imports.clone();
-        for entry in member_imports {
-            if !self.import_admitted(entry.relationship, admitted) {
-                continue;
-            }
-            if let Some(elem) = self.resolve(b, &entry.target, 0) {
-                if self.filters_admit(b, &entry.filters, elem, 0) {
-                    out.members.push((elem, b));
-                }
-            }
+    ) -> Vec<usize> {
+        let mut context = MembershipContext::default();
+        self.imported_bindings_with_context(b, include_implied, admitted, out, &mut context)
+    }
+
+    fn imported_bindings_with_context(
+        &mut self,
+        b: usize,
+        include_implied: bool,
+        admitted: LookupAccess,
+        out: &mut InheritedBindings,
+        context: &mut MembershipContext,
+    ) -> Vec<usize> {
+        if include_implied && self.semantic_ready {
+            self.ensure_positional_redefinitions();
         }
-        let mut seen: HashSet<ImportVisit> = HashSet::new();
-        for entry in self.import_scopes(b) {
-            if !self.import_admitted(entry.relationship, admitted) {
+        let mut order = Vec::new();
+        let mut seen = HashMap::new();
+        let mut excluded = vec![b];
+        self.collect_import_edges(
+            b,
+            admitted,
+            include_implied,
+            &[],
+            &mut excluded,
+            &mut seen,
+            out,
+            &mut order,
+            0,
+            admitted == LookupAccess::All,
+            context,
+        );
+        if admitted == LookupAccess::All {
+            // Namespace::importedMemberships is distinct from the raw
+            // visibility-specific operation used for re-export/inheritance.
+            if let Some(owner) = self.scopes[b].owner {
+                let (retained, incomplete) = self.distinguishable_import_memberships(owner, order);
+                order = retained;
+                out.incomplete |= incomplete;
+            }
+            // Package::importedMemberships filters the Namespace result.
+            let filters = self.scopes[b].filters.clone();
+            order.retain(|&rel| {
+                self.stored_membership_member(rel)
+                    .is_none_or(|member| self.import_filter_set_admits(&filters, member))
+            });
+            let retained: HashSet<_> = order.iter().copied().collect();
+            out.members.retain(|&(element, _)| {
+                self.elements[element]
+                    .owning_relationship
+                    .is_some_and(|rel| retained.contains(&rel))
+            });
+            out.alias_rels.retain(|rel| retained.contains(rel));
+        }
+        order
+    }
+
+    /// Import relationships in declaration order. A recursive membership
+    /// import contributes its Membership before its namespace traversal.
+    #[allow(clippy::too_many_arguments)]
+    fn collect_import_edges(
+        &mut self,
+        sc: usize,
+        access: LookupAccess,
+        include_implied: bool,
+        chain: &[(usize, Vec<usize>)],
+        excluded: &mut Vec<usize>,
+        seen: &mut HashMap<ImportVisit, ImportProjection>,
+        out: &mut InheritedBindings,
+        order: &mut Vec<usize>,
+        depth: usize,
+        defer_package_filters: bool,
+        context: &mut MembershipContext,
+    ) -> Option<Vec<usize>> {
+        if !context.charge(1 + self.scopes[sc].member_imports.len() + self.scopes[sc].imports.len())
+        {
+            out.incomplete = true;
+            out.truncated = true;
+            return None;
+        }
+        let members = self.scopes[sc].member_imports.clone();
+        let namespaces = self.import_scopes(sc);
+        let resolved_imports: HashSet<_> =
+            namespaces.iter().map(|entry| entry.relationship).collect();
+        if self.scopes[sc].imports.iter().any(|entry| {
+            self.import_admitted(entry.relationship, access)
+                && !resolved_imports.contains(&entry.relationship)
+        }) {
+            out.incomplete = true;
+        }
+        let mut entries: Vec<_> = members
+            .iter()
+            .enumerate()
+            .map(|(i, e)| (e.relationship, false, i))
+            .chain(
+                namespaces
+                    .iter()
+                    .enumerate()
+                    .map(|(i, e)| (e.relationship, true, i)),
+            )
+            .collect();
+        entries.sort_unstable();
+        let mut blocked = Vec::new();
+        let mut complete = true;
+        for (rel, namespace, i) in entries {
+            if !self.import_admitted(rel, access) {
                 continue;
             }
-            let access = if entry.is_import_all {
-                LookupAccess::All
+            if namespace {
+                let entry = &namespaces[i];
+                let sub_access = if entry.is_import_all {
+                    LookupAccess::All
+                } else {
+                    LookupAccess::Public
+                };
+                let mut chain2 = chain.to_vec();
+                let mut filters = entry.filters.clone();
+                if !defer_package_filters {
+                    filters.extend_from_slice(&self.scopes[sc].filters);
+                }
+                chain2.push((sc, filters));
+                match self.collect_import_scope(
+                    excluded,
+                    entry.scope,
+                    sub_access,
+                    entry.recursive,
+                    include_implied,
+                    &chain2,
+                    seen,
+                    out,
+                    order,
+                    depth,
+                    context,
+                ) {
+                    Some(bounds) => blocked.extend(bounds),
+                    None => complete = false,
+                }
             } else {
-                LookupAccess::Public
-            };
-            let chain = vec![(b, entry.filters.clone())];
-            self.collect_import_scope(
-                entry.scope,
-                access,
-                entry.recursive,
-                include_implied,
-                &chain,
-                &mut seen,
-                out,
-                0,
-            );
+                let entry = &members[i];
+                let origin = self.set_identity_origin(entry.relationship);
+                let resolved = self.resolve_result(sc, &entry.target, 0, entry.is_import_all);
+                self.identity_origin_unit = origin;
+                if let LookupResult::Found(elem, _, membership) = resolved {
+                    let local_filters = self.scopes[sc].filters.clone();
+                    if self.import_filter_set_admits(&entry.filters, elem)
+                        && (defer_package_filters
+                            || self.import_filter_set_admits(&local_filters, elem))
+                        && self.chain_admits(chain, elem)
+                    {
+                        if let Some(rel) = membership {
+                            out.alias_rels.push(rel);
+                        } else {
+                            out.members.push((elem, sc));
+                        }
+                        if let Some(rel) = membership.or(self.elements[elem].owning_relationship) {
+                            order.push(rel);
+                        } else {
+                            out.incomplete = true;
+                        }
+                    }
+                } else {
+                    out.incomplete = true;
+                }
+            }
         }
+        complete.then_some(blocked)
     }
 
     /// Enumerate what one namespace-import edge makes visible in scope
     /// `sc` — the faithful mirror of `lookup_at` + `lookup_recursive`
     /// over that scope:
-    /// - own (and effective-)named bindings admitted by `access`;
+    /// - owned memberships, including unnamed members, admitted by `access`;
     /// - alias memberships admitted by `access`;
     /// - the scope's own member imports and namespace re-exports, each
     ///   under **its own** policy (filters, `import all`, `::**`) — an
@@ -7086,129 +9414,144 @@ impl Builder {
     /// - the scope's heritage (`base_scopes`), at inherited access —
     ///   lookup resolves inherited members through an import, so
     ///   enumeration follows;
-    /// - for `::**` (`recursive`), descent into owned named members'
-    ///   scopes only — exactly `lookup_recursive`'s traversal.
+    /// - for `::**` (`recursive`), descent into owned members' scopes.
     #[allow(clippy::too_many_arguments)]
     fn collect_import_scope(
         &mut self,
+        excluded: &mut Vec<usize>,
         sc: usize,
         access: LookupAccess,
         recursive: bool,
         include_implied: bool,
         chain: &[(usize, Vec<usize>)],
-        seen: &mut HashSet<ImportVisit>,
+        seen: &mut HashMap<ImportVisit, ImportProjection>,
         out: &mut InheritedBindings,
+        order: &mut Vec<usize>,
         depth: usize,
-    ) {
+        context: &mut MembershipContext,
+    ) -> Option<Vec<usize>> {
+        // Namespace::importedMemberships seeds excluded with itself.
+        // This exclusion is independent of access, recursion and filters.
+        if !context.charge(1) {
+            out.incomplete = true;
+            out.truncated = true;
+            return None;
+        }
+        let is_excluded = excluded.contains(&sc);
+        if !context.namespace_test(sc, is_excluded) {
+            out.incomplete = true;
+            out.truncated = true;
+            return None;
+        }
+        if is_excluded {
+            return Some(vec![sc]);
+        }
         // The filter chain is part of the visit key: a scope first reached
         // through a filtered path must still be visited through an
         // unfiltered one, whatever the import order.
         let mut signature: Vec<(usize, usize)> = chain
             .iter()
-            .flat_map(|(scope, filters)| {
-                // The import's bracket filters plus the importing scope's own
-                // `filter` members, which `filters_admit` applies as well.
-                filters
-                    .iter()
-                    .chain(self.scopes[*scope].filters.iter())
-                    .map(move |&f| (*scope, f))
-            })
+            .flat_map(|(scope, filters)| filters.iter().map(move |&f| (*scope, f)))
             .collect();
         signature.sort_unstable();
         signature.dedup();
         let key: ImportVisit = (sc, access as u8, recursive, signature);
-        if seen.contains(&key) {
-            return;
+        // Redefinition removal is nonmonotonic in namespace exclusions.
+        // Reuse only when every consulted inclusion/exclusion decision agrees,
+        // rather than assuming that more exclusions can only remove results.
+        if let Some(visit) = seen.get(&key) {
+            if context.reuse_namespace(visit, excluded) {
+                return Some(visit.blocked.clone());
+            }
         }
         // A cut visit is not recorded, so a shorter path found later can
         // still complete it; only a genuinely new visit counts as a cut.
         if depth > MAX_RESOLUTION_DEPTH {
             out.truncated = true;
-            return;
+            return None;
         }
-        seen.insert(key);
-        let mut candidates: Vec<usize> = Vec::new();
-        for map in [&self.scopes[sc].names, &self.scopes[sc].effective_names] {
-            for bindings in map.values() {
-                for binding in bindings {
-                    if access.admits(binding.visibility) {
-                        candidates.push(binding.elem);
-                    }
-                }
-            }
+        context.begin_namespace(excluded);
+        excluded.push(sc);
+        let mut blocked = Vec::new();
+        let mut complete = true;
+        let own_cost = self.scopes[sc]
+            .owner
+            .map_or(0, |owner| self.elements[owner].owned_relationships.len());
+        if !context.charge(own_cost + self.scopes[sc].aliases.len()) {
+            excluded.pop();
+            context.finish_namespace(Vec::new());
+            out.incomplete = true;
+            out.truncated = true;
+            return None;
         }
+        // Visibility is a property of Memberships, including unnamed ones;
+        // lookup's name index alone cannot enumerate this collection.
+        let mut candidates: Vec<usize> = if let Some(owner) = self.scopes[sc].owner {
+            self.owned_member_elems(owner, false)
+                .into_iter()
+                .filter(|&elem| {
+                    self.elements[elem]
+                        .owning_relationship
+                        .is_some_and(|rel| self.import_admitted(rel, access))
+                })
+                .collect()
+        } else {
+            self.scopes[sc]
+                .names
+                .values()
+                .chain(self.scopes[sc].effective_names.values())
+                .flatten()
+                .filter(|b| access.admits(b.visibility))
+                .map(|b| b.elem)
+                .collect()
+        };
         candidates.sort_unstable();
         candidates.dedup();
+        let mut subs: Vec<usize> = if recursive {
+            candidates
+                .iter()
+                .filter_map(|e| self.elem_scope.get(e).copied())
+                .collect()
+        } else {
+            Vec::new()
+        };
+        let mut own_memberships = Vec::new();
         for elem in candidates {
             if self.chain_admits(chain, elem) {
                 out.members.push((elem, sc));
-            }
-        }
-        self.scope_alias_rels(sc, access, chain, &mut out.alias_rels);
-        let member_imports = self.scopes[sc].member_imports.clone();
-        for entry in member_imports {
-            if !self.import_admitted(entry.relationship, access) {
-                continue;
-            }
-            if let Some(elem) = self.resolve(sc, &entry.target, 0) {
-                if self.filters_admit(sc, &entry.filters, elem, 0) && self.chain_admits(chain, elem)
-                {
-                    out.members.push((elem, sc));
+                if let Some(rel) = self.elements[elem].owning_relationship {
+                    own_memberships.push(rel);
                 }
             }
         }
-        for sub in self.import_scopes(sc) {
-            if !self.import_admitted(sub.relationship, access) {
-                continue;
-            }
-            let sub_access = if sub.is_import_all {
-                LookupAccess::All
-            } else {
-                LookupAccess::Public
-            };
-            let mut chain2 = chain.to_vec();
-            chain2.push((sc, sub.filters.clone()));
-            self.collect_import_scope(
-                sub.scope,
-                sub_access,
-                sub.recursive,
-                include_implied,
-                &chain2,
-                seen,
-                out,
-                depth + 1,
-            );
-        }
-        let (bases, explicit) = self.base_scopes_split(sc);
-        let bases = if include_implied {
-            bases
-        } else {
-            bases[..explicit].to_vec()
-        };
-        for base in bases {
-            self.collect_import_scope(
-                base,
-                access.inherited(),
-                false,
-                include_implied,
-                chain,
-                seen,
-                out,
-                depth + 1,
-            );
+        let alias_start = out.alias_rels.len();
+        self.scope_alias_rels(sc, access, chain, &mut out.alias_rels);
+        own_memberships.extend_from_slice(&out.alias_rels[alias_start..]);
+        own_memberships.sort_unstable();
+        own_memberships.dedup();
+        order.extend(own_memberships);
+        match self.collect_import_edges(
+            sc,
+            access,
+            include_implied,
+            chain,
+            excluded,
+            seen,
+            out,
+            order,
+            depth + 1,
+            false,
+            context,
+        ) {
+            Some(bounds) => blocked.extend(bounds),
+            None => complete = false,
         }
         if recursive {
-            let mut subs: Vec<usize> = self.scopes[sc]
-                .names
-                .values()
-                .flatten()
-                .filter(|b| access.admits(b.visibility))
-                .filter_map(|b| b.sub_scope)
-                .collect();
             subs.sort_unstable();
             subs.dedup();
             for sub in subs {
-                self.collect_import_scope(
+                let result = self.collect_import_scope(
+                    excluded,
                     sub,
                     access,
                     true,
@@ -7216,17 +9559,84 @@ impl Builder {
                     chain,
                     seen,
                     out,
+                    order,
                     depth + 1,
+                    context,
                 );
+                match result {
+                    Some(bounds) => blocked.extend(bounds),
+                    None => complete = false,
+                }
+            }
+        }
+        if self.scopes[sc]
+            .owner
+            .is_some_and(|owner| crate::metaclass::conforms(self.elements[owner].ty, "Type"))
+        {
+            let family = context.new_type_family();
+            let inherited = self.contextual_inherited_bindings(
+                self.scopes[sc].owner.expect("checked Type owner"),
+                include_implied && !recursive,
+                excluded,
+                &[],
+                family,
+                context,
+                0,
+            );
+            out.truncated |= inherited.truncated;
+            out.incomplete |= inherited.incomplete;
+            complete &= !inherited.truncated;
+            for &membership in &inherited.membership_order {
+                if !context.charge(1) {
+                    out.incomplete = true;
+                    out.truncated = true;
+                    complete = false;
+                    break;
+                }
+                if !self.import_admitted(membership, access) {
+                    continue;
+                }
+                let Some(element) = self.stored_membership_member(membership) else {
+                    out.incomplete = true;
+                    continue;
+                };
+                if !self.chain_admits(chain, element) {
+                    continue;
+                }
+                if self.elements[element].owning_relationship == Some(membership) {
+                    out.members.push((element, sc));
+                } else {
+                    out.alias_rels.push(membership);
+                }
+                order.push(membership);
             }
         }
+        excluded.pop();
+        if !complete {
+            context.finish_namespace(Vec::new());
+            return None;
+        }
+        // This visit always excludes itself; only caller-supplied boundary
+        // exclusions affect whether its completed result is reusable.
+        blocked.retain(|&s| s != sc);
+        blocked.sort_unstable();
+        blocked.dedup();
+        let visit = context.finish_namespace(blocked.clone());
+        seen.insert(key, visit);
+        Some(blocked)
     }
 
     /// Every filter set along an import path admits `elem`.
     fn chain_admits(&mut self, chain: &[(usize, Vec<usize>)], elem: usize) -> bool {
         chain
             .iter()
-            .all(|(scope, filters)| self.filters_admit(*scope, filters, elem, 0))
+            .all(|(_, filters)| self.import_filter_set_admits(filters, elem))
+    }
+
+    fn import_filter_set_admits(&mut self, filters: &[usize], elem: usize) -> bool {
+        filters
+            .iter()
+            .all(|&filter| self.filter_verdict(filter, elem, 0) != Tri::False)
     }
 
     /// Alias Membership relationships of scope `sc` admitted by `access`
@@ -7363,9 +9773,16 @@ impl Builder {
     /// `declared_only` (the memo must not capture a mode-dependent miss).
     fn semantic_metadata_elem(&mut self) -> Option<usize> {
         if let Some(memo) = self.semantic_metadata {
+            Self::note_fill_misses(
+                &mut self.current_misses,
+                &self.fill_frames,
+                Some(&self.semantic_metadata_misses),
+            );
             return memo;
         }
+        self.begin_fill();
         let r = self.resolve(0, &lib_qn("Metaobjects::SemanticMetadata"), 0);
+        self.semantic_metadata_misses = self.end_fill();
         self.semantic_metadata = Some(r);
         r
     }
@@ -7398,8 +9815,14 @@ impl Builder {
             // must land on the *inherited* x, not the redefining part's
             // own registered name — a plain re-resolve self-loops there).
             let recorded = self.spec_resolved.get(i).copied().flatten();
+            self.note_spec_misses([i]);
             let t = match recorded {
                 Some(t) => Some(t),
+                // Redefinition resolution is identity-bound: its original
+                // exclusion/header/callee-chain context cannot be recreated
+                // by an ordinary lexical lookup. An unresolved outcome stays
+                // missing, including a named argument with a lexical namesake.
+                None if self.spec_targets[i].1 == "Redefinition" => None,
                 None => {
                     let (_, _, scope, qn) = self.spec_targets[i].clone();
                     self.resolve(scope, &qn, 0)
@@ -7512,39 +9935,138 @@ impl Builder {
         for i in indices {
             let (_, kind, scope, qn) = self.spec_targets[i].clone();
             if kind == "FeatureTyping" {
-                if let Some(t) = self.resolve(scope, &qn, 0) {
+                self.note_spec_misses([i]);
+                let target = self
+                    .spec_resolved
+                    .get(i)
+                    .copied()
+                    .flatten()
+                    .or_else(|| self.resolve(scope, &qn, 0));
+                if let Some(t) = target {
                     if !out.contains(&t) {
                         out.push(t);
                     }
                 }
             }
         }
-        out
+        out
+    }
+
+    /// The resolved targets of the element's explicit `Redefinition`s,
+    /// read from the builder's recorded pending outcomes (`spec_resolved`
+    /// — a redefinition target must resolve with the owner excluded, so
+    /// re-resolving here would self-hit).
+    pub(crate) fn redefinition_target_elems(&mut self, e: usize) -> Vec<usize> {
+        self.ensure_spec_index();
+        let indices = self
+            .spec_index
+            .as_ref()
+            .and_then(|m| m.get(&e))
+            .cloned()
+            .unwrap_or_default();
+        let mut out = Vec::new();
+        for i in indices {
+            if self.spec_targets[i].1 == "Redefinition" {
+                self.note_spec_misses([i]);
+                if let Some(t) = self.spec_resolved.get(i).copied().flatten() {
+                    if t != e && !out.contains(&t) {
+                        out.push(t);
+                    }
+                }
+            }
+        }
+        out
+    }
+
+    /// Find the local multiplicity, declining an invalid second declaration.
+    /// Body constraints participate even if their ranges are not indexed.
+    pub(crate) fn local_multiplicity(&self, e: usize) -> Option<Option<usize>> {
+        let mut members = self.elements[e]
+            .owned_relationships
+            .iter()
+            .filter(|&&r| crate::metaclass::conforms(self.elements[r].ty, "Membership"))
+            .flat_map(|&r| self.elements[r].children.iter())
+            .filter(|&&child| crate::metaclass::conforms(self.elements[child].ty, "Multiplicity"))
+            .copied();
+        let first = members.next();
+        members.next().is_none().then_some(first)
+    }
+
+    /// Reuse the supported positional redefinition graph for parameters and
+    /// connector ends. Incomplete owner heritage cannot establish bounds.
+    pub(crate) fn cardinality_positional_targets(
+        &mut self,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if !self.dynamic_evidence_current(e) {
+            return None;
+        }
+        if (self.is_parameter(e)
+            || self.elements[e]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true))
+            && self.effective_positional_redefinitions().is_none()
+            && !self.ensure_positional_redefinitions_with_budget(steps)
+        {
+            return None;
+        }
+        let targets = self.completed_positional_targets(e)?;
+        *steps = steps.saturating_add(targets.len());
+        (*steps <= crate::eval::MAX_STEPS).then(|| targets.to_vec())
+    }
+
+    /// Read only a completed positional snapshot. Bounded readers borrow the
+    /// targets and charge before traversal without entering legacy planning.
+    fn completed_positional_targets(&self, e: usize) -> Option<&[usize]> {
+        if !self.dynamic_evidence_current(e) {
+            return None;
+        }
+        if !self.is_parameter(e)
+            && self.elements[e]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                != Some(true)
+        {
+            return Some(&[]);
+        }
+        let plan = self.effective_positional_redefinitions()?;
+        if self
+            .owner_elem(e)
+            .is_some_and(|owner| plan.incomplete.contains(&owner))
+        {
+            return None;
+        }
+        Some(plan.targets.get(&e).map_or(&[][..], Vec::as_slice))
     }
 
-    /// The resolved targets of the element's explicit `Redefinition`s,
-    /// read from the builder's recorded pending outcomes (`spec_resolved`
-    /// — a redefinition target must resolve with the owner excluded, so
-    /// re-resolving here would self-hit).
-    pub(crate) fn redefinition_target_elems(&mut self, e: usize) -> Vec<usize> {
-        self.ensure_spec_index();
-        let indices = self
-            .spec_index
-            .as_ref()
-            .and_then(|m| m.get(&e))
-            .cloned()
-            .unwrap_or_default();
-        let mut out = Vec::new();
-        for i in indices {
-            if self.spec_targets[i].1 == "Redefinition" {
-                if let Some(t) = self.spec_resolved.get(i).copied().flatten() {
-                    if t != e && !out.contains(&t) {
-                        out.push(t);
-                    }
-                }
-            }
+    /// SysML's implicit singleton declaration applies only to structural usages
+    /// owned by a definition or usage, without explicit owned subsettings.
+    /// Call only after ruling out explicit bounds and owned subsettings.
+    pub(crate) fn default_cardinality(&self, e: usize) -> (i128, Option<i128>) {
+        let conforms = crate::metaclass::conforms;
+        let featured = self.owner_elem(e).is_some_and(|owner| {
+            let ty = self.elements[owner].ty;
+            conforms(ty, "Definition") || conforms(ty, "Usage")
+        });
+        if self.structural_usage(e) && featured {
+            (1, Some(1))
+        } else {
+            (0, None)
         }
-        out
+    }
+
+    /// An attribute, port or item usage (connections excluded): the usages
+    /// SysML declares singletons when a definition or usage owns them.
+    pub(crate) fn structural_usage(&self, e: usize) -> bool {
+        let conforms = crate::metaclass::conforms;
+        let ty = self.elements[e].ty;
+        conforms(ty, "AttributeUsage")
+            || conforms(ty, "PortUsage")
+            || (conforms(ty, "ItemUsage") && !conforms(ty, "ConnectionUsage"))
     }
 
     pub(crate) fn resolve_rest(
@@ -7555,7 +10077,7 @@ impl Builder {
         depth: usize,
     ) -> Option<usize> {
         match self.resolve_rest_result(scope.unwrap_or(0), elem, scope, rest, depth, false) {
-            LookupResult::Found(found, _) => Some(found),
+            LookupResult::Found(found, _, _) => Some(found),
             LookupResult::Missing | LookupResult::Ambiguous => None,
         }
     }
@@ -7615,7 +10137,24 @@ impl Builder {
         allow_last_non_public: bool,
     ) -> LookupResult {
         if rest.is_empty() {
-            return LookupResult::Found(elem, scope);
+            return LookupResult::Found(elem, scope, None);
+        }
+        if let Some(id) = self.id_spelled_name(&rest[0]) {
+            if depth > MAX_RESOLUTION_DEPTH {
+                return LookupResult::Missing;
+            }
+            let Some(next) = self.element_index_of_uuid(id) else {
+                return LookupResult::Missing;
+            };
+            let next_scope = self.elem_scope.get(&next).copied();
+            return self.resolve_rest_result(
+                origin,
+                next,
+                next_scope,
+                &rest[1..],
+                depth + 1,
+                allow_last_non_public,
+            );
         }
         let Some(scope) = scope else {
             return LookupResult::Missing;
@@ -7630,14 +10169,20 @@ impl Builder {
             };
         let stamp = self.next_stamp();
         match self.lookup_at(scope, &rest[0].value, depth + 1, stamp, access) {
-            LookupResult::Found(next, next_scope) => self.resolve_rest_result(
-                origin,
-                next,
-                next_scope,
-                &rest[1..],
-                depth + 1,
-                allow_last_non_public,
-            ),
+            hit @ LookupResult::Found(next, next_scope, _) => {
+                if rest.len() == 1 {
+                    hit
+                } else {
+                    self.resolve_rest_result(
+                        origin,
+                        next,
+                        next_scope,
+                        &rest[1..],
+                        depth + 1,
+                        allow_last_non_public,
+                    )
+                }
+            }
             other => other,
         }
     }
@@ -7650,7 +10195,13 @@ fn qn_span(qn: &QualifiedName) -> Span {
     }
 }
 
-fn id_ref(id: Uuid) -> Value {
+/// A reference property value: the element with identity `id`.
+fn id_ref(id: Uuid) -> crate::properties::Atom {
+    crate::properties::Atom::reference(id)
+}
+
+/// A reference in interchange form.
+fn id_value(id: Uuid) -> Value {
     json!({ "@id": id.to_string() })
 }
 
@@ -7980,26 +10531,61 @@ fn member_names(m: &Member, out: &mut HashSet<String>) -> Option<()> {
     );
     if let Some(u) = member_usage(m) {
         if u.declaration.id.name.is_none() {
-            out.extend(effective_ref_name(&u.declaration));
+            out.extend(effective_ref_name(
+                &u.declaration,
+                matches!(
+                    u.kind,
+                    UsageKind::Perform | UsageKind::Exhibit | UsageKind::Include
+                ),
+                u.prefix.is_variant,
+            ));
         }
     }
     Some(())
 }
 
-fn user_member_names(members: &[Member], recursive: bool, out: &mut HashSet<String>) -> Option<()> {
+/// The names the members of a user namespace contribute to an import of
+/// it. Unless the import is `all`, a private or protected import in the
+/// namespace re-exports nothing to it.
+fn user_member_names(
+    members: &[Member],
+    recursive: bool,
+    import_all: bool,
+    out: &mut HashSet<String>,
+) -> Option<()> {
     for m in members {
+        if !import_all
+            && matches!(m.kind, MemberKind::Import(_))
+            && matches!(
+                m.visibility,
+                Some(Visibility::Private | Visibility::Protected)
+            )
+        {
+            continue;
+        }
         member_names(m, out)?;
         if recursive {
             if let Some(body) = member_body(m) {
-                user_member_names(body, true, out)?;
+                user_member_names(body, true, import_all, out)?;
             }
         }
     }
     Some(())
 }
 
-fn effective_ref_name(d: &FeatureDeclaration) -> Option<String> {
+fn effective_ref_name(
+    d: &FeatureDeclaration,
+    reference_chain: bool,
+    variant: bool,
+) -> Option<String> {
+    let named_reference = (reference_chain || variant)
+        && d.specializations
+            .iter()
+            .any(|s| matches!(s, FeatureSpecialization::References(_)));
     for s in &d.specializations {
+        if named_reference && !matches!(s, FeatureSpecialization::References(_)) {
+            continue;
+        }
         let target = match s {
             FeatureSpecialization::References(t) => Some(t),
             FeatureSpecialization::Redefines(ts) => ts.first(),
@@ -8008,7 +10594,12 @@ fn effective_ref_name(d: &FeatureDeclaration) -> Option<String> {
         if let Some(t) = target {
             let qn = match t {
                 TargetRef::Name(qn) => qn,
-                TargetRef::Chain(links) => links.last()?,
+                TargetRef::Chain(links)
+                    if reference_chain && matches!(s, FeatureSpecialization::References(_)) =>
+                {
+                    links.last()?
+                }
+                TargetRef::Chain(_) => return None,
             };
             return qn.segments.last().map(|n| n.value.clone());
         }
@@ -8083,7 +10674,7 @@ pub(crate) fn implicit_def_bases(kind: DefKind) -> &'static [&'static str] {
         DefKind::Connection => &["Connections::Connection"],
         DefKind::Interface => &["Interfaces::Interface"],
         DefKind::Allocation => &["Allocations::Allocation"],
-        DefKind::Flow => &["Flows::Flow"],
+        DefKind::Flow => &["Flows::MessageAction"],
         DefKind::Action => &["Actions::Action"],
         DefKind::State => &["States::StateAction"],
         DefKind::Calc => &["Calculations::Calculation"],
@@ -8107,7 +10698,8 @@ pub(crate) fn implicit_def_bases(kind: DefKind) -> &'static [&'static str] {
         DefKind::Interaction => &["Transfers::Transfer"],
         DefKind::DataType => &["Base::DataValue"],
         DefKind::Type | DefKind::Classifier => &["Base::Anything"],
-        DefKind::Extended | DefKind::Metaclass => &[],
+        DefKind::Metaclass => &["Metaobjects::Metaobject"],
+        DefKind::Extended => &[],
     }
 }
 
@@ -8123,7 +10715,7 @@ pub(crate) fn implicit_usage_bases(kind: UsageKind) -> &'static [&'static str] {
         UsageKind::Connection => &["Connections::connections"],
         UsageKind::Interface => &["Interfaces::interfaces"],
         UsageKind::Allocation => &["Allocations::allocations"],
-        UsageKind::Flow | UsageKind::Message => &["Flows::flows"],
+        UsageKind::Flow | UsageKind::Message => &["Flows::messages"],
         UsageKind::SuccessionFlow => &["Flows::successionFlows"],
         UsageKind::Action | UsageKind::Perform => &["Actions::actions"],
         UsageKind::Accept => &["Actions::acceptActions"],
@@ -8520,6 +11112,8 @@ pub struct SatisfactionInfo {
 /// entry point for semantic queries and expression evaluation.
 pub struct ResolvedModel {
     pub(crate) b: Builder,
+    /// Last publication observed by the derived-reader cache group.
+    semantic_publication_seen: publication::Revision,
     /// Relationship index → owning element, built lazily by
     /// [`Self::element_qualified_name`] (empty until first use).
     rel_owner: Vec<Option<usize>>,
@@ -8552,11 +11146,13 @@ pub struct ResolvedModel {
     external_names: HashMap<Uuid, String>,
     /// The same table inverted: qualified name → id.
     external_by_name: HashMap<String, Uuid>,
+    /// Qualified names with conflicting external identity or provenance
+    /// evidence. The compatibility lookup index remains available, but these
+    /// names cannot prove a designated model-level function identity.
+    external_ambiguous_names: HashSet<String>,
     /// Each external id's root package (the first segment of its
     /// qualified name) — which library package a function belongs to.
     external_package: HashMap<Uuid, String>,
-    /// The implied relationships, once materialized (`json/implied.rs`).
-    implied: Option<implied::ImpliedTable>,
     /// How the inheritance-aware families answer (`json/closures.rs`).
     closure_policy: ClosurePolicy,
     /// Scope → whether its import walk was truncated, per implied flag
@@ -8592,6 +11188,58 @@ impl ResolvedModel {
         Self::from_builder(b, model)
     }
 
+    pub(crate) fn source_compact_json(&self) -> Value {
+        self.b
+            .finish_range(self.b.lib_boundary, self.b.explicit_len())
+    }
+
+    /// Payload units retain their supplied flags even though their syntax was
+    /// reconstructed by the loader. Prepared library prefixes are textual.
+    pub(crate) fn canonical_text_end(&self, e: ElementRef) -> bool {
+        self.b.graph_format == crate::model::GraphFormat::CanonicalV3
+            && e.0 < self.b.explicit_len()
+            && self.b.elements.get(e.0).is_some_and(|row| {
+                metaclass_conforms(row.ty, "Usage")
+                    && row.props.get("isEnd").and_then(|v| v.as_bool()) == Some(true)
+                    && !self
+                        .b
+                        .payload_source_units
+                        .contains(&self.b.unit_of_elem(e.0))
+            })
+    }
+
+    /// Compatibility compact emission completes only proven textual defaults.
+    /// Unknown evidence remains syntax data; checked reads and strict export
+    /// expose the qualification instead of certifying that retained value.
+    fn completed_compact_range(&mut self, start: usize, end: usize) -> Value {
+        let mut compact = self.b.finish_range(start, end);
+        for (offset, row) in compact
+            .as_array_mut()
+            .expect("element array")
+            .iter_mut()
+            .enumerate()
+        {
+            if let Some(report) =
+                self.canonical_end_constant_with_budget(ElementRef(start + offset), 0)
+            {
+                if let Ok(value) = report.value {
+                    row["isConstant"] = json!(value);
+                }
+            }
+        }
+        compact
+    }
+
+    pub(crate) fn payload_owned_flag_anchor(&self, e: ElementRef) -> Option<(usize, String)> {
+        let row = self.b.elements.get(e.0)?;
+        let unit = self.b.unit_of_elem(e.0);
+        (e.0 >= self.b.lib_boundary
+            && e.0 < self.b.explicit_len()
+            && self.b.payload_source_units.contains(&unit)
+            && (row.path_parent.is_some() || !row.path.is_empty()))
+        .then(|| (unit, whole_path(&self.b.elements, e.0)))
+    }
+
     pub(crate) fn from_builder(mut b: Builder, model: &crate::model::Model) -> Self {
         // A user relationship can specialize a library feature without adding
         // a root name. Such a graph cannot reuse derived library quantities.
@@ -8612,22 +11260,26 @@ impl ResolvedModel {
                     .and_then(|key| e.props.get(key))
                     .and_then(|v| v.as_reference())
                     .is_some_and(|id| facts.contains_id(&id))
-                    || e.props
-                        .get("annotatedElement")
-                        .and_then(|v| v.as_array())
-                        .is_some_and(|a| {
-                            a.iter()
-                                .filter_map(|v| v.as_reference())
-                                .any(|id| facts.contains_id(&id))
-                        })
+                    || e.props.get("annotatedElement").is_some_and(|v| {
+                        v.as_reference().is_some_and(|id| facts.contains_id(&id))
+                            || v.as_array().is_some_and(|a| {
+                                a.iter()
+                                    .filter_map(|v| v.as_reference())
+                                    .any(|id| facts.contains_id(&id))
+                            })
+                    })
             });
             if changed {
                 b.semantic_memo = Default::default();
             }
         }
         b.semantic_ready = true;
+        b.publication.enable();
+        b.recorded_lookup_ready = b.recorded_lookup_candidate && !b.recorded_lookup_incomplete;
+        let semantic_publication_seen = b.publication.revision();
         ResolvedModel {
             b,
+            semantic_publication_seen,
             rel_owner: Vec::new(),
             rel_member: Vec::new(),
             by_id: HashMap::new(),
@@ -8642,8 +11294,8 @@ impl ResolvedModel {
             name_memo: Vec::new(),
             external_names: HashMap::new(),
             external_by_name: HashMap::new(),
+            external_ambiguous_names: HashSet::new(),
             external_package: HashMap::new(),
-            implied: None,
             closure_policy: ClosurePolicy::default(),
             import_truncated: HashMap::new(),
             derives_memo: HashMap::new(),
@@ -8664,38 +11316,127 @@ impl ResolvedModel {
     /// reset, and the implied relationships are re-synthesized only if
     /// none were materialized yet (materialized ones stay).
     pub fn set_library_names(&mut self, names: &HashMap<String, Vec<String>>) {
+        let dynamic_was_current = self
+            .b
+            .dynamic_graph
+            .as_ref()
+            .is_some_and(|s| s.current(&self.b));
         self.external_names.clear();
         self.external_by_name.clear();
+        self.external_ambiguous_names.clear();
         self.external_package.clear();
         if self
+            .b
             .implied
             .as_ref()
             .is_some_and(|t| t.from == self.b.elements.len())
         {
-            self.implied = None;
+            self.b.implied = None;
             self.b.implied_from = None;
+            self.b.semantic_ownership = None;
         }
+        let mut qualified_by_id: HashMap<Uuid, &Vec<String>> = HashMap::new();
         for (id, segments) in names {
             let Ok(id) = Uuid::parse_str(id) else {
                 continue;
             };
+            let qualified = segments.join("::");
+            // Alternate textual UUID representations can occur as separate
+            // input keys. Contradictory names for the same parsed identity
+            // must not make function admission depend on map iteration order.
+            if let Some(previous) = qualified_by_id.insert(id, segments) {
+                if previous != segments {
+                    self.external_ambiguous_names.insert(previous.join("::"));
+                    self.external_ambiguous_names.insert(qualified.clone());
+                }
+            }
+            if let Some(previous) = self.external_by_name.get(&qualified) {
+                if *previous != id {
+                    self.external_ambiguous_names.insert(qualified.clone());
+                }
+            }
             if let Some(last) = segments.last() {
                 self.external_names.insert(id, last.clone());
             }
             if let Some(first) = segments.first() {
                 self.external_package.insert(id, first.clone());
             }
-            self.external_by_name.insert(segments.join("::"), id);
+            self.external_by_name.insert(qualified, id);
         }
+        if self.b.implied.is_none() {
+            self.b.external_implied_names = self.external_by_name.clone();
+            self.b.recorded_lookup_graph = None;
+            self.b.recorded_lookup_prefix = None;
+            self.b.positional_redefinitions = None;
+            self.b.supported_implied = None;
+            self.b.inherited_cache.clear();
+            self.b.inherited_by_heritage.clear();
+            self.import_truncated.clear();
+        }
+        self.b
+            .library_names_changed(self.b.implied.is_some(), dynamic_was_current);
         self.name_memo.clear();
     }
 
     /// Resolve a `::`-separated qualified name (quoted segments allowed)
-    /// from the model's root namespace.
+    /// from the model's root namespace. This compatibility lookup also accepts
+    /// anonymous reference locators used by interchange replay; finding an
+    /// element does not imply it has a semantic `name` or `qualifiedName`.
+    /// Use [`Self::resolve_semantic_qualified`] to exclude those locators.
     pub fn resolve_qualified(&mut self, name: &str) -> Option<ElementRef> {
         self.resolve_segments(&split_qualified(name))
     }
 
+    /// Resolve a root-qualified name without accepting compatibility locators
+    /// as semantic names. Alias Memberships remain named independently of
+    /// their target. This uses the same supported lookup rules as
+    /// [`Self::resolve_qualified`]; it is not a completeness certificate for
+    /// namespace resolution in unsupported inheritance/import contexts.
+    pub fn resolve_semantic_qualified(&mut self, name: &str) -> Option<ElementRef> {
+        let mut scope = Some(0);
+        let mut result = None;
+        // Check every qualifier as well: a named child of an anonymous
+        // reference must not become accessible through its parent's locator.
+        for (depth, name) in split_qualified(name).iter().enumerate() {
+            let stamp = self.b.next_stamp();
+            let LookupResult::Found(target, next_scope, membership) =
+                self.b
+                    .lookup_at_with_names(scope?, name, depth, stamp, LookupAccess::All, true)
+            else {
+                return None;
+            };
+            let target = ElementRef(target);
+            let alias = membership.is_some_and(|m| {
+                ["memberName", "memberShortName"].iter().any(|key| {
+                    self.b.elements[m].props.get(key).and_then(|v| v.as_str()) == Some(name)
+                })
+            });
+            if !alias
+                && self.element_effective_name(target).as_ref() != Some(name)
+                && self.element_short_name(target).as_ref() != Some(name)
+            {
+                return None;
+            }
+            result = Some(target);
+            scope = next_scope;
+        }
+        result
+    }
+
+    /// Resolve a named built-in function for expression translation using
+    /// the evaluator's admission rules. Resolved targets must have a known
+    /// standard-library identity. Bare missing names retain standalone intrinsic
+    /// support; ambiguous names and user declarations never select a built-in.
+    /// Callers with a local argument environment must check those bindings first.
+    /// The returned name identifies an implementation, not its supported arities.
+    pub fn intrinsic_function_name(
+        &mut self,
+        scope: ScopeRef,
+        name: &QualifiedName,
+    ) -> Option<String> {
+        self.b.intrinsic_function_name(scope.0, name)
+    }
+
     /// Look up an interchange UUID independently of an element's name.
     /// Includes anonymous and library elements. Malformed or absent IDs
     /// return `None`; the ID belongs to this resolved model state.
@@ -8722,7 +11463,7 @@ impl ResolvedModel {
         };
         // Scope 0 is the shared root namespace.
         match self.b.resolve_unrestricted(0, &qn) {
-            LookupResult::Found(elem, _) => Some(ElementRef(elem)),
+            LookupResult::Found(elem, _, _) => Some(ElementRef(elem)),
             LookupResult::Missing | LookupResult::Ambiguous => None,
         }
     }
@@ -8845,12 +11586,14 @@ impl ResolvedModel {
     /// 8.2.3.5): the declared name, else — for a Feature that declares
     /// neither a name nor a short name — the effective name of its
     /// naming feature: the feature it explicitly redefines,
-    /// else the positional name of the library feature its membership
+    /// else a positional redefinition target in the owner's heritage, else
+    /// the positional name of the library feature its membership
     /// kind implicitly redefines (a binary connector's ends `source` /
     /// `target`, a return parameter `result`, a subject `subj`, an
     /// invocation's positional argument the callee's parameter name, …),
-    /// else the feature it references, else the last link of its feature
-    /// chain. A naming feature that did not resolve names nothing, so an
+    /// else the feature selected by its SysML reference naming rule.
+    /// An anonymous feature chain does not inherit its last link's name.
+    /// A naming feature that did not resolve names nothing, so an
     /// unresolved `:>> mass` is unnamed here where
     /// [`Self::element_lookup_name`] still answers `mass`. Never falls
     /// back to the short name (`qualifiedName` does).
@@ -8878,6 +11621,65 @@ impl ResolvedModel {
         crate::eval::evaluate_feature(self, e)
     }
 
+    /// Evaluate a feature value and retain failures hidden by inherited-default
+    /// fallback. The result matches [`Self::evaluate`]; reporting has separate
+    /// bounded storage. Use [`crate::eval::EvaluationReport::into_checked_result`]
+    /// to reject hidden failures or truncated diagnostics.
+    pub fn evaluate_report(&mut self, e: ElementRef) -> crate::eval::EvaluationReport {
+        crate::eval::evaluate_feature_report(self, e)
+    }
+
+    /// Integer cardinality bounds under the evaluator's supported rules.
+    /// Local explicit bounds and eligible implicit SysML singleton declarations
+    /// take precedence. The implicit `[1]` applies to attribute/item/port usages
+    /// owned by definitions/usages without explicit owned subsettings; connection
+    /// usages and their subtypes are excluded. Otherwise, bounds intersect across
+    /// explicit subsettings/redefinitions and supported positional parameter/end
+    /// redefinitions. With no applicable inherited bounds, the default is `[0..*]`.
+    ///
+    /// Exactness refers to integer representation, not complete normative
+    /// multiplicity semantics. Other specialization kinds and implied constraint
+    /// families are not implemented. Body ranges and named multiplicity subsets
+    /// support exact literals and stored feature references. Inherited reference
+    /// valuations select a unique effective feature by referent identity and
+    /// supported Redefinition edges, independent of reference spelling. Incomplete
+    /// or ambiguous selection and nonliteral bounds during calculation calls
+    /// remain unknown. Receiver provider proofs admit complete nonrecursive,
+    /// unfiltered namespace/member imports. Exact member imports do not require
+    /// unrelated imports in their declaring namespace to be complete. Missing
+    /// providers, recursive/filtered imports, chain bases, attached metadata and
+    /// cycles remain unknown. This is a receiver/inherited-provider proof, not
+    /// a certification of lexical lookup completeness or whole-model validity.
+    /// Reference resolution retains its existing identity contract. Selected
+    /// feature values support contextual scalar formulas, resolving each dependency
+    /// lexically before identity-based selection in the receiver. Contextual calls,
+    /// member navigation, cycles and exhausted budgets remain unknown. Broader
+    /// local formula evaluation is retained before rebasing. Package references
+    /// retain lexical identity while their scalar dependencies keep the receiver.
+    /// Unknown receiver defaults stay unknown.
+    /// Local bounds take precedence; this is not a conformance check against
+    /// every inherited restriction or an implementation of `Type::multiplicities`.
+    ///
+    /// Without local bounds establishing the result, unresolved/unsupported
+    /// owned subsettings and inheritance cycles return `None`. Also returns
+    /// `None` for multiple local multiplicities, invalid evaluated ranges or
+    /// unevaluable bounds; the inner `None` denotes an unbounded upper
+    /// limit. Counts outside
+    /// `i128` are unevaluable. This does not instantiate collection members.
+    pub fn effective_cardinality(&mut self, e: ElementRef) -> Option<(i128, Option<i128>)> {
+        crate::eval::effective_cardinality(self, e)
+    }
+
+    /// Whether `e` is a collection by the implicit default alone: an
+    /// attribute, item or port usage that a package or another non-type
+    /// namespace owns, with no multiplicity, subsetting or redefinition of
+    /// its own. Such a usage evaluates as `[0..*]`, and declaring `[1]`
+    /// makes it one value; a parameter, connector end, reference usage or
+    /// explicitly open multiplicity is never reported here.
+    pub fn implicit_open_multiplicity(&mut self, e: ElementRef) -> bool {
+        crate::eval::implicit_open_multiplicity(self, e)
+    }
+
     /// Render an evaluated value for display with model context:
     /// element results (enum literals, referenced features) show their
     /// declared (or short) name instead of `Display`'s opaque
@@ -8950,6 +11752,53 @@ impl ResolvedModel {
         crate::eval::evaluate_expr_in(&mut self.b, scope.0, expr)
     }
 
+    /// As [`Self::evaluate_in`], retaining bounded diagnostic causes hidden by
+    /// inherited-default fallback. Source identity follows the same contract;
+    /// use [`Self::with_source`] for syntax from a particular declaration.
+    /// A clean report does not certify that a returned value is concrete.
+    pub fn evaluate_in_report(
+        &mut self,
+        scope: ScopeRef,
+        expr: &Expr,
+    ) -> crate::eval::EvaluationReport {
+        crate::eval::evaluate_expr_report(&mut self.b, scope.0, expr)
+    }
+
+    /// Run model queries using the source identity of an expression's declaration.
+    /// This selects source-site identity bindings only; lexical and receiver scopes
+    /// remain the explicit arguments of each query. `owner` must belong to this model.
+    /// Nested calls and unwinding restore the caller's source identity. The callback
+    /// should query the model rather than replace it or its source declarations.
+    pub fn with_source<T>(&mut self, owner: ElementRef, read: impl FnOnce(&mut Self) -> T) -> T {
+        struct Restore<'a> {
+            model: &'a mut ResolvedModel,
+            previous: Option<usize>,
+        }
+        impl Drop for Restore<'_> {
+            fn drop(&mut self) {
+                self.model.b.identity_origin_unit = self.previous;
+            }
+        }
+        let previous = self.b.set_identity_origin(owner.0);
+        let guard = Restore {
+            model: self,
+            previous,
+        };
+        read(&mut *guard.model)
+    }
+
+    /// Evaluate a chain of member names on an already evaluated receiver value.
+    /// All member names are read under the current source context (see
+    /// [`Self::with_source`]); the receiver retains the identity it already has.
+    /// The links share one evaluation budget and use ordinary chain semantics.
+    pub fn evaluate_value_chain(
+        &mut self,
+        target: crate::eval::Value,
+        members: &[&QualifiedName],
+    ) -> Result<crate::eval::Value, crate::eval::EvalError> {
+        crate::eval::evaluate_value_chain(self, target, members)
+    }
+
     /// The measurement unit denoted by a bracket's unit expression
     /// (`[mm]`, `[km/h]`), with references resolving from `scope`. Unlike
     /// [`Self::evaluate_in`] on the whole bracket, this reads *only* the
@@ -8991,6 +11840,7 @@ impl ResolvedModel {
     /// implied relationship is owned through the side table, not its
     /// owner's row.
     fn ensure_rel_owner(&mut self) {
+        self.sync_semantic_publication();
         if self.rel_owner.len() != self.b.elements.len() {
             let mut map = vec![None; self.b.elements.len()];
             for (i, el) in self.b.elements.iter().enumerate() {
@@ -8998,9 +11848,9 @@ impl ResolvedModel {
                     map[r] = Some(i);
                 }
             }
-            if let Some(table) = &self.implied {
-                for (k, &owner) in table.owner_of.iter().enumerate() {
-                    map[table.from + k] = Some(owner);
+            if let Some(view) = &self.b.semantic_ownership {
+                for (relationship, owner) in view.relationship_owners() {
+                    map[relationship] = Some(owner);
                 }
             }
             self.rel_owner = map;
@@ -9009,6 +11859,7 @@ impl ResolvedModel {
 
     /// Build the membership → owned-member map on first use.
     fn ensure_rel_member(&mut self) {
+        self.sync_semantic_publication();
         if self.rel_member.len() != self.b.elements.len() {
             let mut map = vec![None; self.b.elements.len()];
             for (i, el) in self.b.elements.iter().enumerate() {
@@ -9465,6 +12316,77 @@ impl ResolvedModel {
             .collect()
     }
 
+    /// The already-materialized semantic ownership view. Mutable entry points
+    /// establish readiness; immutable source navigation deliberately stays raw.
+    pub(super) fn projected_owned_relationships(&self, e: ElementRef) -> Vec<ElementRef> {
+        match self.b.semantic_ownership.as_ref() {
+            Some(view) => view
+                .relationships(&self.b, e.0)
+                .map(|rows| rows.iter().map(ElementRef).collect())
+                .unwrap_or_default(),
+            None => self.owned_relationships(e),
+        }
+    }
+
+    /// Serialize a generated node with its real kind and reciprocal ownership.
+    /// Source rows are never emitted through this path.
+    pub(crate) fn generated_node_record(&self, e: ElementRef) -> Option<Map<String, Value>> {
+        let view = self.b.semantic_ownership.as_ref()?;
+        if !view.contains(e.0) {
+            return None;
+        }
+        let node = &self.b.elements[e.0];
+        let id = |index: usize| json!({"@id":self.b.elements[index].id.to_string()});
+        let mut record = self.element_properties(e);
+        if crate::metaclass::conforms(node.ty, "Feature") {
+            generated_defaults::fill_owned_defaults(node.ty, &node.props, &mut record);
+        }
+        record.insert("@type".into(), json!(node.ty));
+        record.insert("@id".into(), json!(node.id.to_string()));
+        record.insert("elementId".into(), json!(node.id.to_string()));
+        record.insert("isImpliedIncluded".into(), json!(true));
+        record.insert(
+            "ownedRelationship".into(),
+            Value::Array(view.relationships(&self.b, e.0)?.iter().map(id).collect()),
+        );
+        record.insert(
+            "owningRelationship".into(),
+            node.owning_relationship.map(id).unwrap_or(Value::Null),
+        );
+        if crate::metaclass::conforms(node.ty, "Relationship") {
+            record.insert(
+                "ownedRelatedElement".into(),
+                Value::Array(node.children.iter().copied().map(id).collect()),
+            );
+            record.insert(
+                "owningRelatedElement".into(),
+                view.generated_relationship_owner(e.0)
+                    .map(id)
+                    .unwrap_or(Value::Null),
+            );
+        }
+        record.entry("aliasIds").or_insert_with(|| json!([]));
+        record.entry("declaredName").or_insert(Value::Null);
+        record.entry("declaredShortName").or_insert(Value::Null);
+        Some(record)
+    }
+
+    /// Generated direct descendants, in relationship then child order. The
+    /// full emitter follows this closure atomically from each source owner.
+    pub(crate) fn generated_node_children(&self, e: ElementRef) -> Vec<ElementRef> {
+        let Some(view) = self.b.semantic_ownership.as_ref() else {
+            return Vec::new();
+        };
+        let Some(rows) = view.relationships(&self.b, e.0) else {
+            return Vec::new();
+        };
+        rows.iter()
+            .chain(self.b.elements[e.0].children.iter().copied())
+            .filter(|&index| view.contains(index))
+            .map(ElementRef)
+            .collect()
+    }
+
     /// The elements owned by `e` through its owned memberships, in
     /// declaration order — KerML `Namespace::ownedMember`.
     pub fn owned_members(&self, e: ElementRef) -> Vec<ElementRef> {
@@ -9494,13 +12416,16 @@ impl ResolvedModel {
     /// chains included, filters applied). Removal is redefinition-driven,
     /// not name-driven, per KerML `removeRedefinedFeatures`: a member is
     /// dropped when another inherited candidate (transitively) redefines
-    /// it, when its own redefinition closure meets a feature **directly**
+    /// it (including a distinct Membership of the same Feature), when its
+    /// own redefinition closure meets a feature **directly**
     /// redefined by one of `e`'s owned features (the normative
     /// `ownedFeature.redefinition.redefinedFeature` set is one hop), or
     /// under SysML's implicit same-name usage redefinition; same-name
     /// members of *unrelated* branches are all retained (lookup answers
     /// ambiguous — the memberships still inherit). Handles come in
-    /// breadth-first heritage order, creation order within a level.
+    /// direct-base heritage order (each base's ancestors before the next
+    /// base), preserving
+    /// each base's public-before-protected membership order.
     ///
     /// Returns **Membership relationship handles**, per the normative
     /// operation: owning memberships for ordinary members, the imported
@@ -9519,50 +12444,62 @@ impl ResolvedModel {
     /// The normative `excluded` namespace/type parameters are not taken
     /// (they are the OCL recursion's cycle-guard plumbing; the guard here
     /// is internal — [`Self::inheritance_walk_truncated`] reports when it
-    /// cut the walk). `e` without a body scope answers empty.
+    /// cut the walk). Supported literal, null and metadata-access leaves without a body scope
+    /// read their library heritage by element identity. Other elements without a
+    /// body scope answer empty.
     pub fn inherited_memberships(
         &mut self,
         e: ElementRef,
         include_implied: bool,
     ) -> Vec<ElementRef> {
         let Some(&s) = self.b.elem_scope.get(&e.0) else {
-            return Vec::new();
+            return self
+                .b
+                .literal_inherited_memberships(e.0, include_implied)
+                .membership_order
+                .into_iter()
+                .map(ElementRef)
+                .collect();
         };
         let bindings = self.b.inherited_bindings(s, include_implied);
-        let mut out: Vec<ElementRef> = Vec::new();
-        let mut seen: HashSet<usize> = HashSet::new();
-        for &(elem, _) in &bindings.members {
-            if let Some(r) = self.b.elements[elem].owning_relationship {
-                if seen.insert(r) {
-                    out.push(ElementRef(r));
-                }
-            }
-        }
-        // Alias Memberships — direct heritage and imported alike; the
-        // aliased element is reachable through
-        // [`Self::membership_member`].
-        for &r in &bindings.alias_rels {
-            if seen.insert(r) {
-                out.push(ElementRef(r));
-            }
-        }
-        out
+        bindings
+            .membership_order
+            .iter()
+            .copied()
+            .map(ElementRef)
+            .collect()
     }
 
-    /// Whether the inheritance walk behind [`Self::inherited_memberships`]
-    /// / [`Self::inherited_features`] for `e` hit the resolver's depth
-    /// budget (a heritage or import chain deeper than 24 levels), so the
-    /// enumeration may be incomplete. Cycles never trip it — the walk
-    /// tracks visited scopes and a cyclic heritage enumerates completely;
-    /// only a genuinely deeper chain does. The flag lets an emitter
-    /// refuse to present a cut enumeration as the closure.
+    /// Whether the inheritance/import enumeration reached its depth budget.
+    /// Scoped acyclic inheritance itself has no depth cap; supported scope-less
+    /// expression heritage and contextual import operations have bounded traversal budgets.
+    /// This does not report unsupported semantic dependencies; see
+    /// [`Self::inheritance_incomplete`].
     pub fn inheritance_walk_truncated(&mut self, e: ElementRef, include_implied: bool) -> bool {
         let Some(&s) = self.b.elem_scope.get(&e.0) else {
-            return false;
+            return self
+                .b
+                .literal_inherited_memberships(e.0, include_implied)
+                .truncated;
         };
         self.b.inherited_bindings(s, include_implied).truncated
     }
 
+    /// Whether this inheritance query has a known cyclic or unsupported
+    /// positional dependency, hit an import-walk depth budget, or restored
+    /// bootstrap lookup after selection exceeded its stabilization budget. `false`
+    /// does not certify complete specification conformance: the fidelity of
+    /// inheritance-dependent properties remains qualified. Compatibility
+    /// exports permit unsupported semantics but refuse actual depth cuts.
+    pub fn inheritance_incomplete(&mut self, e: ElementRef, include_implied: bool) -> bool {
+        let Some(&s) = self.b.elem_scope.get(&e.0) else {
+            let result = self.b.literal_inherited_memberships(e.0, include_implied);
+            return result.incomplete || result.truncated;
+        };
+        let result = self.b.inherited_bindings(s, include_implied);
+        result.incomplete || result.truncated || self.b.recorded_lookup_incomplete
+    }
+
     /// [`Self::inherited_memberships`] projected to feature member
     /// *elements*, selected by the **member's** metaclass — the view a
     /// compartment or an object API wants, in which a package-owned part
@@ -9574,7 +12511,19 @@ impl ResolvedModel {
     /// keeps the wider view.
     pub fn inherited_features(&mut self, e: ElementRef, include_implied: bool) -> Vec<ElementRef> {
         let Some(&s) = self.b.elem_scope.get(&e.0) else {
-            return Vec::new();
+            let inherited = self.b.literal_inherited_memberships(e.0, include_implied);
+            let mut seen = HashSet::new();
+            return inherited
+                .membership_order
+                .into_iter()
+                .filter_map(|membership| {
+                    let member = self.b.stored_membership_member(membership)?;
+                    (crate::metaclass::conforms(self.b.elements[member].ty, "Feature")
+                        && seen.insert(member))
+                    .then_some(member)
+                })
+                .map(ElementRef)
+                .collect();
         };
         let bindings = self.b.inherited_bindings(s, include_implied);
         bindings
@@ -9663,7 +12612,11 @@ impl ResolvedModel {
     /// Whether `e` belongs to a loaded library unit (resolution target
     /// only — never serialized, never a transformation target).
     pub fn is_library_element(&self, e: ElementRef) -> bool {
-        e.0 < self.b.lib_boundary
+        self.b
+            .semantic_ownership
+            .as_ref()
+            .map_or(e.0, |view| view.source_anchor(e.0))
+            < self.b.lib_boundary
     }
 
     /// `Type::isAbstract` as declared: the `abstract` keyword, or a
@@ -9678,8 +12631,10 @@ impl ResolvedModel {
     }
 
     /// Evaluated numeric bounds of `e`'s *explicitly declared*
-    /// multiplicity: `[l..u]` → `(l, u)`, `[u]` → `(u, u)` except `[*]`
-    /// → `(0, ∞)` — the same reading the multiplicity checks use.
+    /// header multiplicity: `[l..u]` → `(l, u)`, `[u]` → `(u, u)` except `[*]`
+    /// → `(0, ∞)`. This compatibility accessor returns approximate `f64`
+    /// values; semantic validation retains exact values. Body/named numeric
+    /// domains do not become a declaration of their own Feature cardinality.
     /// `None` when `e` declares no multiplicity of its own (inherited
     /// ones are not walked) or a bound does not evaluate to a number.
     pub fn declared_multiplicity(&mut self, e: ElementRef) -> Option<(f64, f64)> {
@@ -9695,13 +12650,18 @@ impl ResolvedModel {
             crate::eval::Value::Real(f) => Some(f),
             _ => None,
         };
-        let hi = as_num(crate::eval::evaluate_expr_in(&mut self.b, scope, &m.upper).ok()?)?;
-        let lo = match &m.lower {
-            Some(l) => as_num(crate::eval::evaluate_expr_in(&mut self.b, scope, l).ok()?)?,
-            None if hi.is_infinite() => 0.0,
-            None => hi,
-        };
-        Some((lo, hi))
+        let origin = self.b.set_identity_origin(e.0);
+        let result = (|| {
+            let hi = as_num(crate::eval::evaluate_expr_in(&mut self.b, scope, &m.upper).ok()?)?;
+            let lo = match &m.lower {
+                Some(l) => as_num(crate::eval::evaluate_expr_in(&mut self.b, scope, l).ok()?)?,
+                None if hi.is_infinite() => 0.0,
+                None => hi,
+            };
+            Some((lo, hi))
+        })();
+        self.b.identity_origin_unit = origin;
+        result
     }
 
     /// `e`'s explicit FeatureTyping targets (`: T`), resolved — a subset
@@ -9724,10 +12684,10 @@ impl ResolvedModel {
     }
 
     /// How many references failed to resolve (serialized as `@ref`
-    /// spellings). A transformation gate: an edit that was supposed to be
-    /// semantics-preserving must not change this.
+    /// spellings), including ambiguous references. A transformation gate: an
+    /// edit that was supposed to be semantics-preserving must not change this.
     pub fn unresolved_count(&self) -> usize {
-        self.b.unresolved.len()
+        self.b.unresolved.len() + self.b.ambiguous.len()
     }
 
     /// Unresolved user references that name a member visible only under
@@ -9749,7 +12709,8 @@ impl ResolvedModel {
             .collect()
     }
 
-    /// Every reference that failed to resolve: the element whose property
+    /// Every reference that failed to resolve, including ambiguous references:
+    /// the element whose property
     /// carries it, the spelling as written, and the unit it was written
     /// in. Relocation edits (which must not create unresolved references)
     /// diff this list pre/post to name exactly what they broke.
@@ -9757,6 +12718,7 @@ impl ResolvedModel {
         self.b
             .unresolved
             .iter()
+            .chain(self.b.ambiguous.iter())
             .map(|(elem, qn)| UnresolvedReference {
                 owner: ElementRef(*elem),
                 spelling: qn.to_ref_string(),
@@ -9798,6 +12760,20 @@ impl ResolvedModel {
         if map.is_empty() {
             return Vec::new();
         }
+        let dynamic_was_current =
+            self.b.dynamic_graph.as_ref().is_some_and(|s| {
+                s.current(&self.b) && s.outcome == dynamic_graph::Outcome::Accepted
+            });
+        let local_was_current = self
+            .b
+            .dynamic_graph
+            .as_ref()
+            .is_some_and(|s| s.local_current(&self.b));
+        let result_was_current = self
+            .b
+            .dynamic_graph
+            .as_ref()
+            .is_some_and(|snapshot| snapshot.result_redefinition_current(&self.b));
         let mut applied: Vec<(Uuid, Uuid, &'static str)> = Vec::new();
         let mut remap: HashMap<Uuid, Uuid> = HashMap::new();
         let n = self.b.elements.len();
@@ -9814,38 +12790,395 @@ impl ResolvedModel {
         if applied.is_empty() {
             return applied;
         }
+        self.b.recorded_lookup_prefix = None;
         for i in 0..n {
             for atom in self.b.elements[i].props.values_mut() {
                 atom.remap(&remap);
             }
         }
+        for (_, target) in self.b.id_spelled_targets.values_mut() {
+            if let Some(&replacement) = remap.get(target) {
+                *target = replacement;
+            }
+        }
+        // Name tables are reference-bearing indexes too: a later implied
+        // materialization must never recreate an edge to a retired identity.
+        for names in [&mut self.b.lib_qnames, &mut self.b.lib_mem_qnames] {
+            for i in 0..names.len() {
+                if let Some(&id) = remap.get(&names[i].0) {
+                    names[i].0 = id;
+                }
+            }
+        }
+        for names in [
+            &mut self.external_by_name,
+            &mut self.b.external_implied_names,
+        ] {
+            for id in names.values_mut() {
+                if let Some(&replacement) = remap.get(id) {
+                    *id = replacement;
+                }
+            }
+        }
+        // ID replacement can collapse external bindings. Keep conflicting
+        // name provenance qualified even when the compatibility indexes merge.
+        let mut external_names_by_id: HashMap<Uuid, String> = HashMap::new();
+        for (name, &id) in &self.external_by_name {
+            if let Some(previous) = external_names_by_id.insert(id, name.clone()) {
+                if previous != *name {
+                    self.external_ambiguous_names.insert(previous);
+                    self.external_ambiguous_names.insert(name.clone());
+                }
+            }
+        }
+        for names in [&mut self.external_names, &mut self.external_package] {
+            *names = std::mem::take(names)
+                .into_iter()
+                .map(|(id, name)| (remap.get(&id).copied().unwrap_or(id), name))
+                .collect();
+        }
+        if self
+            .b
+            .implied
+            .as_ref()
+            .is_none_or(|t| t.from == self.b.elements.len())
+        {
+            self.b.implied = None;
+            self.b.implied_from = None;
+            self.b.semantic_ownership = None;
+            self.b.positional_redefinitions = None;
+            self.b.inherited_cache.clear();
+            self.b.inherited_by_heritage.clear();
+            self.import_truncated.clear();
+        }
         self.by_id_built_for = usize::MAX;
         self.b.id_index = None;
+        self.b.supported_implied = None;
+        let metadata_changed = self.b.refresh_metadata_associations();
+        if metadata_changed {
+            self.quantity_index = None;
+            self.name_memo.clear();
+            self.redefiner_index = None;
+            self.import_truncated.clear();
+        }
+        self.refresh_implied_specializations();
+        self.b.remap_dynamic_graph(
+            &remap,
+            dynamic_was_current && !metadata_changed,
+            local_was_current,
+            result_was_current && !metadata_changed,
+        );
         applied
     }
 
-    /// Bind references spelled as a bare id — a `{"@ref": "<uuid>"}`
-    /// placeholder left by a reference to an element that has no name
-    /// (the textual notation cannot spell it, so the lift carried the
-    /// id as a quoted name) — to that id: a reference to an element of
-    /// this model, or a dangling reference to an id outside it (a library
-    /// element when no library is loaded), which the emitters carry as
-    /// spelled. Returns the ids bound. Binding sets the property; the
-    /// resolver's semantic tables (typing, specialization, reference
-    /// sites) do not learn the link.
-    pub fn bind_id_spelled_references(&mut self) -> HashSet<Uuid> {
+    /// Bind references spelled as a bare id — a `{"@ref": "<uuid>"}`
+    /// placeholder left by a reference to an element that has no name
+    /// (the textual notation cannot spell it, so the lift carried the
+    /// id as a quoted name) — to that id: a reference to an element of
+    /// this model, or a dangling reference to an id outside it (a library
+    /// element when no library is loaded), which the emitters carry as
+    /// spelled. Returns the ids bound. In-model references participate in
+    /// typing, specialization, inherited lookup, evaluation and reference
+    /// navigation. User references are resolved again after the identities
+    /// become available, including references depending on the newly bound
+    /// heritage or imports. Call after restoring explicit ids and before
+    /// derived/implied queries. Payload loaders should use
+    /// [`Self::bind_id_spelled_references_with`] to disambiguate lexical
+    /// names that happen to spell an identity.
+    ///
+    /// Generated owned-result handles must be reacquired after this call;
+    /// see [`Self::bind_id_spelled_references_with`] for the invalidation rule.
+    pub fn bind_id_spelled_references(&mut self) -> HashSet<Uuid> {
+        self.bind_id_spelled_references_with(&mut HashMap::new())
+    }
+
+    /// Bind identity spellings with the original payload's reference hints.
+    ///
+    /// This call invalidates handles for newly generated owned-result nodes;
+    /// reacquire those nodes through their source expression afterward. Source
+    /// and pre-existing generic implied relationship handles remain valid.
+    /// Invalidated Rust handles are not generation-checked: do not reuse them.
+    /// This also repairs spellings that accidentally resolved as a lexical
+    /// UUID-looking name. The hints are pruned to actual identity spellings
+    /// and should be retained across rebuilds of the lifted text. Call this
+    /// after restoring explicit ids and before derived/implied queries.
+    ///
+    /// Unresolved UUID-shaped spellings without a preserved payload holder
+    /// retain the compatibility interpretation as identity references. The
+    /// lift cannot always distinguish an authored UUID-shaped `@ref` from
+    /// an unnamed-target fallback when it regenerates relationship identity.
+    pub fn bind_id_spelled_references_with(
+        &mut self,
+        hints: &mut crate::loader::IdReferenceBindings,
+    ) -> HashSet<Uuid> {
+        self.bind_id_spelled_references_impl(hints, false)
+    }
+
+    /// Bind only payload-proven reference sites. Unlike the compatibility
+    /// binder, unrelated authored UUID-shaped names keep lexical meaning.
+    /// The same generated-handle invalidation rules apply as for
+    /// [`Self::bind_id_spelled_references_with`].
+    pub fn bind_payload_id_references(
+        &mut self,
+        hints: &mut crate::loader::IdReferenceBindings,
+    ) -> HashSet<Uuid> {
+        self.bind_id_spelled_references_impl(hints, true)
+    }
+
+    /// Source positions of references currently bound by identity. Transform
+    /// callers may map these through their exact text splices and then call
+    /// [`Self::rekey_id_reference_bindings`] on a rebuilt model. This preserves
+    /// site evidence when an enclosing declaration changes identity.
+    pub fn bound_id_reference_sites(&self) -> Vec<(usize, Span, Uuid)> {
+        self.b
+            .id_spelled_targets
+            .iter()
+            .map(|(&(unit, start, end), &(_, id))| (unit, Span { start, end }, id))
+            .collect()
+    }
+
+    /// Recover holder/property keys only at explicitly carried source sites
+    /// whose rebuilt single-segment spelling still equals the given UUID.
+    /// A changed reference spelling is deliberately not carried forward.
+    pub fn rekey_id_reference_bindings(
+        &self,
+        sites: &[(usize, Span, Uuid)],
+    ) -> crate::loader::IdReferenceBindings {
+        let sites: HashMap<_, _> = sites
+            .iter()
+            .map(|(u, s, id)| ((*u, s.start, s.end), *id))
+            .collect();
+        self.b
+            .id_binding_pending
+            .iter()
+            .filter_map(|p| {
+                let [name] = p.qn.segments.as_slice() else {
+                    return None;
+                };
+                if p.qn.is_global {
+                    return None;
+                }
+                let id =
+                    *sites.get(&(self.b.unit_of_elem(p.elem), name.span.start, name.span.end))?;
+                (Uuid::parse_str(&name.value).ok() == Some(id))
+                    .then(|| ((self.b.elem_id(p.elem), p.key.clone()), id))
+            })
+            .collect()
+    }
+
+    /// Current serialized endpoint values for retained payload spelling hints.
+    /// Keep this separate from the spelling map: an imported member's spelling
+    /// denotes a Membership-valued serialized endpoint after resolution.
+    pub fn payload_id_reference_values(
+        &mut self,
+        hints: &crate::loader::IdReferenceBindings,
+    ) -> crate::loader::IdReferenceBindings {
+        hints
+            .keys()
+            .filter_map(|(owner, key)| {
+                let element = self.b.element_index_of_uuid(*owner)?;
+                let (base, index) = key
+                    .split_once('#')
+                    .map_or((key.as_str(), None), |(b, i)| (b, i.parse::<usize>().ok()));
+                let mut value = self.b.elements[element].props.get(base)?;
+                if let Some(index) = index {
+                    let crate::properties::Atom::Array(items) = value else {
+                        return None;
+                    };
+                    value = items.get(index)?;
+                }
+                let target = value
+                    .get("@id")
+                    .and_then(|v| v.as_str())
+                    .and_then(|s| Uuid::parse_str(s).ok())?;
+                Some(((*owner, key.clone()), target))
+            })
+            .collect()
+    }
+
+    fn bind_id_spelled_references_impl(
+        &mut self,
+        hints: &mut crate::loader::IdReferenceBindings,
+        strict: bool,
+    ) -> HashSet<Uuid> {
+        if self.b.id_binding_pending.is_empty() && !self.b.id_spelled_targets.is_empty() {
+            return HashSet::new();
+        }
+        self.discard_owned_result_tail();
         let mut bound: HashSet<Uuid> = HashSet::new();
         let n = self.b.elements.len();
-        for i in self.b.lib_boundary..n {
-            for atom in self.b.elements[i].props.values_mut() {
-                bind_atom(atom, &mut bound);
+        if !strict {
+            for i in self.b.lib_boundary..n {
+                let row = &mut self.b.elements[i];
+                for (key, atom) in row.props.entries.make_mut() {
+                    if !crate::model::is_payload_usage_flag(row.ty, key.name()) {
+                        bind_atom(atom, &mut bound);
+                    }
+                }
             }
         }
+        let mut hinted_sites = HashSet::new();
+        let pending_ids: HashMap<_, _> = self
+            .b
+            .id_binding_pending
+            .iter()
+            .filter_map(|p| {
+                let [name] = p.qn.segments.as_slice() else {
+                    return None;
+                };
+                let id = Uuid::parse_str(&name.value).ok()?;
+                Some(((self.b.elements[p.elem].id, p.key.clone()), (p, id)))
+            })
+            .collect();
+        hints.retain(|key, target| {
+            let matching = pending_ids
+                .get(key)
+                .filter(|(_, id)| id == target)
+                .map(|(p, _)| *p);
+            if let Some(p) = matching {
+                hinted_sites.insert((p.elem, p.qn.span.start, p.qn.span.end));
+                bound.insert(*target);
+                true
+            } else {
+                false
+            }
+        });
+        let strict_slots: Vec<_> = if strict {
+            self.b
+                .id_binding_pending
+                .iter()
+                .filter_map(|p| {
+                    let id = hints.get(&(self.b.elem_id(p.elem), p.key.clone()))?;
+                    Some((p.elem, p.key.clone(), *id))
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
         if !bound.is_empty() {
-            let spellings: HashSet<String> = bound.iter().map(|u| u.to_string()).collect();
-            self.b.unresolved.retain(|(_, qn)| {
-                !(qn.segments.len() == 1 && spellings.contains(&qn.segments[0].value))
-            });
+            if self
+                .b
+                .implied
+                .as_ref()
+                .is_some_and(|t| t.from == self.b.elements.len())
+            {
+                self.b.implied = None;
+                self.b.implied_from = None;
+                self.b.semantic_ownership = None;
+            }
+            let unresolved: HashSet<_> = self
+                .b
+                .unresolved
+                .iter()
+                .map(|(owner, qn)| (*owner, qn.span.start, qn.span.end))
+                .collect();
+            let mut bound_sites = HashSet::new();
+            for pending in &self.b.id_binding_pending {
+                let site = (pending.elem, pending.qn.span.start, pending.qn.span.end);
+                if hinted_sites.contains(&site) || (!strict && unresolved.contains(&site)) {
+                    if let [name] = pending.qn.segments.as_slice() {
+                        if let Ok(id) = Uuid::parse_str(&name.value) {
+                            if bound.contains(&id) {
+                                bound_sites.insert(site);
+                                self.b.id_spelled_targets.insert(
+                                    (
+                                        self.b.unit_of_elem(pending.elem),
+                                        name.span.start,
+                                        name.span.end,
+                                    ),
+                                    (id, id),
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+            self.b.recorded_lookup_prefix = None;
+            self.b.reset_lookup_caches();
+            self.b.semantic_memo = Default::default();
+            self.quantity_index = None;
+            self.name_memo.clear();
+            self.redefiner_index = None;
+            self.import_truncated.clear();
+            let pending = std::mem::take(&mut self.b.id_binding_pending);
+            if !pending.is_empty() {
+                // Array-valued references append during resolution; replay
+                // replaces their values instead of duplicating them.
+                for p in &pending {
+                    if let Some((base, _)) = p.key.split_once('#') {
+                        self.b.elements[p.elem].props.insert(base, json!([]));
+                    }
+                    if let Some(si) = p.spec_idx {
+                        self.b.spec_resolved[si] = None;
+                    }
+                }
+                self.b.unresolved.retain(|(e, _)| *e < self.b.lib_boundary);
+                self.b.ambiguous.retain(|(e, _)| *e < self.b.lib_boundary);
+                self.b.blocked.clear();
+                self.b.ref_sites.clear();
+                self.b.used_imports.clear();
+                self.b.pending = pending;
+                self.b.semantic_ready = false;
+                self.b.resolve_pending();
+                self.b.semantic_ready = true;
+                self.b.positional_redefinitions = None;
+                self.b.supported_implied = None;
+                self.b.inherited_cache.clear();
+                self.b.inherited_by_heritage.clear();
+                // External targets stay references by identity even though
+                // no in-model element can supply a semantic outcome.
+                if strict {
+                    // External targets stay identity references only at the
+                    // exact retained payload-proven slots. Resolved imports
+                    // retain their Membership-valued resolution outcome.
+                    for (elem, key, target) in &strict_slots {
+                        let (base, index) = key
+                            .split_once('#')
+                            .map_or((key.as_str(), None), |(base, i)| {
+                                (base, i.parse::<usize>().ok())
+                            });
+                        let entries = self.b.elements[*elem].props.entries.make_mut();
+                        let Some((_, atom)) = entries.iter_mut().find(|(k, _)| k.name() == base)
+                        else {
+                            continue;
+                        };
+                        let atom = if let Some(index) = index {
+                            let crate::properties::Atom::Array(items) = atom else {
+                                continue;
+                            };
+                            let Some(atom) = items.get_mut(index) else {
+                                continue;
+                            };
+                            atom
+                        } else {
+                            atom
+                        };
+                        if atom
+                            .get("@ref")
+                            .and_then(|v| v.as_str())
+                            .and_then(|s| Uuid::parse_str(s.trim_matches('\'')).ok())
+                            == Some(*target)
+                        {
+                            bind_atom(atom, &mut bound);
+                        }
+                    }
+                } else {
+                    for i in self.b.lib_boundary..n {
+                        let row = &mut self.b.elements[i];
+                        for (key, atom) in row.props.entries.make_mut() {
+                            if !crate::model::is_payload_usage_flag(row.ty, key.name()) {
+                                bind_atom(atom, &mut bound);
+                            }
+                        }
+                    }
+                }
+            }
+            self.b
+                .unresolved
+                .retain(|(owner, qn)| !bound_sites.contains(&(*owner, qn.span.start, qn.span.end)));
+            self.b.refresh_metadata_associations();
+            // Refresh known adjacency only; binding still precedes semantic queries.
+            self.refresh_implied_specializations();
         }
         bound
     }
@@ -10302,123 +13635,87 @@ impl ResolvedModel {
         out
     }
 
-    /// The elements a view usage exposes: every member visible through
-    /// the view's `expose` imports (recursively for `::**` forms), each
-    /// admitted by the view's `filter` conditions — the same
-    /// three-valued filter machinery that governs import visibility, so
-    /// only a provably-false condition hides a member. Order follows
-    /// discovery (per import, declaration order).
-    pub fn view_exposed_elements(&mut self, view: ElementRef) -> Vec<ElementRef> {
-        let Some(&scope) = self.b.elem_scope.get(&view.0) else {
-            return Vec::new();
+    /// The declared name of the rendering a view requests
+    /// (`render asInterconnectionDiagram;` → `asInterconnectionDiagram`):
+    /// the referenced rendering of the first ViewRenderingMembership among
+    /// the view's feature memberships, inherited ones included, as the
+    /// specification derives `viewRendering`. The view's own `render`
+    /// member comes first. A view without one takes the rendering it
+    /// inherits through its typings and specializations (`view v : T;`
+    /// over `view def T { render asElementTable; }` → `asElementTable`);
+    /// of several, the first in heritage order wins — the first-declared
+    /// typing or specialization, and a supertype's own `render` ahead of
+    /// the ones it inherits in turn. A `render` member that references a
+    /// rendering names it (through a feature chain, its last feature); one
+    /// that declares a rendering in place (`render rendering outline;`) is
+    /// that rendering. `None` when the view has no rendering, or when the
+    /// one selected does not resolve to a rendering usage.
+    pub fn view_rendering(&mut self, view: ElementRef) -> Option<String> {
+        self.ensure_by_id();
+        let membership = self.view_rendering_membership(view)?;
+        let rendering = match self.d_referenced_member(membership, "RenderingUsage")? {
+            Reference::Element(rendering) => rendering,
+            Reference::Unresolved(_) => self.spelled_rendering(membership)?,
+            Reference::External(_) => return None,
         };
-        let mut out = Vec::new();
-        // `emitted` keeps the order-preserving `out` free of duplicates
-        // without a linear scan per candidate (a `::**` exposure over a
-        // large model visits every element).
-        let mut emitted = std::collections::HashSet::new();
-        let mut seen = std::collections::HashSet::new();
-        // Membership exposes (`expose P::name;`, and the target itself of
-        // `expose P::**`) contribute their resolved element directly.
-        for entry in self.b.scopes[scope].member_imports.clone() {
-            if let Some(elem) = self.b.resolve(scope, &entry.target, 0) {
-                if self.b.filters_admit(scope, &entry.filters, elem, 0) && emitted.insert(elem) {
-                    out.push(ElementRef(elem));
-                }
-            }
-        }
-        for entry in self.b.import_scopes(scope) {
-            self.collect_exposed(
-                scope,
-                entry.scope,
-                entry.recursive,
-                &entry.filters,
-                &mut seen,
-                &mut emitted,
-                &mut out,
-            );
-        }
-        out
+        self.b.elements[rendering.0]
+            .props
+            .get("declaredName")
+            .and_then(|v| v.as_str())
+            .map(str::to_string)
     }
 
-    #[allow(clippy::too_many_arguments)]
-    fn collect_exposed(
-        &mut self,
-        view_scope: usize,
-        sc: usize,
-        recursive: bool,
-        fids: &[usize],
-        seen: &mut std::collections::HashSet<usize>,
-        emitted: &mut std::collections::HashSet<usize>,
-        out: &mut Vec<ElementRef>,
-    ) {
-        // The seen-set breaks scope cycles (each scope enumerates once).
-        if !seen.insert(sc) {
-            return;
-        }
-        let Some(owner) = self.b.scopes[sc].owner else {
-            return;
-        };
-        for m in self.b.owned_member_elems(owner, false) {
-            if !self.b.filters_admit(view_scope, fids, m, 0) {
-                continue;
-            }
-            if emitted.insert(m) {
-                out.push(ElementRef(m));
-            }
-            if recursive {
-                if let Some(&msc) = self.b.elem_scope.get(&m) {
-                    self.collect_exposed(view_scope, msc, true, fids, seen, emitted, out);
-                }
-            }
+    /// The ViewRenderingMembership [`Self::view_rendering`] reads: the
+    /// view's own, else the first it inherits. The inheritance walk keeps
+    /// a supertype's rendering beside the rendering of a more specific
+    /// type that replaces it, so the order decides: the walk lists each
+    /// type's own memberships ahead of those it inherits.
+    fn view_rendering_membership(&mut self, view: ElementRef) -> Option<ElementRef> {
+        let own = self
+            .owned_relationships_of_kind(view, "ViewRenderingMembership")
+            .into_iter()
+            .next();
+        if own.is_some() {
+            return own;
         }
-    }
-
-    /// The declared name of the rendering a view usage requests
-    /// (`render asInterconnectionDiagram;` → `asInterconnectionDiagram`),
-    /// read from the view's ViewRenderingMembership member's reference.
-    pub fn view_rendering(&mut self, view: ElementRef) -> Option<String> {
-        self.ensure_by_id();
-        let m = self
-            .members_under(view.0, "ViewRenderingMembership")
+        self.inherited_memberships(view, true)
+            .into_iter()
+            .find(|&m| self.is_kind(m, "ViewRenderingMembership"))
+    }
+
+    /// The rendering a `render` member names by a reference that did not
+    /// resolve when the model was built, which holds its spelling as
+    /// written: resolved from the namespace the member was declared in —
+    /// the view's own body, or the body of the definition or view it
+    /// inherits the member from. A chained reference is not re-resolved.
+    fn spelled_rendering(&mut self, membership: ElementRef) -> Option<ElementRef> {
+        let member = self.membership_member(membership)?;
+        let subsetting = self
+            .owned_relationships_of_kind(member, "ReferenceSubsetting")
             .into_iter()
             .next()?;
-        let target = match self.rel_prop_target(m, "ReferenceSubsetting", "referencedFeature") {
-            Some(t) => t,
-            // A library rendering (`render asElementTable;`, the standard
-            // `Views` package) is never serialized, so the reference holds
-            // its spelling as written: resolve that from the view's scope.
-            None => {
-                let rel = *self.b.elements[m]
-                    .owned_relationships
-                    .iter()
-                    .find(|&&r| self.b.elements[r].ty == "ReferenceSubsetting")?;
-                let spelling = self.b.elements[rel]
-                    .props
-                    .get("referencedFeature")?
-                    .get("@ref")?
-                    .as_str()?
-                    .to_string();
-                let scope = *self.b.elem_scope.get(&view.0)?;
-                let qn = QualifiedName {
-                    is_global: false,
-                    segments: split_qualified(&spelling)
-                        .into_iter()
-                        .map(|value| Name {
-                            value,
-                            span: sysmlv2_syntax::span::Span::default(),
-                        })
-                        .collect(),
+        let spelling = self.b.elements[subsetting.0]
+            .props
+            .get("referencedFeature")?
+            .get("@ref")?
+            .as_str()?
+            .to_string();
+        let owner = self.owner(membership)?;
+        let scope = ScopeRef(*self.b.elem_scope.get(&owner.0)?);
+        let qn = QualifiedName {
+            is_global: false,
+            segments: split_qualified(&spelling)
+                .into_iter()
+                .map(|value| Name {
+                    value,
                     span: sysmlv2_syntax::span::Span::default(),
-                };
-                self.b.resolve(scope, &qn, 0)?
-            }
+                })
+                .collect(),
+            span: sysmlv2_syntax::span::Span::default(),
         };
-        self.b.elements[target]
-            .props
-            .get("declaredName")
-            .and_then(|v| v.as_str())
-            .map(str::to_string)
+        let rendering = self.resolve_in_excluding(scope, &qn, Some(member))?;
+        self.is_kind(rendering, "RenderingUsage")
+            .then_some(rendering)
     }
 
     /// Resolve a qualified name with references resolving from `scope` —
@@ -10516,6 +13813,7 @@ impl ResolvedModel {
     /// when they declare none of their own. Library features are not
     /// indexed. Built lazily once per resolved model.
     pub fn redefiners(&mut self, e: ElementRef) -> Vec<ElementRef> {
+        self.sync_semantic_publication();
         if self.redefiner_index.is_none() {
             let mut index: HashMap<usize, Vec<usize>> = HashMap::new();
             let users: Vec<usize> = (self.b.lib_boundary..self.b.elements.len()).collect();
@@ -10560,11 +13858,6 @@ impl ResolvedModel {
             .map(|(s, expr)| (ScopeRef(*s), expr.clone()))
     }
 
-    /// Declared `in`/`inout` parameter names, in declaration order.
-    pub fn calc_params(&self, e: ElementRef) -> Vec<String> {
-        self.b.in_params.get(&e.0).cloned().unwrap_or_default()
-    }
-
     /// The declared `return` parameter, when the calculation has one.
     pub fn calc_return_param(&self, e: ElementRef) -> Option<ElementRef> {
         self.b.return_params.get(&e.0).copied().map(ElementRef)
@@ -10919,8 +14212,9 @@ impl ResolvedModel {
         out
     }
 
-    /// The metadata annotating `e` — prefix metadata (`#M` / `@M`)
-    /// recorded at lowering — in declaration order.
+    /// Known metadata annotating `e`, including prefix/about-less metadata and
+    /// identity-validated explicit `about` annotations, in declaration order.
+    /// Unresolved or malformed annotation associations are omitted.
     pub fn metadata_of(&self, e: ElementRef) -> Vec<ElementRef> {
         self.b
             .metadata_of
@@ -11037,6 +14331,7 @@ impl ResolvedModel {
     }
 
     fn ensure_by_id(&mut self) {
+        self.sync_semantic_publication();
         if self.by_id_built_for != self.b.elements.len() {
             self.by_id_built_for = self.b.elements.len();
             self.by_id = self
@@ -11353,11 +14648,11 @@ mod split_qualified_tests {
 
     #[test]
     fn decodes_control_escapes_like_escape_name_spells_them() {
-        let raw = "APS M3 to APS-TMT Interface Point\nAlignment Error Analysis";
+        let raw = "Optics Bench to Sensor-Hub Interface Point\nAlignment Error Analysis";
         let spelled = format!("P::{}", sysmlv2_syntax::ast::escape_name(raw));
         assert_eq!(
             spelled,
-            "P::'APS M3 to APS-TMT Interface Point\\nAlignment Error Analysis'"
+            "P::'Optics Bench to Sensor-Hub Interface Point\\nAlignment Error Analysis'"
         );
         assert_eq!(
             split_qualified(&spelled),
@@ -11386,7 +14681,7 @@ mod split_qualified_tests {
         let mut model = crate::model::Model::new();
         let unit = model.add_source(
             "t.sysml".to_string(),
-            "package P { part def 'APS M3 to APS-TMT Interface Point\\nAlignment Error Analysis'; }",
+            "package P { part def 'Optics Bench to Sensor-Hub Interface Point\\nAlignment Error Analysis'; }",
         );
         assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
         let mut r = super::ResolvedModel::build(&model);
@@ -11395,7 +14690,7 @@ mod split_qualified_tests {
         let spelled = r.element_qualified_name(def).unwrap();
         assert_eq!(
             spelled,
-            "P::'APS M3 to APS-TMT Interface Point\\nAlignment Error Analysis'"
+            "P::'Optics Bench to Sensor-Hub Interface Point\\nAlignment Error Analysis'"
         );
         assert_eq!(r.resolve_qualified(&spelled), Some(def));
     }
@@ -11413,6 +14708,12 @@ mod split_qualified_tests {
 #[cfg(test)]
 mod unused_imports_tests;
 
+#[cfg(test)]
+mod replay_dependencies_tests;
+
+#[cfg(test)]
+mod identity_tables_tests;
+
 /// Persist element headers and their variable-length lists as separate tables.
 /// A decoded library shares each table's contiguous backing storage.
 mod element_table {
@@ -11427,7 +14728,7 @@ mod element_table {
     struct HeaderRef<'a> {
         ty: &'a str,
         id: Uuid,
-        path: &'a str,
+        path: std::borrow::Cow<'a, str>,
         present: u64,
         flags: u64,
         owner: Option<usize>,
@@ -11463,10 +14764,15 @@ mod element_table {
         struct Headers<'a>(&'a LayeredVec<Elem>);
         impl Serialize for Headers<'_> {
             fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-                s.collect_seq(self.0.iter().map(|e| HeaderRef {
+                s.collect_seq(self.0.iter().enumerate().map(|(i, e)| HeaderRef {
                     ty: e.ty,
                     id: e.id,
-                    path: &e.path,
+                    // The table holds whole paths, which decode as such.
+                    path: if e.path_parent.is_some() {
+                        whole_path(self.0, i).into()
+                    } else {
+                        e.path.as_str().into()
+                    },
                     present: e.props.present,
                     flags: e.props.flags,
                     owner: e.owning_relationship,
@@ -11519,6 +14825,7 @@ mod element_table {
                 ty: h.ty.0,
                 id: h.id,
                 path: h.path,
+                path_parent: None,
                 props: Properties {
                     present: h.present,
                     flags: h.flags,
@@ -11570,4 +14877,478 @@ mod element_table_tests {
                 .is_err()
         );
     }
+
+    /// The table carries whole ownership paths, however the builder holds
+    /// them, and decodes to the same paths and identities.
+    #[test]
+    fn whole_paths_survive_the_table() {
+        let mut model = crate::model::Model::new();
+        model.add_library_source(
+            "l.sysml",
+            "package L { part p { attribute x = 1 + 2 * 3; } }",
+        );
+        let mut b = Builder::default();
+        b.build_model(&model);
+        assert!(b.elements.iter().any(|e| e.path_parent.is_some()));
+        let decoded: Table = crate::cache_codec::decode(
+            &crate::cache_codec::encode(&Table(b.elements.clone())).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(decoded.0.len(), b.elements.len());
+        for i in 0..b.elements.len() {
+            assert_eq!(whole_path(&decoded.0, i), whole_path(&b.elements, i));
+            assert_eq!(decoded.0[i].id, b.elements[i].id);
+        }
+    }
+}
+
+#[cfg(test)]
+mod ownership_path_tests {
+    use super::*;
+
+    /// An identity derived from an ownership path is the version-5
+    /// identity of the whole path, whether the parent's hash state was
+    /// kept or the parent's path is read afresh — including for children
+    /// of elements created before the states were kept or after they
+    /// were dropped.
+    #[test]
+    fn identities_hash_the_whole_ownership_path() {
+        for keep in [true, false] {
+            let mut b = Builder::default();
+            let mut paths = Vec::new();
+            let root = b.new_element("Namespace", None, "$root/u.sysml".into());
+            paths.push("$root/u.sysml".to_string());
+            if keep {
+                b.keep_path_hashes();
+            }
+            let mut parent = root;
+            for level in 0..40 {
+                let segment = format!("m{level}");
+                let rel = b.new_relationship("OwningMembership", parent, &segment);
+                paths.push(format!("{}/{segment}", paths[parent]));
+                // Segments may be empty or hold separators of their own.
+                let segment = ["", "x/y", "e", "first"][level % 4];
+                let element = b.new_owned_element("PartUsage", rel, segment);
+                paths.push(format!("{}/{segment}", paths[rel]));
+                parent = element;
+            }
+            b.path_hashes = None;
+            for owner in [root, parent, parent / 2] {
+                b.new_relationship("Membership", owner, "late");
+                paths.push(format!("{}/late", paths[owner]));
+            }
+            assert_eq!(paths.len(), b.elements.len());
+            for (i, path) in paths.iter().enumerate() {
+                assert_eq!(&whole_path(&b.elements, i), path);
+                assert_eq!(
+                    b.elements[i].id,
+                    Uuid::new_v5(&ID_NAMESPACE, path.as_bytes()),
+                    "{path}"
+                );
+            }
+        }
+    }
+
+    /// Lowering stores and hashes a bounded number of path bytes per
+    /// element, however deep the ownership nests. Measured in bytes rather
+    /// than in wall-clock time: the counts are the work and the memory the
+    /// paths take, and do not depend on the machine.
+    ///
+    /// The longest operator chain the parser admits nests its first operand
+    /// over four thousand ownership levels deep. Holding and hashing each
+    /// element's whole path took about 233 MB of each over its seventeen
+    /// thousand elements, against about 100 KB with segments.
+    #[test]
+    fn path_cost_is_linear_in_the_ownership_depth() {
+        // Lowering the chain recurses once per operator, so the probe runs
+        // on a thread with room for it; the count is kept per thread, so
+        // the build runs there too.
+        std::thread::Builder::new()
+            .stack_size(64 << 20)
+            .spawn(|| {
+                let terms = sysmlv2_syntax::parser::MAX_EXPR_OPERATORS as usize;
+                let chain = (0..terms)
+                    .map(|i| format!("a{i} > 0"))
+                    .collect::<Vec<_>>()
+                    .join(" and ");
+                let mut model = crate::model::Model::new();
+                model.add_source(
+                    "chain.sysml",
+                    &format!("package P {{ part x {{ attribute v = {chain}; }} }}"),
+                );
+                assert!(!model.has_errors());
+                let before = path_bytes_hashed();
+                let r = ResolvedModel::build(&model);
+                let hashed = path_bytes_hashed() - before;
+                let elements = r.b.elements.len();
+                let stored: usize = r.b.elements.iter().map(|e| e.path.len()).sum();
+                assert!(
+                    stored <= 16 * elements,
+                    "{stored} path bytes held for {elements} elements"
+                );
+                assert!(
+                    hashed <= 32 * elements,
+                    "{hashed} path bytes hashed for {elements} elements"
+                );
+            })
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+}
+
+#[cfg(test)]
+mod filter_origin_tests {
+    use super::*;
+    use crate::model::Model;
+
+    #[test]
+    fn prepared_filters_reject_invalid_source_scope_and_filter_indexes() {
+        let mut model = Model::new();
+        model.add_library_source("lib.sysml","package Items { part def X; } package P { filter true; import Items::*[true]; import Items::X[true]; }");
+        assert!(!model.has_errors());
+        let r = ResolvedModel::build(&model);
+        assert!(r.b.valid_library(1));
+        for field in [0, 1] {
+            let mut b = r.b.clone();
+            if field == 0 {
+                b.filter_exprs[0].0 = b.elements.len();
+            } else {
+                b.filter_exprs[0].1 = b.scopes.len();
+            }
+            assert!(!b.valid_library(1));
+        }
+        for kind in [0, 1, 2] {
+            let mut b = r.b.clone();
+            let fid = b.filter_exprs.len();
+            let scope = b.scopes.iter().position(|s| !s.filters.is_empty()).unwrap();
+            match kind {
+                0 => b.scopes[scope].filters.push(fid),
+                1 => b.scopes[scope].imports[0].filters.push(fid),
+                _ => b.scopes[scope].member_imports[0].filters.push(fid),
+            }
+            assert!(!b.valid_library(1));
+        }
+        let mut b = r.b.clone();
+        b.filters_active.clear();
+        assert!(!b.valid_library(1));
+    }
+
+    #[test]
+    fn filter_execution_restores_source_and_reentrancy_state() {
+        let id = "88888888-8888-4888-8888-888888888888";
+        let mut model = Model::new();
+        model.add_source("first.sysml", "package First;");
+        model.add_source("filter.sysml",&format!("package P {{ metadata def Actual; metadata def '{id}'; package Items {{ #Actual part def X; }} package View {{ filter @'{id}'; filter false and @missing; filter true or @missing; filter @missing; public import Items::*; }} }}"));
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let actual = r.resolve_qualified("P::Actual").unwrap();
+        let ordinary = r.resolve_qualified(&format!("P::'{id}'")).unwrap();
+        let sites = r.references_to(ordinary);
+        assert_eq!(sites.len(), 1);
+        let id = id.parse().unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(actual), id)]));
+        let mut hints =
+            HashMap::from([((r.element_id(sites[0].owner), sites[0].kind.clone()), id)]);
+        assert!(r.bind_id_spelled_references_with(&mut hints).contains(&id));
+        let x = r.resolve_qualified("P::Items::X").unwrap();
+        let view = r.resolve_qualified("P::View").unwrap();
+        let scope = *r.b.elem_scope.get(&view.0).unwrap();
+        let filters = r.b.scopes[scope].filters.clone();
+        assert_eq!(filters.len(), 4);
+        for origin in [None, Some(0)] {
+            r.b.identity_origin_unit = origin;
+            for (&fid, expected) in
+                filters
+                    .iter()
+                    .zip([Tri::True, Tri::False, Tri::True, Tri::Unknown])
+            {
+                assert_eq!(r.b.filter_verdict(fid, x.0, 0), expected);
+                assert!(!r.b.filters_active[fid]);
+                assert_eq!(r.b.identity_origin_unit, origin);
+                r.b.filters_active[fid] = true;
+                assert_eq!(r.b.filter_verdict(fid, x.0, 0), Tri::Unknown);
+                assert!(r.b.filters_active[fid]);
+                assert_eq!(r.b.identity_origin_unit, origin);
+                r.b.filters_active[fid] = false;
+                assert_eq!(
+                    r.b.filter_verdict(fid, x.0, MAX_RESOLUTION_DEPTH + 1),
+                    Tri::Unknown
+                );
+                assert_eq!(r.b.identity_origin_unit, origin);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod source_query_tests {
+    use super::*;
+    use crate::{
+        eval::{EvalError, Value},
+        model::Model,
+    };
+
+    #[test]
+    fn source_callbacks_restore_after_nesting_errors_and_panics() {
+        let mut m = Model::new();
+        m.add_source("a.sysml", "package A;");
+        m.add_source("b.sysml", "package B;");
+        let mut r = ResolvedModel::build(&m);
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        for prior in [None, Some(0), Some(1)] {
+            r.b.identity_origin_unit = prior;
+            let result: Result<(), ()> = r.with_source(a, |r| {
+                assert_eq!(r.b.identity_origin_unit, Some(0));
+                r.with_source(b, |r| assert_eq!(r.b.identity_origin_unit, Some(1)));
+                assert_eq!(r.b.identity_origin_unit, Some(0));
+                Err(())
+            });
+            assert!(result.is_err());
+            assert_eq!(r.b.identity_origin_unit, prior);
+            assert!(
+                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                    r.with_source(a, |r| r.with_source(b, |_| panic!("test unwind")))
+                }))
+                .is_err()
+            );
+            assert_eq!(r.b.identity_origin_unit, prior);
+        }
+    }
+
+    #[test]
+    fn value_chain_preserves_uncertainty_and_bounds_recursive_work() {
+        let mut m = Model::new();
+        m.add_source("model.sysml", "package P { part def T; }");
+        let mut r = ResolvedModel::build(&m);
+        let ty = r.resolve_qualified("P::T").unwrap();
+        let name = QualifiedName {
+            is_global: false,
+            segments: vec![Name {
+                value: "x".into(),
+                span: Default::default(),
+            }],
+            span: Default::default(),
+        };
+        let instance = |v| Value::Instance {
+            ty,
+            ty_name: "T".into(),
+            fields: vec![("x".into(), v)],
+        };
+        assert_eq!(
+            r.evaluate_value_chain(Value::Indeterminate, &[&name, &name]),
+            Ok(Value::Indeterminate)
+        );
+        assert_eq!(
+            r.evaluate_value_chain(instance(instance(Value::Integer(7))), &[&name, &name]),
+            Ok(Value::Integer(7))
+        );
+        let repeated = Value::Sequence(vec![
+            instance(Value::Integer(7)),
+            instance(Value::Integer(7)),
+        ]);
+        assert_eq!(
+            r.evaluate_value_chain(repeated, &[&name]),
+            Ok(Value::Integer(7))
+        );
+        let mut empty = name.clone();
+        empty.segments.clear();
+        assert!(matches!(
+            r.evaluate_value_chain(instance(Value::Integer(7)), &[&empty]),
+            Err(EvalError::Unsupported(_))
+        ));
+        let many = Value::Sequence((0..4000).map(|i| instance(Value::Integer(i))).collect());
+        assert!(matches!(
+            r.evaluate_value_chain(many, &[&name]),
+            Err(EvalError::Budget(_))
+        ));
+        let mut deep = Value::Integer(1);
+        for _ in 0..=crate::eval::MAX_CALL_DEPTH {
+            deep = Value::Quantity(Box::new(deep), crate::eval::Unit::from_dims(Vec::new()));
+        }
+        assert!(matches!(
+            r.evaluate_value_chain(instance(deep.clone()), &[&name]),
+            Err(EvalError::Budget(_))
+        ));
+        // An empty path performs no recursive work, even on a deep receiver.
+        assert_eq!(r.evaluate_value_chain(deep.clone(), &[]), Ok(deep));
+        assert_eq!(
+            r.evaluate_value_chain(instance(Value::Integer(8)), &[&name]),
+            Ok(Value::Integer(8))
+        );
+    }
+}
+
+#[cfg(test)]
+mod positional_member_tests {
+    use super::*;
+    use crate::model::Model;
+
+    fn resolved(name: &str, source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_source(name, source);
+        assert!(!model.has_errors(), "{source}");
+        ResolvedModel::build(&model)
+    }
+
+    /// A parameter takes members from what its position pairs it with, and
+    /// from nothing else that shares its name: not an element of an
+    /// enclosing namespace, not the parameter its owner inherits under the
+    /// same name at another position.
+    #[test]
+    fn a_parameter_inherits_no_namesake() {
+        for (name, source, parameter, namesake) in [
+            (
+                "functions.kerml",
+                "package P { datatype R;
+                     function rect { in re : R[1]; in im : R[1]; return : R[1]; }
+                     function re { in x : R[1]; return : R[1]; } }",
+                "P::rect::re",
+                "P::re::x",
+            ),
+            (
+                "parts.sysml",
+                "package P { part engine { attribute rpm; } calc def power { in engine; } }",
+                "P::power::engine",
+                "P::engine::rpm",
+            ),
+            (
+                "swapped.sysml",
+                "package P { part def P2 { attribute m2; }
+                     action def A { in p; in q : P2; }
+                     action def Swapped :> A { in q; in p; } }",
+                "P::Swapped::q",
+                "P::P2::m2",
+            ),
+        ] {
+            let mut r = resolved(name, source);
+            let parameter_ref = r.resolve_qualified(parameter).unwrap();
+            let namesake_ref = r.resolve_qualified(namesake).unwrap();
+            assert!(
+                !r.effective_features(parameter_ref, true)
+                    .contains(&namesake_ref),
+                "{parameter}"
+            );
+            let member = namesake.rsplit("::").next().unwrap();
+            assert_eq!(
+                r.resolve_qualified(&format!("{parameter}::{member}")),
+                None,
+                "{parameter}"
+            );
+        }
+    }
+
+    /// A parameter, a result and an end inherit the members of what their
+    /// position pairs them with — through a general that declares its own,
+    /// and through one that only inherits them.
+    #[test]
+    fn a_feature_inherits_the_members_of_what_it_redefines_by_position() {
+        let mut r = resolved(
+            "positions.sysml",
+            "package P {
+                 part def P1 { attribute m1; }
+                 part def P2 { attribute m2; }
+                 action def A { in p : P1; in q : P2; }
+                 action def Swapped :> A { in q; in p; }
+                 action def Renamed :> A { in x; in y; }
+                 action swappedUse : A { in q; in p; }
+                 action def Explicit :> A { in y :>> q; in x; }
+                 calc def C1 { in i; return r : P1; }
+                 calc def C2 :> C1 { return s; }
+                 calc def C3 :> C2;
+                 calc def C4 :> C3 { return t; }
+                 connection def Conn { end e1 : P1; end e2 : P2; }
+                 connection def Conn2 :> Conn { end f1; end f2; }
+                 connection def Conn3 :> Conn2;
+                 connection def Conn4 :> Conn3 { end g1; end g2; }
+                 requirement def R { subject sub : P1; }
+                 requirement def R2 :> R { subject t; in x; }
+             }",
+        );
+        let m1 = r.resolve_qualified("P::P1::m1").unwrap();
+        let m2 = r.resolve_qualified("P::P2::m2").unwrap();
+        for (feature, expected) in [
+            ("P::Swapped::q", m1),
+            ("P::Swapped::p", m2),
+            ("P::Renamed::x", m1),
+            ("P::Renamed::y", m2),
+            ("P::swappedUse::q", m1),
+            ("P::swappedUse::p", m2),
+            ("P::Explicit::x", m2),
+            ("P::Explicit::y", m1),
+            ("P::C2::s", m1),
+            ("P::C4::t", m1),
+            ("P::Conn2::f1", m1),
+            ("P::Conn2::f2", m2),
+            ("P::Conn4::g1", m1),
+            ("P::Conn4::g2", m2),
+            ("P::R2::t", m1),
+        ] {
+            let feature_ref = r.resolve_qualified(feature).unwrap();
+            let member = r.element_qualified_name(expected).unwrap();
+            let member = member.rsplit("::").next().unwrap();
+            assert_eq!(
+                r.resolve_qualified(&format!("{feature}::{member}")),
+                Some(expected),
+                "{feature}::{member}"
+            );
+            assert!(
+                r.effective_features(feature_ref, true).contains(&expected),
+                "{feature}"
+            );
+            assert!(
+                !r.effective_features(feature_ref, false).contains(&expected),
+                "{feature} inherits through an implied relationship"
+            );
+        }
+        assert_eq!(r.resolve_qualified("P::Swapped::q::m2"), None);
+        // A written redefinition keeps its members among the written
+        // heritage; the position adds the general's at the same index.
+        let y = r.resolve_qualified("P::Explicit::y").unwrap();
+        assert!(r.effective_features(y, false).contains(&m2));
+    }
+
+    /// A parameter reusing an inherited name at another position shadows
+    /// nothing, in lookup as in the inherited view: `Q::b` redefines `A::a`
+    /// by position, so `A::b` is still inherited beside it, and a name that
+    /// finds both is ambiguous.
+    #[test]
+    fn a_reused_parameter_name_shadows_nothing_in_lookup() {
+        let mut r = resolved(
+            "shadow.sysml",
+            "package P {
+                 action def A { in a; in b; }
+                 action def Q :> A { in b; }
+                 action def C :> Q, A;
+             }",
+        );
+        let q_b = r.resolve_qualified("P::Q::b").unwrap();
+        let a_b = r.resolve_qualified("P::A::b").unwrap();
+        let c = r.resolve_qualified("P::C").unwrap();
+        assert_eq!(r.resolve_qualified("P::C::b"), None);
+        // Ambiguous, not missing: both `b`s are found from `C`'s body.
+        let body = *r.b.elem_scope.get(&c.0).unwrap();
+        let b = QualifiedName {
+            is_global: false,
+            segments: vec![Name {
+                value: "b".to_string(),
+                span: Span::default(),
+            }],
+            span: Span::default(),
+        };
+        assert!(matches!(
+            r.b.resolve_result(body, &b, 0, false),
+            LookupResult::Ambiguous
+        ));
+        let features = r.effective_features(c, true);
+        assert!(features.contains(&q_b) && features.contains(&a_b));
+        let names: Vec<String> = r
+            .callable_parameters(c)
+            .unwrap()
+            .into_iter()
+            .map(|p| p.name)
+            .collect();
+        assert_eq!(names, ["b", "b"]);
+    }
 }
diff --git a/crates/sysmlv2-model/src/json/behavior.rs b/crates/sysmlv2-model/src/json/behavior.rs
index 9425e83..53df464 100644
--- a/crates/sysmlv2-model/src/json/behavior.rs
+++ b/crates/sysmlv2-model/src/json/behavior.rs
@@ -21,7 +21,7 @@
 //! compensated for rather than read literally: an accept action's
 //! trigger (`accept x at t`) is lowered as a TriggerInvocationExpression
 //! that is itself a parameter member, where the pilot's grammar makes it
-//! the payload parameter's value (API-GAPS issue 20) — it is not counted
+//! the payload parameter's value — it is not counted
 //! as an input parameter, and an accept's `payloadArgument` falls back to
 //! it.
 
@@ -130,13 +130,7 @@ impl ResolvedModel {
         }
         let m = self.b.elements[f.0].owning_relationship?;
         let ty = self.b.elements[m].ty;
-        if conforms(ty, "ReturnParameterMembership") {
-            Some("out")
-        } else if conforms(ty, "ParameterMembership") {
-            Some("in")
-        } else {
-            None
-        }
+        parameter_direction_default(ty)
     }
 
     /// `inputParameters() = input->select(f | f.owner = self)`: the owned
@@ -166,7 +160,7 @@ impl ResolvedModel {
     /// The argument an input parameter carries: its FeatureValue's value
     /// — or, for a trigger invocation's argument, which this lowering owns
     /// as the parameter itself without the Feature-and-FeatureValue
-    /// wrapper (API-GAPS issue 20), the expression that is the parameter.
+    /// wrapper, the expression that is the parameter.
     fn d_argument_of(&self, p: ElementRef) -> Option<ElementRef> {
         self.d_feature_value_of(p).or_else(|| {
             let owner = self.b.elements[p.0]
@@ -190,8 +184,7 @@ impl ResolvedModel {
 
     /// `AcceptActionUsage::payloadArgument = argument(1)`: the payload
     /// parameter's value, else the trigger this lowering owns beside the
-    /// payload (the pilot's grammar makes the trigger the payload's value;
-    /// API-GAPS issue 20).
+    /// payload (the pilot's grammar makes the trigger the payload's value).
     pub(super) fn d_accept_payload_argument(&self, e: ElementRef) -> Option<ElementRef> {
         self.d_argument(e, 1).or_else(|| {
             self.d_owned_features(e)
@@ -282,12 +275,40 @@ impl ResolvedModel {
 
     /// `Expression::result` / `Function::result`: the owned member
     /// parameter of the first ReturnParameterMembership (the inherited
-    /// result waits for the closure policy).
+    /// result waits for the closure policy). Operators use their library
+    /// Function's result even under passthrough. Supported scope-less literals
+    /// and metadata access inherit the actual semantic-library return identity.
     pub(super) fn d_result(&mut self, e: ElementRef) -> Option<ElementRef> {
-        self.d_feature_memberships(e)
+        if !self.b.elem_scope.contains_key(&e.0)
+            && super::implied::literal_implied_base(self.b.elements[e.0].ty).is_some()
+        {
+            let include_implied = self.closure_policy.include_implied()?;
+            let inherited = self.b.literal_inherited_memberships(e.0, include_implied);
+            if inherited.incomplete || inherited.truncated {
+                return None;
+            }
+            return self
+                .b
+                .literal_inherited_result(&inherited, &mut super::MembershipContext::default())
+                .map(ElementRef);
+        }
+        let result = self
+            .d_feature_memberships(e)
             .into_iter()
             .find(|&m| self.is_kind(m, "ReturnParameterMembership"))
-            .and_then(|m| self.d_owned_member_element(m))
+            .and_then(|m| self.d_owned_member_element(m));
+        if result.is_some() || self.element_type(e) != "OperatorExpression" {
+            return result;
+        }
+        // An operator specializes its library Function. Its return parameter
+        // remains a real reference even when passthrough emission leaves the
+        // inherited-member lists empty. A missing library/function/result is
+        // still unavailable, and no result identity is synthesized here.
+        let function = self.d_instantiated_type(e)?.element()?;
+        if self.element_type(function) != "Function" {
+            return None;
+        }
+        self.d_result(function)
     }
 
     /// The types of `e` of the given kind: `Expression::function`,
@@ -312,7 +333,10 @@ impl ResolvedModel {
     pub(super) fn d_instantiated_type(&mut self, e: ElementRef) -> Option<Reference> {
         self.ensure_by_id();
         if self.is_kind(e, "OperatorExpression") {
-            let operator = self.prop_str(e.0, "operator")?.to_string();
+            let operator = self.prop_str(e.0, "operator")?;
+            // The two exponentiation spellings share the normative '^'
+            // library endpoint (KerML 1.0, Table 5).
+            let operator = if operator == "**" { "^" } else { operator }.to_string();
             let candidates: Vec<(String, String)> =
                 ["BaseFunctions", "DataFunctions", "ControlFunctions"]
                     .iter()
@@ -376,6 +400,24 @@ impl ResolvedModel {
     /// reading.
     pub(super) fn d_arguments(&mut self, e: ElementRef) -> Vec<Reference> {
         self.ensure_by_id();
+        if self.b.graph_format == crate::model::GraphFormat::CanonicalV3
+            && self.is_kind(e, "ConstructorExpression")
+        {
+            // Omitted earlier features cannot hide a later supplied argument.
+            // Compatibility export uses the same complete ordering certificate;
+            // an empty fallback is explicitly uncertified when proof is absent.
+            return self
+                .constructor_binding_report(e)
+                .arguments
+                .map(|report| {
+                    report
+                        .bindings
+                        .into_iter()
+                        .map(|binding| Reference::Element(binding.value))
+                        .collect()
+                })
+                .unwrap_or_default();
+        }
         let params = self.d_input_parameters(e);
         let callee = self.d_instantiated_type(e);
         let targets: Vec<ElementRef> = match callee {
@@ -558,6 +600,17 @@ impl ResolvedModel {
             .find(|&m| self.is_kind(m, "ConjugatedPortDefinition"))
     }
 
+    /// `ConjugatedPortTyping::portDefinition =
+    /// conjugatedPortDefinition.originalPortDefinition`.
+    pub(super) fn d_typing_port_definition(&mut self, e: ElementRef) -> Option<ElementRef> {
+        // The owned reader accepts inherited storage aliases and validates
+        // the target kind before following the conjugated definition's owner.
+        let target = self.property(e, "conjugatedPortDefinition").ok()?;
+        let conjugated = self.element_by_id(target.get("@id")?.as_str()?)?;
+        self.d_owning_namespace(conjugated)
+            .filter(|&original| self.is_kind(original, "PortDefinition"))
+    }
+
     // ---- helpers ----
 
     /// A kind test on a reference: an element of the model passes when
@@ -584,3 +637,14 @@ impl ResolvedModel {
             .unwrap_or(false)
     }
 }
+
+/// Normative ParameterMembership direction defaults shared with checked readers.
+pub(super) fn parameter_direction_default(kind: &str) -> Option<&'static str> {
+    if conforms(kind, "ReturnParameterMembership") {
+        Some("out")
+    } else if conforms(kind, "ParameterMembership") {
+        Some("in")
+    } else {
+        None
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/callable_bodies.rs b/crates/sysmlv2-model/src/json/callable_bodies.rs
new file mode 100644
index 0000000..8084a7c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/callable_bodies.rs
@@ -0,0 +1,190 @@
+//! The result an invocation of a callable evaluates: its own, or one its
+//! written heritage declares.
+use super::{Builder, ElementRef, ResolvedModel, ScopeRef};
+use std::collections::HashSet;
+use sysmlv2_syntax::ast::Expr;
+
+/// How a callable declares its result.
+#[derive(Clone, Debug, PartialEq)]
+pub enum CallableResult {
+    /// A trailing result expression, written in `scope`.
+    Expression {
+        /// The scope the expression is written in.
+        scope: ScopeRef,
+        /// The expression.
+        expression: Expr,
+    },
+    /// A return parameter bound to a value (`return r = a - b;`).
+    Parameter(ElementRef),
+}
+
+/// The result an invocation of a callable evaluates (see
+/// [`ResolvedModel::callable_body`]).
+#[derive(Clone, Debug, PartialEq)]
+pub enum CallableBody {
+    /// The result and the callable that declares it: the callee itself, or
+    /// the nearest callable in its written heritage that declares one.
+    Declared {
+        /// The callable that declares the result.
+        owner: ElementRef,
+        /// The result it declares.
+        result: CallableResult,
+    },
+    /// Different callables equally near the callee each declare a result.
+    Ambiguous(Vec<ElementRef>),
+}
+
+/// A function or calculation-family metaclass: what an invocation applies.
+pub(crate) fn calculation_like(ty: &str) -> bool {
+    ty.contains("Calculation")
+        || ty.contains("Constraint")
+        || ty.contains("Expression")
+        || ty == "Function"
+        || ty == "Predicate"
+}
+
+impl Builder {
+    /// The result `callable` declares itself.
+    pub(crate) fn own_callable_result(&self, callable: usize) -> Option<CallableResult> {
+        if let Some((_, scope, expression)) =
+            self.result_exprs.iter().find(|(o, _, _)| *o == callable)
+        {
+            return Some(CallableResult::Expression {
+                scope: ScopeRef(*scope),
+                expression: expression.clone(),
+            });
+        }
+        let &ret = self.return_params.get(&callable)?;
+        self.values
+            .contains_key(&ret)
+            .then_some(CallableResult::Parameter(ElementRef(ret)))
+    }
+
+    /// See [`ResolvedModel::callable_body`]; statement execution is the
+    /// caller's to refuse.
+    pub(crate) fn callable_body(&mut self, callee: usize) -> Option<CallableBody> {
+        if let Some(result) = self.own_callable_result(callee) {
+            return Some(CallableBody::Declared {
+                owner: ElementRef(callee),
+                result,
+            });
+        }
+        if !calculation_like(self.elements[callee].ty) || self.is_parameter(callee) {
+            return None;
+        }
+        let mut seen = HashSet::from([callee]);
+        let mut level = vec![callee];
+        while !level.is_empty() {
+            let mut next = Vec::new();
+            for e in level {
+                for general in self.explicit_supertype_elems(e) {
+                    if seen.insert(general) {
+                        next.push(general);
+                    }
+                }
+            }
+            let mut declared: Vec<_> = next
+                .iter()
+                .filter_map(|&general| Some((general, self.own_callable_result(general)?)))
+                .collect();
+            match declared.len() {
+                0 => level = next,
+                1 => {
+                    let (owner, result) = declared.remove(0);
+                    return Some(CallableBody::Declared {
+                        owner: ElementRef(owner),
+                        result,
+                    });
+                }
+                _ => {
+                    return Some(CallableBody::Ambiguous(
+                        declared
+                            .into_iter()
+                            .map(|(owner, _)| ElementRef(owner))
+                            .collect(),
+                    ));
+                }
+            }
+        }
+        None
+    }
+}
+
+impl ResolvedModel {
+    /// The result an invocation of `callee` evaluates: the trailing result
+    /// expression or bound return parameter it declares, else — for a
+    /// calculation-family definition or usage — the nearest one its written
+    /// heritage declares, breadth-first: a usage's definition's, a
+    /// definition's general's. Evaluate an inherited result in the callee's
+    /// context, where its arguments stand for the parameters they redefine.
+    /// A function-typed parameter stands for an unknown calculation and
+    /// inherits none. `None` when no result is declared, or the callee's
+    /// body requires statement execution.
+    pub fn callable_body(&mut self, callee: ElementRef) -> Option<CallableBody> {
+        if self.b.calculation_requires_execution(callee.0) {
+            return None;
+        }
+        self.b.callable_body(callee.0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+
+    #[test]
+    fn a_callable_without_a_result_takes_the_nearest_one_written() {
+        let mut model = Model::new();
+        model.add_source(
+            "bodies.sysml",
+            "calc def Diff { in a; in b; return r = a - b; }
+             calc def Sum { in a; in b; a + b }
+             calc def D3 :> Diff { in x; }
+             calc def Deeper :> D3;
+             calc def Own :> Diff { in x; x * 2 }
+             calc typed : Sum;
+             calc def Both :> Diff, Sum;
+             calc def Holder { in fn : Diff; in g : Sum; }
+             calc def Empty { in x; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let diff = r.resolve_qualified("Diff").unwrap();
+        let sum = r.resolve_qualified("Sum").unwrap();
+        let ret = r.resolve_qualified("Diff::r").unwrap();
+        for (name, owner) in [("D3", diff), ("Deeper", diff), ("Diff", diff)] {
+            let callee = r.resolve_qualified(name).unwrap();
+            assert_eq!(
+                r.callable_body(callee),
+                Some(CallableBody::Declared {
+                    owner,
+                    result: CallableResult::Parameter(ret),
+                }),
+                "{name}"
+            );
+        }
+        let typed = r.resolve_qualified("typed").unwrap();
+        assert!(matches!(
+            r.callable_body(typed),
+            Some(CallableBody::Declared {
+                owner,
+                result: CallableResult::Expression { .. },
+            }) if owner == sum
+        ));
+        let own = r.resolve_qualified("Own").unwrap();
+        assert!(matches!(
+            r.callable_body(own),
+            Some(CallableBody::Declared { owner, .. }) if owner == own
+        ));
+        let both = r.resolve_qualified("Both").unwrap();
+        assert_eq!(
+            r.callable_body(both),
+            Some(CallableBody::Ambiguous(vec![diff, sum]))
+        );
+        for name in ["Holder::fn", "Holder::g", "Empty"] {
+            let callee = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.callable_body(callee), None, "{name}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/cardinality.rs b/crates/sysmlv2-model/src/json/cardinality.rs
new file mode 100644
index 0000000..f151c0b
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/cardinality.rs
@@ -0,0 +1,1612 @@
+//! Checked multiplicity constraints and collection questions over shared evidence.
+use super::{
+    Builder, ElementRef, ResolvedModel, membership_evidence,
+    semantic::certified_types::Stamp,
+    semantic_ownership,
+    structural_index::StoredStructure,
+    type_relations::{self, TypeRelations},
+};
+use crate::metaclass::conforms;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+/// An exact integer interval. An absent upper limit denotes infinity.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CardinalityBounds {
+    pub lower: i128,
+    pub upper: Option<i128>,
+}
+impl CardinalityBounds {
+    /// Exact collection size, when the complete interval is a singleton.
+    pub fn size(self) -> Option<i128> {
+        (self.upper == Some(self.lower)).then_some(self.lower)
+    }
+    /// A proved emptiness answer; an interval containing zero and positive
+    /// counts does not establish either answer.
+    pub fn is_empty(self) -> Option<bool> {
+        if self.upper == Some(0) {
+            Some(true)
+        } else if self.lower > 0 {
+            Some(false)
+        } else {
+            None
+        }
+    }
+    /// Proved validity of a one-based index. A possibly present position is unknown.
+    pub fn contains_index(self, index: i128) -> Option<bool> {
+        if index <= 0 || self.upper.is_some_and(|upper| index > upper) {
+            Some(false)
+        } else if index <= self.lower {
+            Some(true)
+        } else {
+            None
+        }
+    }
+}
+/// Why a complete supported multiplicity domain could not be established.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum CardinalityIssue {
+    InvalidElement,
+    InvalidRelationship,
+    IncompleteProvider,
+    UnsupportedBound,
+    CyclicDependency,
+    ConflictingConstraints,
+    StaleEvidence,
+    WorkLimit,
+}
+/// Checked cardinality constraints. This proves bounds, not concrete members,
+/// whole-model conformance, or the value of an arbitrary collection expression.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct CardinalityReport {
+    pub bounds: Result<CardinalityBounds, CardinalityIssue>,
+    /// Range or named Multiplicity identities contributing to the answer.
+    pub multiplicities: Vec<ElementRef>,
+    /// Structural Usage identities supplying the normative implicit singleton.
+    pub implicit_singletons: Vec<ElementRef>,
+    pub steps: usize,
+}
+fn charge(steps: &mut usize, amount: usize) -> Result<(), CardinalityIssue> {
+    *steps = steps.saturating_add(amount);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(CardinalityIssue::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+impl ResolvedModel {
+    /// Prove supported Type multiplicities using reciprocal owned membership,
+    /// complete shared specialization evidence and exact receiver-aware bounds.
+    /// Owned multiplicities stop inheritance, as in Type::multiplicities. When
+    /// several inherited constraints apply their numeric domains intersect;
+    /// incompatible constraints are errors, never an empty collection. Unlike
+    /// the compatibility evaluator, missing semantic providers cannot establish
+    /// an unconstrained default. Unsupported expressions remain qualified.
+    pub fn cardinality_report(&mut self, receiver: ElementRef) -> CardinalityReport {
+        self.cardinality_report_with_budget(receiver, 0)
+    }
+    /// Add cardinalities of a flat or nested sequence without pretending that
+    /// one symbolic collection placeholder denotes one member. Closed reflection
+    /// elements remain single declarations. Unknown receiver members stay qualified
+    /// because their placeholder does not retain the outer receiver cardinality.
+    pub fn collection_cardinality_report(
+        &mut self,
+        value: &crate::eval::Value,
+    ) -> CardinalityReport {
+        fn visit(
+            r: &mut ResolvedModel,
+            value: &crate::eval::Value,
+            depth: usize,
+            steps: &mut usize,
+            domains: &mut Vec<ElementRef>,
+            defaults: &mut Vec<ElementRef>,
+            stamp: &mut Option<Stamp>,
+        ) -> Result<CardinalityBounds, CardinalityIssue> {
+            use crate::eval::Value;
+            charge(steps, 1)?;
+            if depth >= 64 {
+                return Err(CardinalityIssue::WorkLimit);
+            }
+            match value {
+                Value::Indeterminate | Value::UnboundMember(_) => {
+                    Err(CardinalityIssue::IncompleteProvider)
+                }
+                Value::Unbound(element) => {
+                    let report = r.cardinality_report_with_budget(*element, *steps);
+                    *steps = report.steps;
+                    let bounds = report.bounds?;
+                    if stamp.as_ref().is_some_and(|previous| !previous.current(r)) {
+                        return Err(CardinalityIssue::StaleEvidence);
+                    }
+                    if stamp.is_none() {
+                        *stamp = Some(Stamp::capture(r));
+                    }
+                    domains.extend(report.multiplicities);
+                    defaults.extend(report.implicit_singletons);
+                    Ok(bounds)
+                }
+                Value::Sequence(items) => {
+                    charge(steps, items.len())?;
+                    let mut bounds = CardinalityBounds {
+                        lower: 0,
+                        upper: Some(0),
+                    };
+                    for item in items {
+                        let next = visit(r, item, depth + 1, steps, domains, defaults, stamp)?;
+                        bounds.lower = bounds
+                            .lower
+                            .checked_add(next.lower)
+                            .ok_or(CardinalityIssue::UnsupportedBound)?;
+                        bounds.upper = match (bounds.upper, next.upper) {
+                            (Some(a), Some(b)) => {
+                                Some(a.checked_add(b).ok_or(CardinalityIssue::UnsupportedBound)?)
+                            }
+                            _ => None,
+                        };
+                    }
+                    Ok(bounds)
+                }
+                _ => Ok(CardinalityBounds {
+                    lower: 1,
+                    upper: Some(1),
+                }),
+            }
+        }
+        let mut steps = 0;
+        let mut multiplicities = Vec::new();
+        let mut implicit_singletons = Vec::new();
+        let bounds = visit(
+            self,
+            value,
+            0,
+            &mut steps,
+            &mut multiplicities,
+            &mut implicit_singletons,
+            &mut None,
+        );
+        if bounds.is_err() {
+            multiplicities.clear();
+            implicit_singletons.clear();
+        }
+        CardinalityReport {
+            bounds,
+            multiplicities,
+            implicit_singletons,
+            steps,
+        }
+    }
+    fn cardinality_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> CardinalityReport {
+        let mut steps = initial;
+        let mut multiplicities = Vec::new();
+        let mut implicit_singletons = Vec::new();
+        let mut bounds = (|| {
+            if !self
+                .b
+                .elements
+                .get(receiver.0)
+                .is_some_and(|e| conforms(e.ty, "Type"))
+            {
+                return Err(CardinalityIssue::InvalidElement);
+            }
+            // Shared preparation precedes the stamp; readers never publish a
+            // competing graph or retain a partial proof across a mutation.
+            if !self
+                .b
+                .ensure_positional_redefinitions_with_budget(&mut steps)
+            {
+                return Err(CardinalityIssue::IncompleteProvider);
+            }
+            let raw = StoredStructure::for_query(&mut self.b, &mut steps)
+                .ok_or(CardinalityIssue::IncompleteProvider)?;
+            if !raw.ids_unique
+                || raw.annotations_incomplete
+                || self.b.metadata_associations_incomplete
+            {
+                return Err(CardinalityIssue::IncompleteProvider);
+            }
+            let context = self.b.owner_scope_of(receiver.0);
+            let mut reader = Reader {
+                raw,
+                relations: TypeRelations::default(),
+                active: HashSet::new(),
+                known: HashMap::new(),
+                domains: HashSet::new(),
+                expressions: HashSet::new(),
+                universal_relationships: HashSet::new(),
+                steps: &mut steps,
+            };
+            let result = reader.constraints(&mut self.b, receiver.0, 0)?;
+            let stamp = Stamp::capture(self);
+            charge(reader.steps, result.len())?;
+            for &domain in &result {
+                if let Constraint::Range(domain) = domain {
+                    reader.validate_domain(&mut self.b, domain, 0)?;
+                }
+            }
+            let expressions = std::mem::take(&mut reader.expressions);
+            let universal_relationships = std::mem::take(&mut reader.universal_relationships);
+            drop(reader);
+            let mut operators = certified_operators(self, &expressions, context, &mut steps)?;
+            operators.universal_relationships = universal_relationships;
+            let mut bounds = CardinalityBounds {
+                lower: 0,
+                upper: None,
+            };
+            for domain in result {
+                let (lower, upper) = match domain {
+                    Constraint::Range(domain) => {
+                        multiplicities.push(ElementRef(domain));
+                        crate::eval::checked_multiplicity_domain(
+                            &mut self.b,
+                            domain,
+                            context,
+                            &operators,
+                            &mut steps,
+                        )
+                        .ok_or(CardinalityIssue::UnsupportedBound)?
+                    }
+                    Constraint::Singleton(feature) => {
+                        implicit_singletons.push(ElementRef(feature));
+                        (1, Some(1))
+                    }
+                };
+                bounds.lower = bounds.lower.max(lower);
+                bounds.upper = match (bounds.upper, upper) {
+                    (Some(a), Some(b)) => Some(a.min(b)),
+                    (a, b) => a.or(b),
+                };
+                if bounds.upper.is_some_and(|upper| bounds.lower > upper) {
+                    return Err(CardinalityIssue::ConflictingConstraints);
+                }
+            }
+            if !stamp.current(self) {
+                return Err(CardinalityIssue::StaleEvidence);
+            }
+            Ok(bounds)
+        })();
+        if steps > crate::eval::MAX_STEPS {
+            bounds = Err(CardinalityIssue::WorkLimit);
+        }
+        if bounds.is_err() {
+            multiplicities.clear();
+            implicit_singletons.clear();
+        }
+        CardinalityReport {
+            bounds,
+            multiplicities,
+            implicit_singletons,
+            steps,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Constraint {
+    Range(usize),
+    Singleton(usize),
+}
+struct Reader<'a> {
+    raw: Arc<StoredStructure>,
+    relations: TypeRelations,
+    active: HashSet<usize>,
+    known: HashMap<usize, Vec<Constraint>>,
+    domains: HashSet<usize>,
+    expressions: HashSet<usize>,
+    universal_relationships: HashSet<usize>,
+    steps: &'a mut usize,
+}
+impl Reader<'_> {
+    fn members(&mut self, b: &Builder, owner: usize) -> Result<Vec<usize>, CardinalityIssue> {
+        charge(self.steps, 1)?;
+        if !self.raw.is_current(b) || self.raw.metadata_annotation_targets.contains(&owner) {
+            return Err(CardinalityIssue::IncompleteProvider);
+        }
+        let domains = self
+            .raw
+            .membership_domains(b, self.steps)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        if !domains.owner_complete(owner) {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let relationships = semantic_ownership::owned_relationships(b, owner)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        charge(self.steps, relationships.len())?;
+        let mut result = Vec::new();
+        let mut seen = HashSet::new();
+        for relationship in relationships.iter() {
+            if !seen.insert(relationship) {
+                return Err(CardinalityIssue::InvalidRelationship);
+            }
+            let relation = b
+                .elements
+                .get(relationship)
+                .ok_or(CardinalityIssue::InvalidRelationship)?;
+            if conforms(relation.ty, "Membership") {
+                let member =
+                    membership_evidence::member(b, &self.raw, owner, relationship, self.steps)
+                        .ok_or(CardinalityIssue::InvalidRelationship)?;
+                if conforms(relation.ty, "OwningMembership") {
+                    result.push(member);
+                }
+            }
+        }
+        Ok(result)
+    }
+    fn constraints(
+        &mut self,
+        b: &mut Builder,
+        owner: usize,
+        depth: usize,
+    ) -> Result<Vec<Constraint>, CardinalityIssue> {
+        charge(self.steps, 1)?;
+        if depth >= 64 || !self.active.insert(owner) {
+            return Err(CardinalityIssue::CyclicDependency);
+        }
+        if let Some(known) = self.known.get(&owner) {
+            charge(self.steps, known.len())?;
+            self.active.remove(&owner);
+            return Ok(known.clone());
+        }
+        let owned: Vec<_> = self
+            .members(b, owner)?
+            .into_iter()
+            .filter(|&e| conforms(b.elements[e].ty, "Multiplicity"))
+            .collect();
+        if owned.len() > 1 {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let mut result: Vec<_> = owned.into_iter().map(Constraint::Range).collect();
+        if result.is_empty() && self.implicit_singleton(b, owner)? {
+            result.push(Constraint::Singleton(owner));
+        }
+        if result.is_empty() {
+            let bases = self
+                .relations
+                .complete_direct_bases(b, owner, self.steps)
+                .ok_or(CardinalityIssue::IncompleteProvider)?;
+            let mut seen = HashSet::new();
+            for base in bases {
+                for domain in self.constraints(b, base, depth + 1)? {
+                    charge(self.steps, 1)?;
+                    if seen.insert(domain) {
+                        result.push(domain);
+                    }
+                }
+            }
+        }
+        self.active.remove(&owner);
+        charge(self.steps, result.len())?;
+        self.known.insert(owner, result.clone());
+        Ok(result)
+    }
+    fn implicit_singleton(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+    ) -> Result<bool, CardinalityIssue> {
+        if b.default_cardinality(feature) != (1, Some(1)) {
+            return Ok(false);
+        }
+        let membership = b.elements[feature]
+            .owning_relationship
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        let owner =
+            semantic_ownership::checked_relationship_carrier(b, &self.raw, membership, self.steps)
+                .flatten()
+                .ok_or(CardinalityIssue::InvalidRelationship)?;
+        if !conforms(b.elements[membership].ty, "FeatureMembership")
+            || membership_evidence::member(b, &self.raw, owner, membership, self.steps)
+                != Some(feature)
+            || self.raw.metadata_annotation_targets.contains(&owner)
+        {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let domains = self
+            .raw
+            .membership_domains(b, self.steps)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        if !domains.owner_complete(owner) {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let typing = self
+            .raw
+            .typing(b, self.steps)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        if typing.sources_incomplete {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let relationships = typing
+            .relationships
+            .get(&feature)
+            .map_or(&[][..], Vec::as_slice);
+        charge(self.steps, relationships.len())?;
+        // Owned authored subsettings suppress the textual/default singleton.
+        // The generated static suffix is not an authored declaration, and an
+        // authored isImplied flag cannot impersonate that provenance.
+        for &relationship in relationships {
+            if relationship < b.explicit_len()
+                && conforms(b.elements[relationship].ty, "Subsetting")
+            {
+                return Ok(false);
+            }
+        }
+        Ok(true)
+    }
+    fn validate_domain(
+        &mut self,
+        b: &mut Builder,
+        owner: usize,
+        depth: usize,
+    ) -> Result<(), CardinalityIssue> {
+        charge(self.steps, 1)?;
+        if depth >= 64 || !self.domains.insert(owner) {
+            return Err(CardinalityIssue::CyclicDependency);
+        }
+        if !conforms(b.elements[owner].ty, "Multiplicity") {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let members = self.members(b, owner)?;
+        if b.elements[owner].ty == "MultiplicityRange" {
+            let bounds: Vec<_> = members
+                .iter()
+                .copied()
+                .take_while(|&member| conforms(b.elements[member].ty, "Expression"))
+                .collect();
+            if !(1..=2).contains(&bounds.len())
+                || members[bounds.len()..]
+                    .iter()
+                    .any(|&member| conforms(b.elements[member].ty, "Expression"))
+            {
+                return Err(CardinalityIssue::InvalidRelationship);
+            }
+            for (key, expected) in [
+                ("lowerBound", (bounds.len() == 2).then_some(bounds[0])),
+                ("upperBound", bounds.last().copied()),
+            ] {
+                if let Some(value) = b.elements[owner].props.get(key) {
+                    if match expected {
+                        Some(expected) => value.as_reference() != Some(b.elements[expected].id),
+                        None => !value.is_null(),
+                    } {
+                        return Err(CardinalityIssue::InvalidRelationship);
+                    }
+                }
+            }
+            if let Some(value) = b.elements[owner].props.get("bound") {
+                let values = value
+                    .as_array()
+                    .ok_or(CardinalityIssue::InvalidRelationship)?;
+                charge(self.steps, values.len())?;
+                if values.len() != bounds.len()
+                    || values.iter().zip(&bounds).any(|(value, &expected)| {
+                        value.as_reference() != Some(b.elements[expected].id)
+                    })
+                {
+                    return Err(CardinalityIssue::InvalidRelationship);
+                }
+            }
+        }
+        for member in members {
+            if conforms(b.elements[member].ty, "Expression") {
+                match b.elements[member].ty {
+                    "LiteralInteger" | "LiteralInfinity" => {
+                        // Literal syntax has no payload relationships; imported
+                        // relationship-bearing forms need their own proof.
+                        if !b.elements[member].owned_relationships.is_empty() {
+                            return Err(CardinalityIssue::UnsupportedBound);
+                        }
+                    }
+                    _ => {
+                        self.expressions.insert(member);
+                    }
+                }
+            }
+        }
+        let typing = self
+            .raw
+            .typing(b, self.steps)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        if typing.sources_incomplete {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        let relationships = semantic_ownership::owned_relationships(b, owner)
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+        charge(self.steps, relationships.len())?;
+        let relationships: Vec<_> = relationships.iter().collect();
+        let mut seen = HashSet::new();
+        for relationship in relationships {
+            if !seen.insert(relationship) {
+                return Err(CardinalityIssue::InvalidRelationship);
+            }
+            let kind = b
+                .elements
+                .get(relationship)
+                .ok_or(CardinalityIssue::InvalidRelationship)?
+                .ty;
+            if !conforms(kind, "Specialization") {
+                continue;
+            }
+            if !matches!(kind, "Subsetting" | "Redefinition") {
+                return Err(CardinalityIssue::IncompleteProvider);
+            }
+            if semantic_ownership::checked_relationship_carrier(
+                b,
+                &self.raw,
+                relationship,
+                self.steps,
+            ) != Some(Some(owner))
+            {
+                return Err(CardinalityIssue::InvalidRelationship);
+            }
+            if !b.static_chain_row_current(relationship)
+                || !b.result_redefinition_row_current(relationship)
+                || !b.dynamic_evidence_current(owner)
+            {
+                return Err(CardinalityIssue::StaleEvidence);
+            }
+            let target = type_relations::endpoint(
+                b,
+                owner,
+                relationship,
+                &["specific", "subsettingFeature", "redefiningFeature"],
+                &["general", "subsettedFeature", "redefinedFeature"],
+                "Feature",
+                self.steps,
+            )
+            .ok_or(CardinalityIssue::InvalidRelationship)?;
+            if conforms(b.elements[target].ty, "Multiplicity") {
+                self.validate_domain(b, target, depth + 1)?;
+            } else if kind == "Subsetting"
+                && self.relations.library_role(b, "Base::things", self.steps) == Some(target)
+            {
+                // Every Feature subsets the universal library feature. This
+                // checked identity adds no integer-domain constraint; unrelated
+                // non-Multiplicity targets are not silently discarded.
+                self.universal_relationships.insert(relationship);
+            } else {
+                return Err(CardinalityIssue::InvalidRelationship);
+            }
+        }
+        if typing
+            .relationships
+            .get(&owner)
+            .is_some_and(|incoming| incoming.iter().any(|r| !seen.contains(r)))
+        {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        self.domains.remove(&owner);
+        Ok(())
+    }
+}
+
+impl Builder {
+    /// Preserve the compatibility candidate order, but certify every membership
+    /// and its inverse domain before it can establish absence of a redefinition.
+    pub(crate) fn cardinality_feature_candidates(
+        &mut self,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        let scope = *self.elem_scope.get(&e)?;
+        let inherited = self.inherited_bindings(scope, true);
+        if inherited.incomplete || inherited.truncated || self.recorded_lookup_incomplete {
+            return None;
+        }
+        let raw = StoredStructure::for_query(self, steps)?;
+        let domains = raw.membership_domains(self, steps)?;
+        if !raw.ids_unique || !domains.owner_complete(e) {
+            return None;
+        }
+        let own = semantic_ownership::owned_relationships(self, e)?;
+        charge(
+            steps,
+            own.len().saturating_add(inherited.membership_order.len()),
+        )
+        .ok()?;
+        let relationships: Vec<_> = own
+            .iter()
+            .chain(inherited.membership_order.iter().copied())
+            .collect();
+        let mut out = Vec::new();
+        let mut seen = HashSet::new();
+        for relationship in relationships {
+            if !super::is_feature_membership(self.elements.get(relationship)?.ty) {
+                continue;
+            }
+            let owner =
+                semantic_ownership::checked_relationship_carrier(self, &raw, relationship, steps)??;
+            if !domains.owner_complete(owner) {
+                return None;
+            }
+            let member = membership_evidence::member(self, &raw, owner, relationship, steps)?;
+            if !conforms(self.elements[member].ty, "Feature") {
+                return None;
+            }
+            if seen.insert(member) {
+                out.push(member);
+            }
+        }
+        Some(out)
+    }
+    /// Complete raw inverse domain plus reciprocal, typed endpoint evidence.
+    /// Stored isImplied flags never exempt authored rows from certification.
+    fn cardinality_edges(
+        &mut self,
+        e: usize,
+        redefinitions_only: bool,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if !self.dynamic_evidence_current(e) || !self.result_redefinition_evidence_current(e) {
+            return None;
+        }
+        let raw = StoredStructure::for_query(self, steps)?;
+        if !raw.ids_unique || !raw.is_current(self) {
+            return None;
+        }
+        let typing = raw.typing(self, steps)?;
+        if typing.sources_incomplete {
+            return None;
+        }
+        let own = semantic_ownership::owned_relationships(self, e)?;
+        let incoming = typing.relationships.get(&e).map_or(&[][..], Vec::as_slice);
+        charge(
+            steps,
+            own.len().saturating_mul(2).saturating_add(incoming.len()),
+        )
+        .ok()?;
+        let authored_owned_subsets = own
+            .iter()
+            .filter(|&relationship| {
+                relationship < self.explicit_len()
+                    && conforms(self.elements[relationship].ty, "Subsetting")
+            })
+            .count();
+        let relationships: Vec<_> = own.iter().chain(incoming.iter().copied()).collect();
+        let mut seen = HashSet::new();
+        let mut targets = Vec::new();
+        for relationship in relationships {
+            if !seen.insert(relationship) {
+                continue;
+            }
+            let kind = self.elements.get(relationship)?.ty;
+            if !conforms(kind, "Subsetting") || (redefinitions_only && kind != "Redefinition") {
+                continue;
+            }
+            if !matches!(kind, "Subsetting" | "Redefinition") {
+                return None;
+            }
+            if !self.static_chain_row_current(relationship)
+                || !self.result_redefinition_row_current(relationship)
+            {
+                return None;
+            }
+            let carrier =
+                semantic_ownership::checked_relationship_carrier(self, &raw, relationship, steps)?;
+            let target = type_relations::endpoint_with_carrier(
+                self,
+                e,
+                carrier,
+                relationship,
+                &["specific", "subsettingFeature", "redefiningFeature"],
+                &["general", "subsettedFeature", "redefinedFeature"],
+                "Feature",
+                steps,
+            )?;
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        self.ensure_spec_index();
+        let mut recorded_subsets = 0;
+        let mut recorded_targets = Vec::new();
+        if let Some(indices) = self.spec_index.as_ref()?.get(&e) {
+            charge(steps, indices.len()).ok()?;
+            for &index in indices {
+                let kind = self.spec_targets[index].1;
+                if matches!(kind, "Subsetting" | "Redefinition")
+                    && (!redefinitions_only || kind == "Redefinition")
+                {
+                    recorded_subsets += 1;
+                    let recorded = self.spec_resolved.get(index).copied().flatten()?;
+                    if !targets.contains(&recorded) {
+                        return None;
+                    }
+                    if !redefinitions_only {
+                        charge(steps, recorded_targets.len()).ok()?;
+                        if !recorded_targets.contains(&recorded) {
+                            recorded_targets.push(recorded);
+                        }
+                    }
+                }
+            }
+        }
+        // Compatibility Feature-cardinality reads admit the recorded authored
+        // specialization domain. In particular, a named Multiplicity's numeric
+        // subsettings are not evidence for its own Feature cardinality. Keep
+        // those unrecorded authored forms unknown even after raw certification;
+        // centrally published relationships have their separate freshness proof.
+        // Positional targets are applied separately, after structural singleton
+        // defaults. Publishing them must not move them before that precedence.
+        if !redefinitions_only && authored_owned_subsets != recorded_subsets {
+            return None;
+        }
+        Some(if redefinitions_only {
+            targets
+        } else {
+            recorded_targets
+        })
+    }
+    pub(crate) fn cardinality_subset_targets(
+        &mut self,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        self.cardinality_edges(e, false, steps)
+    }
+    pub(crate) fn cardinality_redefinition_targets(
+        &mut self,
+        e: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        let mut targets = self.cardinality_edges(e, true, steps)?;
+        if (self.is_parameter(e)
+            || self.elements[e]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true))
+            && self.effective_positional_redefinitions().is_none()
+            && !self.ensure_positional_redefinitions_with_budget(steps)
+        {
+            return None;
+        }
+        let positional = self.completed_positional_targets(e)?;
+        charge(steps, positional.len()).ok()?;
+        for &target in positional {
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        Some(targets)
+    }
+}
+
+/// Collect only current graph operands from the shared checked invocation
+/// provider. Recorded source syntax is not evidence after an imported row edit.
+fn certified_operators(
+    r: &mut ResolvedModel,
+    roots: &HashSet<usize>,
+    context: Option<usize>,
+    steps: &mut usize,
+) -> Result<crate::eval::CheckedMultiplicityExpressions, CardinalityIssue> {
+    use sysmlv2_syntax::ast::BinaryOp;
+    charge(steps, roots.len())?;
+    let mut pending: Vec<_> = roots.iter().copied().collect();
+    let mut seen = HashSet::new();
+    let mut contextual_features: Option<(HashSet<usize>, HashSet<usize>)> = None;
+    let mut operators = crate::eval::CheckedMultiplicityExpressions::default();
+    let raw =
+        StoredStructure::for_query(&mut r.b, steps).ok_or(CardinalityIssue::IncompleteProvider)?;
+    while let Some(expression) = pending.pop() {
+        charge(steps, 1)?;
+        if !seen.insert(expression) {
+            continue;
+        }
+        if raw.metadata_annotation_targets.contains(&expression)
+            || r.b
+                .metadata_of
+                .get(&expression)
+                .is_some_and(|m| !m.is_empty())
+        {
+            return Err(CardinalityIssue::IncompleteProvider);
+        }
+        // Contextual references follow FeatureReferenceExpression::evaluate(target),
+        // not its separate model-level classification. Other expression kinds
+        // retain the existing model-level admission requirement.
+        if r.b.elements[expression].ty != "FeatureReferenceExpression" {
+            require_model_level_value(r, expression, steps)?;
+        }
+        match r.b.elements[expression].ty {
+            "LiteralInteger" | "LiteralInfinity" => continue,
+            "FeatureReferenceExpression" => {
+                certify_reference_domain(&r.b, &raw, expression, steps)?;
+                // The referenced Feature is the first non-parameter member,
+                // matching the shared model-level rule. A published result is
+                // a ParameterMembership, not another reference target.
+                let target = membership_evidence::first_unowned_member(
+                    &mut r.b,
+                    &raw,
+                    expression,
+                    "ParameterMembership",
+                    "Feature",
+                    None,
+                    steps,
+                )
+                .ok_or(CardinalityIssue::InvalidRelationship)?;
+                let selected = crate::eval::checked_multiplicity_reference_target(
+                    &mut r.b, target, context, steps,
+                )
+                .ok_or(CardinalityIssue::IncompleteProvider)?;
+                // Lexical references keep their model-level proof. A selected
+                // Type member instead has a complete receiver/redefinition proof.
+                if r.b
+                    .owner_elem(target)
+                    .is_none_or(|owner| !conforms(r.b.elements[owner].ty, "Type"))
+                {
+                    require_model_level_value(r, expression, steps)?;
+                } else {
+                    let receiver = context
+                        .and_then(|scope| r.b.scope_owner(scope))
+                        .ok_or(CardinalityIssue::IncompleteProvider)?;
+                    // Active behavior inputs need an invocation/frame environment;
+                    // a declaration default cannot stand in for supplied arguments.
+                    if conforms(r.b.elements[receiver].ty, "Behavior") {
+                        return Err(CardinalityIssue::UnsupportedBound);
+                    }
+                    if contextual_features.is_none() {
+                        let projection =
+                            r.b.checked_type_features(receiver, steps)
+                                .map_err(|_| CardinalityIssue::IncompleteProvider)?;
+                        charge(
+                            steps,
+                            projection
+                                .features
+                                .len()
+                                .saturating_add(projection.directed_features.len()),
+                        )?;
+                        contextual_features = Some((
+                            projection.features.into_iter().map(|e| e.0).collect(),
+                            projection
+                                .directed_features
+                                .into_iter()
+                                .map(|e| e.0)
+                                .collect(),
+                        ));
+                    }
+                    let (features, directed) = contextual_features.as_ref().unwrap();
+                    if !features.contains(&selected) || directed.contains(&selected) {
+                        return Err(CardinalityIssue::UnsupportedBound);
+                    }
+                }
+                let (_, value) = membership_evidence::valuation(&r.b, &raw, selected, steps)
+                    .flatten()
+                    .ok_or(CardinalityIssue::UnsupportedBound)?;
+                operators
+                    .references
+                    .insert(expression, (target, selected, value));
+                pending.push(value);
+                continue;
+            }
+            "OperatorExpression" => {}
+            _ => return Err(CardinalityIssue::UnsupportedBound),
+        }
+        let report = r.invocation_binding_report_with_budget(ElementRef(expression), *steps);
+        *steps = report.steps;
+        let arguments = report
+            .arguments
+            .map_err(|_| CardinalityIssue::UnsupportedBound)?;
+        let operator = match r.b.elements[expression]
+            .props
+            .get("operator")
+            .and_then(|v| v.as_str())
+        {
+            Some("+") => BinaryOp::Add,
+            Some("-") => BinaryOp::Sub,
+            Some("*") => BinaryOp::Mul,
+            Some("/") => BinaryOp::Div,
+            Some("%") => BinaryOp::Rem,
+            Some("^" | "**") => BinaryOp::Pow,
+            _ => return Err(CardinalityIssue::UnsupportedBound),
+        };
+        charge(steps, arguments.bindings.len())?;
+        let operands: Vec<_> = arguments
+            .bindings
+            .iter()
+            .map(|binding| binding.value.0)
+            .collect();
+        if operands.len() != 2
+            && !(operands.len() == 1 && matches!(operator, BinaryOp::Add | BinaryOp::Sub))
+        {
+            return Err(CardinalityIssue::UnsupportedBound);
+        }
+        pending.extend(operands.iter().copied());
+        operators.operators.insert(expression, (operator, operands));
+    }
+    Ok(operators)
+}
+
+/// A contextual reference replaces only the model-level eligibility predicate,
+/// never the complete inverse membership and current ownership evidence.
+fn certify_reference_domain(
+    b: &Builder,
+    raw: &StoredStructure,
+    expression: usize,
+    steps: &mut usize,
+) -> Result<(), CardinalityIssue> {
+    if !raw.is_current(b)
+        || !b.dynamic_evidence_current(expression)
+        || !b.local_featuring_evidence_current(expression)
+        || !b.result_redefinition_evidence_current(expression)
+    {
+        return Err(CardinalityIssue::StaleEvidence);
+    }
+    if raw.carrier(b, expression) != Some(None)
+        || !raw
+            .membership_domains(b, steps)
+            .ok_or(CardinalityIssue::InvalidRelationship)?
+            .owner_complete(expression)
+    {
+        return Err(CardinalityIssue::InvalidRelationship);
+    }
+    let relationships = semantic_ownership::owned_relationships(b, expression)
+        .ok_or(CardinalityIssue::InvalidRelationship)?;
+    charge(steps, relationships.len())?;
+    let mut seen = HashSet::new();
+    for relationship in relationships.iter() {
+        if !seen.insert(relationship)
+            || semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)
+                != Some(Some(expression))
+        {
+            return Err(CardinalityIssue::InvalidRelationship);
+        }
+        if !b.static_chain_row_current(relationship)
+            || !b.result_redefinition_row_current(relationship)
+        {
+            return Err(CardinalityIssue::StaleEvidence);
+        }
+        if conforms(b.elements[relationship].ty, "Membership") {
+            membership_evidence::member(b, raw, expression, relationship, steps)
+                .ok_or(CardinalityIssue::InvalidRelationship)?;
+        }
+    }
+    Ok(())
+}
+
+fn require_model_level_value(
+    r: &mut ResolvedModel,
+    expression: usize,
+    steps: &mut usize,
+) -> Result<(), CardinalityIssue> {
+    let proof = r.model_level_evaluability_with_budget(ElementRef(expression), *steps);
+    *steps = proof.steps;
+    if proof.classification == super::ModelLevelEvaluability::Evaluable {
+        Ok(())
+    } else {
+        Err(CardinalityIssue::UnsupportedBound)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::{GraphFormat, Model};
+    use serde_json::json;
+    const LIB: &str = "standard library package Base { classifier Anything; feature things:Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; }";
+    fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+        let mut m = Model::with_graph_format(format);
+        assert!(
+            m.add_library_source("bounds-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let unit = m.add_source("bounds.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&m)
+    }
+    fn bounds(r: &mut ResolvedModel, name: &str) -> Result<CardinalityBounds, CardinalityIssue> {
+        let e = r.resolve_qualified(name).unwrap();
+        r.cardinality_report(e).bounds
+    }
+    #[test]
+    fn checked_constraints_preserve_local_precedence_and_intersect_inheritance() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture(
+                "feature a[2..5]; feature b[3..7]; feature c subsets a,b; feature d[4] subsets c; feature bad[1] subsets c; feature zero[0]; feature conflict subsets a,zero;",
+                format,
+            );
+            assert_eq!(
+                bounds(&mut r, "a"),
+                Ok(CardinalityBounds {
+                    lower: 2,
+                    upper: Some(5)
+                })
+            );
+            assert_eq!(
+                bounds(&mut r, "c"),
+                Ok(CardinalityBounds {
+                    lower: 3,
+                    upper: Some(5)
+                })
+            );
+            assert_eq!(
+                bounds(&mut r, "d"),
+                Ok(CardinalityBounds {
+                    lower: 4,
+                    upper: Some(4)
+                })
+            );
+            // Cardinality selection is not specialization conformance validation.
+            assert_eq!(
+                bounds(&mut r, "bad"),
+                Ok(CardinalityBounds {
+                    lower: 1,
+                    upper: Some(1)
+                })
+            );
+            assert_eq!(
+                bounds(&mut r, "conflict"),
+                Err(CardinalityIssue::ConflictingConstraints)
+            );
+            let c = bounds(&mut r, "c").unwrap();
+            assert_eq!(c.size(), None);
+            assert_eq!(c.is_empty(), Some(false));
+            assert_eq!(c.contains_index(3), Some(true));
+            assert_eq!(c.contains_index(4), None);
+            assert_eq!(c.contains_index(6), Some(false));
+            assert_eq!(c.contains_index(0), Some(false));
+        }
+    }
+    #[test]
+    fn checked_named_domains_are_exact_and_cycles_remain_unknown() {
+        let mut r = fixture(
+            "multiplicity huge[9223372036854775809]; feature exact { multiplicity subsets huge; } multiplicity a subsets b; multiplicity b subsets a; feature cyclic {multiplicity subsets a;} feature infinity[*]; feature empty[0];",
+            GraphFormat::CanonicalV3,
+        );
+        assert_eq!(
+            bounds(&mut r, "exact").unwrap().size(),
+            Some(9223372036854775809)
+        );
+        assert_eq!(
+            bounds(&mut r, "infinity"),
+            Ok(CardinalityBounds {
+                lower: 0,
+                upper: None
+            })
+        );
+        assert_eq!(bounds(&mut r, "empty").unwrap().is_empty(), Some(true));
+        assert_eq!(
+            bounds(&mut r, "cyclic"),
+            Err(CardinalityIssue::CyclicDependency)
+        );
+    }
+    #[test]
+    fn checked_range_inverse_membership_and_endpoint_aliases_cannot_be_hidden() {
+        for mutation in 0..3 {
+            let mut r = fixture(
+                "multiplicity base[3]; feature a {multiplicity m subsets base;} feature other;",
+                GraphFormat::CanonicalV3,
+            );
+            assert_eq!(bounds(&mut r, "a").unwrap().size(), Some(3));
+            let a = r.resolve_qualified("a").unwrap().0;
+            let m = r.resolve_qualified("a::m").unwrap().0;
+            let other = r.resolve_qualified("other").unwrap().0;
+            let member = r.b.elements[m].owning_relationship.unwrap();
+            match mutation {
+                0 => {
+                    r.b.elements[a].owned_relationships = r.b.elements[a]
+                        .owned_relationships
+                        .iter()
+                        .copied()
+                        .filter(|&x| x != member)
+                        .collect::<Vec<_>>()
+                        .into()
+                }
+                1 => {
+                    let id = r.b.elements[other].id;
+                    r.b.elements[member]
+                        .props
+                        .insert("memberElement", json!({"@id": id.to_string()}));
+                }
+                _ => {
+                    let edge = r.b.elements[m].owned_relationships[0];
+                    let id = r.b.elements[other].id;
+                    r.b.elements[edge]
+                        .props
+                        .insert("general", json!({"@id": id.to_string()}));
+                }
+            }
+            assert_eq!(
+                bounds(&mut r, "a"),
+                Err(CardinalityIssue::InvalidRelationship),
+                "mutation {mutation}"
+            );
+        }
+    }
+    #[test]
+    fn checked_reference_bounds_and_budget_retry_do_not_publish_partial_success() {
+        let mut r = fixture(
+            "feature n=3; feature a[n]; feature b[2];",
+            GraphFormat::LegacyV2,
+        );
+        assert_eq!(bounds(&mut r, "a").unwrap().size(), Some(3));
+        let b = r.resolve_qualified("b").unwrap();
+        let failed = r.cardinality_report_with_budget(b, crate::eval::MAX_STEPS);
+        assert_eq!(failed.bounds, Err(CardinalityIssue::WorkLimit));
+        assert!(failed.multiplicities.is_empty());
+        assert_eq!(r.cardinality_report(b).bounds.unwrap().size(), Some(2));
+    }
+    const CONTEXTUAL_BOUNDS: &str = "class Parent {
+        feature n=4; feature aliasValue=n;
+        multiplicity dynamic[n];
+        feature slots {multiplicity subsets dynamic;}
+        feature direct[aliasValue];
+    }
+    class Child specializes Parent {
+        feature n redefines Parent::n=6;
+        feature slots redefines Parent::slots;
+        feature direct redefines Parent::direct;
+    }
+    class Grandchild specializes Child {
+        feature n redefines Child::n=9;
+        feature slots redefines Child::slots;
+        feature direct redefines Child::direct;
+    }
+    class Shadow specializes Parent {
+        feature n=12; feature slots redefines Parent::slots;
+    }";
+
+    #[test]
+    fn checked_contextual_references_follow_redefinition_identity() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture(CONTEXTUAL_BOUNDS, format);
+            for _ in 0..2 {
+                for (name, size) in [
+                    ("Parent::slots", 4),
+                    ("Parent::direct", 4),
+                    ("Child::slots", 6),
+                    ("Child::direct", 6),
+                    ("Grandchild::slots", 9),
+                    ("Grandchild::direct", 9),
+                    ("Shadow::slots", 4),
+                ] {
+                    let report = bounds(&mut r, name);
+                    assert_eq!(
+                        report
+                            .unwrap_or_else(|e| panic!("{format:?} {name}: {e:?}"))
+                            .size(),
+                        Some(size)
+                    );
+                }
+            }
+            let slots = r.resolve_qualified("Child::slots").unwrap();
+            assert_eq!(
+                r.cardinality_report_with_budget(slots, crate::eval::MAX_STEPS)
+                    .bounds,
+                Err(CardinalityIssue::WorkLimit)
+            );
+            assert_eq!(r.cardinality_report(slots).bounds.unwrap().size(), Some(6));
+        }
+    }
+
+    #[test]
+    fn checked_contextual_references_preserve_library_replay_results() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut base = Model::with_graph_format(format);
+            base.add_library_source("bounds-library.kerml", LIB);
+            base.add_library_source("contextual-bounds.kerml", CONTEXTUAL_BOUNDS);
+            base.record_library_cache();
+            ResolvedModel::build(&base);
+            let cache =
+                LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                    .unwrap();
+            let prepared = base.prepare_library().unwrap();
+            let decoded =
+                Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(93).unwrap(), 93).unwrap());
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.add_library_source("bounds-library.kerml", LIB);
+                        model.add_library_source("contextual-bounds.kerml", CONTEXTUAL_BOUNDS);
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let unit = model.add_source("user-bounds.kerml", "class User specializes Grandchild {feature slots redefines Grandchild::slots; feature direct redefines Grandchild::direct;}");
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+                let mut r = ResolvedModel::build(&model);
+                let mut signatures = Vec::new();
+                for name in ["User::slots", "User::direct"] {
+                    let element = r.resolve_qualified(name).unwrap();
+                    let report = r.cardinality_report(element);
+                    assert_eq!(
+                        report
+                            .bounds
+                            .unwrap_or_else(|e| panic!("{format:?} {mode} {name}: {e:?}"))
+                            .size(),
+                        Some(9)
+                    );
+                    signatures.push(
+                        report
+                            .multiplicities
+                            .iter()
+                            .map(|e| r.b.elements[e.0].id)
+                            .collect::<Vec<_>>(),
+                    );
+                }
+                match &expected {
+                    None => expected = Some(signatures),
+                    Some(expected) => assert_eq!(&signatures, expected, "{format:?} mode {mode}"),
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn checked_contextual_reference_values_use_current_rows_and_complete_aliases() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            for mutation in 0..3 {
+                let mut r = fixture(CONTEXTUAL_BOUNDS, format);
+                let selected = r.resolve_qualified("Child::n").unwrap().0;
+                let value = r.b.elements[selected]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| r.b.elements[rel].ty == "FeatureValue")
+                    .unwrap();
+                let literal = r.b.elements[value].children[0];
+                assert_eq!(bounds(&mut r, "Child::slots").unwrap().size(), Some(6));
+                r.b.elements[literal].props.insert("value", json!(7));
+                assert_eq!(bounds(&mut r, "Child::slots").unwrap().size(), Some(7));
+                match mutation {
+                    0 => {
+                        let id = r.b.elements[selected].id;
+                        r.b.elements[value]
+                            .props
+                            .insert("memberElement", json!({"@id": id.to_string()}));
+                    }
+                    1 => r.b.elements[value].children.make_mut().clear(),
+                    _ => {
+                        let rel = r.b.elements[selected]
+                            .owned_relationships
+                            .iter()
+                            .copied()
+                            .find(|&rel| r.b.elements[rel].ty == "Redefinition")
+                            .unwrap();
+                        let id = r.b.elements[selected].id;
+                        r.b.elements[rel]
+                            .props
+                            .insert("general", json!({"@id": id.to_string()}));
+                    }
+                }
+                let slots = r.resolve_qualified("Child::slots").unwrap();
+                let report = r.cardinality_report(slots);
+                assert!(report.bounds.is_err(), "{format:?} mutation {mutation}");
+                assert!(report.multiplicities.is_empty());
+            }
+        }
+    }
+
+    #[test]
+    fn checked_contextual_references_reject_unlisted_inverse_membership_claims() {
+        for key in ["membershipOwningNamespace", "source"] {
+            let mut r = fixture(CONTEXTUAL_BOUNDS, GraphFormat::CanonicalV3);
+            let slots = r.resolve_qualified("Child::slots").unwrap();
+            assert_eq!(r.cardinality_report(slots).bounds.unwrap().size(), Some(6));
+            let domain = r.resolve_qualified("Parent::dynamic").unwrap().0;
+            let expression =
+                r.b.owned_member_elems(domain, false)
+                    .into_iter()
+                    .find(|&e| r.b.elements[e].ty == "FeatureReferenceExpression")
+                    .unwrap();
+            let other = r.resolve_qualified("Shadow::n").unwrap().0;
+            let membership = r.b.elements[other].owning_relationship.unwrap();
+            let claim = json!({"@id": r.b.elements[expression].id.to_string()});
+            r.b.elements[membership].props.insert(
+                key,
+                if key == "source" {
+                    json!([claim])
+                } else {
+                    claim
+                },
+            );
+            let report = r.cardinality_report(slots);
+            assert_eq!(
+                report.bounds,
+                Err(CardinalityIssue::InvalidRelationship),
+                "{key}"
+            );
+            assert!(report.multiplicities.is_empty());
+        }
+    }
+
+    #[test]
+    fn checked_contextual_references_reject_stale_published_receiver_edges() {
+        let mut r = fixture(CONTEXTUAL_BOUNDS, GraphFormat::CanonicalV3);
+        let slots = r.resolve_qualified("Child::slots").unwrap();
+        assert_eq!(r.cardinality_report(slots).bounds.unwrap().size(), Some(6));
+        r.implied_relationships(slots);
+        assert_eq!(r.cardinality_report(slots).bounds.unwrap().size(), Some(6));
+        let n = r.resolve_qualified("Child::n").unwrap().0;
+        let relation = r.b.elements[n]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "Redefinition")
+            .unwrap();
+        let own_id = r.b.elements[n].id;
+        r.b.elements[relation]
+            .props
+            .insert("redefinedFeature", json!({"@id": own_id.to_string()}));
+        let report = r.cardinality_report(slots);
+        assert!(report.bounds.is_err());
+        assert!(report.multiplicities.is_empty());
+    }
+
+    #[test]
+    fn checked_contextual_references_keep_metadata_domains_qualified() {
+        for on_expression in [false, true] {
+            let mut r = fixture(CONTEXTUAL_BOUNDS, GraphFormat::CanonicalV3);
+            let slots = r.resolve_qualified("Child::slots").unwrap();
+            assert_eq!(r.cardinality_report(slots).bounds.unwrap().size(), Some(6));
+            let target = if on_expression {
+                let domain = r.resolve_qualified("Parent::dynamic").unwrap().0;
+                r.b.owned_member_elems(domain, false)
+                    .into_iter()
+                    .find(|&e| r.b.elements[e].ty == "FeatureReferenceExpression")
+                    .unwrap()
+            } else {
+                r.resolve_qualified("Child::n").unwrap().0
+            };
+            r.b.metadata_of.insert(target, vec![target]);
+            assert!(r.cardinality_report(slots).bounds.is_err());
+        }
+    }
+
+    #[test]
+    fn checked_contextual_references_do_not_substitute_runtime_parameter_defaults() {
+        let mut r = fixture(
+            "function F {in n=4; in slots[n]; return result;}",
+            GraphFormat::CanonicalV3,
+        );
+        assert!(bounds(&mut r, "F::slots").is_err());
+    }
+
+    #[test]
+    fn checked_contextual_references_reject_ambiguous_and_cyclic_values() {
+        for source in [
+            "class Parent {feature n=4; feature slots[n];}
+             class Child specializes Parent {feature choiceA redefines Parent::n=6; feature choiceB redefines Parent::n=7; feature slots redefines Parent::slots;}",
+            "class Parent {feature n=4; feature slots[n];}
+             class Child specializes Parent {feature n redefines Parent::n=n; feature slots redefines Parent::slots;}",
+        ] {
+            let mut r = fixture(source, GraphFormat::CanonicalV3);
+            assert!(bounds(&mut r, "Child::slots").is_err());
+        }
+    }
+
+    #[test]
+    fn checked_formula_uses_current_graph_operands_and_rejects_stale_publication() {
+        for mutation in 0..2 {
+            let mut m = Model::with_graph_format(GraphFormat::CanonicalV3);
+            m.add_library_source("bounds-library.kerml", "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;} standard library package DataFunctions {function '+' {in a; in b; return r;} function '*' {in a; in b; return r;}} ");
+            let unit = m.add_source("formula.kerml", "feature f[(1+2)];");
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut r = ResolvedModel::build(&m);
+            let f = r.resolve_qualified("f").unwrap();
+            let operator =
+                r.b.elements
+                    .iter()
+                    .position(|e| e.ty == "OperatorExpression")
+                    .unwrap();
+            let two =
+                r.b.elements
+                    .iter()
+                    .position(|e| {
+                        e.ty == "LiteralInteger"
+                            && matches!(e.props.get("value"), Some(crate::properties::Atom::Number(n)) if n.as_i64() == Some(2))
+                    })
+                    .unwrap();
+            if mutation == 0 {
+                r.b.elements[two].props.insert("value", json!(9));
+            } else {
+                r.b.elements[operator].props.insert("operator", json!("*"));
+            }
+            r.implied_relationships(f);
+            let report = r.cardinality_report(f);
+            assert_eq!(
+                report.bounds.unwrap().size(),
+                Some(if mutation == 0 { 10 } else { 2 })
+            );
+            // Same IDs and row count do not preserve a certificate after edits.
+            r.b.elements[two].props.insert("value", json!(7));
+            assert!(r.cardinality_report(f).bounds.is_err());
+        }
+    }
+
+    #[test]
+    fn checked_reference_bounds_follow_current_graph_valuations() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture("feature n=3; feature m=n; feature a[m];", format);
+            let literal =
+                r.b.elements
+                    .iter()
+                    .position(|e| e.ty == "LiteralInteger")
+                    .unwrap();
+            r.b.elements[literal].props.insert("value", json!(9));
+            assert_eq!(bounds(&mut r, "a").unwrap().size(), Some(9));
+            r.b.elements[literal].props.insert("value", json!(12));
+            assert_eq!(bounds(&mut r, "a").unwrap().size(), Some(12));
+        }
+    }
+
+    #[test]
+    fn checked_reference_bounds_ignore_published_result_memberships() {
+        let mut r = fixture(
+            "feature n=3; feature m=n; feature a[m];",
+            GraphFormat::CanonicalV3,
+        );
+        let a = r.resolve_qualified("a").unwrap();
+        assert_eq!(r.cardinality_report(a).bounds.unwrap().size(), Some(3));
+        r.implied_relationships(a);
+        let references: Vec<_> = r
+            .user_elements()
+            .filter(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .collect();
+        for reference in references {
+            assert!(
+                semantic_ownership::owned_relationships(&r.b, reference.0)
+                    .unwrap()
+                    .iter()
+                    .any(|rel| r.b.elements[rel].ty == "ReturnParameterMembership")
+            );
+        }
+        assert_eq!(r.cardinality_report(a).bounds.unwrap().size(), Some(3));
+    }
+
+    #[test]
+    fn compatibility_cardinality_keeps_numeric_domains_separate_from_feature_bounds() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture(
+                "multiplicity four[4]; alias named for four; multiplicity chain subsets named; feature exact { multiplicity subsets chain; } feature base[2]; feature inherited subsets base;",
+                format,
+            );
+            let four = r.resolve_qualified("four").unwrap();
+            let chain = r.resolve_qualified("chain").unwrap();
+            let exact = r.resolve_qualified("exact").unwrap();
+            let base = r.resolve_qualified("base").unwrap();
+            let inherited = r.resolve_qualified("inherited").unwrap();
+            assert_eq!(r.effective_cardinality(four), Some((0, None)));
+            assert_eq!(r.effective_cardinality(chain), None);
+            assert_eq!(r.effective_cardinality(exact), Some((4, Some(4))));
+            assert_eq!(r.cardinality_report(exact).bounds.unwrap().size(), Some(4));
+            assert_eq!(r.effective_cardinality(inherited), Some((2, Some(2))));
+            let mut exhausted = crate::eval::MAX_STEPS;
+            assert_eq!(
+                r.b.cardinality_subset_targets(inherited.0, &mut exhausted),
+                None
+            );
+            assert_eq!(r.effective_cardinality(inherited), Some((2, Some(2))));
+            let chain_edge = r.b.elements[chain.0].owned_relationships[0];
+            // Authored flags cannot turn an unrecorded edge into a generated one.
+            r.b.elements[chain_edge]
+                .props
+                .insert("isImplied", json!(true));
+            assert_eq!(r.effective_cardinality(chain), None);
+            let edge = r.b.elements[inherited.0].owned_relationships[0];
+            let id = r.b.elements[base.0].id;
+            r.b.elements[edge]
+                .props
+                .insert("specific", json!({"@id": id.to_string()}));
+            assert_eq!(r.effective_cardinality(inherited), None);
+        }
+    }
+
+    #[test]
+    fn compatibility_structural_default_precedes_published_positional_bounds() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut model = Model::with_graph_format(format);
+            let unit = model.add_source(
+                "parameter-bounds.sysml",
+                "calc def Base { in original[3]; return result; } calc def Child :> Base { in attribute renamed; return result; }",
+            );
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let parameter = r.resolve_qualified("Child::renamed").unwrap();
+            let original = r.resolve_qualified("Base::original").unwrap();
+            assert_eq!(r.effective_cardinality(parameter), Some((1, Some(1))));
+            r.implied_relationships(parameter);
+            let generated = semantic_ownership::owned_relationships(&r.b, parameter.0)
+                .unwrap()
+                .iter()
+                .find(|&relationship| {
+                    relationship >= r.b.explicit_len()
+                        && r.b.elements[relationship].ty == "Redefinition"
+                })
+                .unwrap();
+            assert_eq!(
+                r.b.cardinality_subset_targets(parameter.0, &mut 0),
+                Some(Vec::new())
+            );
+            assert_eq!(r.effective_cardinality(parameter), Some((1, Some(1))));
+            let id = r.b.elements[original.0].id;
+            r.b.elements[generated]
+                .props
+                .insert("specific", json!({"@id": id.to_string()}));
+            assert_eq!(r.effective_cardinality(parameter), None);
+        }
+    }
+
+    #[test]
+    fn compatibility_cardinality_edges_refuse_stale_dynamic_suffixes() {
+        let mut r = fixture(
+            "function F {in p;} feature call=F(1);",
+            GraphFormat::CanonicalV3,
+        );
+        let invocation = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(invocation);
+        let parameter =
+            r.b.elements
+                .iter()
+                .enumerate()
+                .find_map(|(i, e)| {
+                    (e.ty == "Redefinition" && i >= r.b.explicit_len())
+                        .then(|| {
+                            e.props
+                                .get("owningRelatedElement")
+                                .and_then(|v| v.as_reference())
+                        })
+                        .flatten()
+                })
+                .unwrap();
+        let parameter = r.b.element_index_of_uuid(parameter).unwrap();
+        assert!(r.b.cardinality_subset_targets(parameter, &mut 0).is_some());
+        let rows = r.b.elements.observe_revision();
+        r.b.lib_qnames.push((
+            uuid::Uuid::new_v4(),
+            vec!["changed loaded name evidence".into()],
+        ));
+        assert!(r.b.elements.revision().unwrap().same_as(&rows));
+        assert!(r.b.cardinality_subset_targets(parameter, &mut 0).is_none());
+    }
+
+    #[test]
+    fn compatibility_redefinition_and_candidate_readers_refuse_forged_inverse_evidence() {
+        let mut r = fixture(
+            "class C { feature a=2; feature b redefines a=3; }",
+            GraphFormat::LegacyV2,
+        );
+        let c = r.resolve_qualified("C").unwrap().0;
+        let a = r.resolve_qualified("C::a").unwrap().0;
+        let b = r.resolve_qualified("C::b").unwrap().0;
+        assert_eq!(
+            r.b.cardinality_redefinition_targets(b, &mut 0),
+            Some(vec![a])
+        );
+        let edge = r.b.elements[b]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&e| r.b.elements[e].ty == "Redefinition")
+            .unwrap();
+        let a_id = r.b.elements[a].id;
+        r.b.elements[edge]
+            .props
+            .insert("specific", json!({"@id": a_id.to_string()}));
+        assert_eq!(r.b.cardinality_redefinition_targets(b, &mut 0), None);
+        let member = r.b.elements[a].owning_relationship.unwrap();
+        r.b.elements[c].owned_relationships = r.b.elements[c]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&e| e != member)
+            .collect::<Vec<_>>()
+            .into();
+        assert_eq!(r.b.cardinality_feature_candidates(c, &mut 0), None);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/closures.rs b/crates/sysmlv2-model/src/json/closures.rs
index ac67584..87d1d24 100644
--- a/crates/sysmlv2-model/src/json/closures.rs
+++ b/crates/sysmlv2-model/src/json/closures.rs
@@ -1,4 +1,4 @@
-//! The closures and the inheritance-aware switch (plan §33h): the four
+//! The closures and the inheritance-aware switch: the four
 //! closure names — `inheritedMembership`, `inheritedFeature`,
 //! `importedMembership`, `featuringType` — over the resolver's own
 //! inheritance and import walks, and the *closure policy* under which the
@@ -14,10 +14,13 @@
 //! — the payload grows with the closures materialized per element, which
 //! is why the passthrough level exists (INTEROP.md).
 //!
-//! The walk stops at a fixed heritage depth ([`super::MAX_RESOLUTION_DEPTH`])
-//! and reports it ([`ResolvedModel::closure_truncated`]) rather than
-//! presenting a cut enumeration as the closure; the emitter refuses to
-//! write one.
+//! Scoped acyclic inheritance is evaluated iteratively without a depth cap.
+//! Supported scope-less expression heritage and contextual import inheritance use bounded
+//! query walks. Import walks and cyclic inheritance fallback retain a depth budget
+//! ([`super::MAX_RESOLUTION_DEPTH`]); [`ResolvedModel::closure_truncated`]
+//! reports an actual cut, and closure emission refuses that partial result.
+//! Known unsupported dependencies are separately reported by
+//! [`ResolvedModel::inheritance_incomplete`].
 
 use super::{ElementRef, InheritedBindings, LookupAccess, ResolvedModel};
 use crate::metaclass::conforms;
@@ -80,6 +83,7 @@ impl ResolvedModel {
     /// incomplete. A closure the emitter is asked to write for such an
     /// element is refused, not truncated.
     pub fn closure_truncated(&mut self, e: ElementRef) -> bool {
+        self.sync_semantic_publication();
         let include_implied = self.include_implied();
         if self.inheritance_walk_truncated(e, include_implied) {
             return true;
@@ -126,35 +130,28 @@ impl ResolvedModel {
     /// excludes) — each imported member's owning membership, and the
     /// imported alias memberships, admitted by the imports' filter
     /// conditions, in discovery order (per import, declaration order).
-    /// Two deviations from the normative operation: a `import Q::alias;`
-    /// contributes the aliased element's owning membership rather than
-    /// the alias Membership itself, and a mutual public-import cycle
-    /// lists a namespace's own memberships under its imports (the
-    /// operation's `excluded->including(self)` seed), which `membership`
-    /// deduplicates.
+    /// Named imports retain the selected alias Membership. Namespace
+    /// traversal excludes ancestor namespaces to break import cycles.
+    /// Membership identity is deduplicated before name/metaclass collisions
+    /// against peers and owned memberships are removed. Package filters follow
+    /// that pruning. Visibility-specific re-exports are a separate operation.
+    /// Signatures requiring unavailable external or specialized inferred naming
+    /// remain conservatively present; this is not a complete conformance claim.
     pub fn imported_memberships(&mut self, e: ElementRef) -> Vec<ElementRef> {
         let Some(&s) = self.b.elem_scope.get(&e.0) else {
             return Vec::new();
         };
         let include_implied = self.include_implied();
         let mut bindings = InheritedBindings::default();
-        self.b
+        let order = self
+            .b
             .imported_bindings(s, include_implied, LookupAccess::All, &mut bindings);
-        let mut out: Vec<ElementRef> = Vec::new();
-        let mut seen: HashSet<usize> = HashSet::new();
-        for &(elem, _) in &bindings.members {
-            if let Some(r) = self.b.elements[elem].owning_relationship {
-                if seen.insert(r) {
-                    out.push(ElementRef(r));
-                }
-            }
-        }
-        for &r in &bindings.alias_rels {
-            if seen.insert(r) {
-                out.push(ElementRef(r));
-            }
-        }
-        out
+        let mut seen = HashSet::new();
+        order
+            .into_iter()
+            .filter(|&r| seen.insert(r))
+            .map(ElementRef)
+            .collect()
     }
 
     // ---- the inheritance-aware bases ----
diff --git a/crates/sysmlv2-model/src/json/constructor_bindings.rs b/crates/sysmlv2-model/src/json/constructor_bindings.rs
new file mode 100644
index 0000000..4147abe
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/constructor_bindings.rs
@@ -0,0 +1,1449 @@
+//! Checked canonical constructor arguments over the shared complete Type feature sequence.
+use super::{
+    ElementRef, ResolvedModel, TypeInputIssue, membership_evidence,
+    semantic::certified_types::Stamp, semantic_ownership, structural_index::StoredStructure,
+    type_relations,
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+/// A supplied argument and the exact public feature it directly redefines.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorBinding {
+    pub feature: ElementRef,
+    pub parameter: ElementRef,
+    pub value: ElementRef,
+}
+/// Complete supplied arguments in public instantiated-Type feature order.
+/// Omitted features remain in `features` without a binding; defaults, arity and
+/// result specialization are separate obligations.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorBindings {
+    pub instantiated_type: ElementRef,
+    pub result: ElementRef,
+    pub features: Vec<ElementRef>,
+    pub bindings: Vec<ConstructorBinding>,
+}
+/// A failed proof never denotes an empty argument list.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ConstructorBindingIssue {
+    InvalidElement,
+    InvalidRelationship,
+    IncompleteFeatures(TypeInputIssue),
+    IncompleteProvider,
+    UnsupportedConfiguration,
+    UnmappedArgument,
+    DuplicateArgument,
+    StaleEvidence,
+    WorkLimit,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorBindingReport {
+    pub arguments: Result<ConstructorBindings, ConstructorBindingIssue>,
+    pub steps: usize,
+}
+use ConstructorBindingIssue::*;
+fn charge(steps: &mut usize, n: usize) -> Result<(), ConstructorBindingIssue> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+/// Authoritative constructor selector and sole owned result, independent of
+/// whether supplied arguments or the result specialization can be certified.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorSelection {
+    pub instantiated_type: ElementRef,
+    pub result: ElementRef,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorSelectionReport {
+    pub selection: Result<ConstructorSelection, ConstructorBindingIssue>,
+    pub steps: usize,
+}
+impl ResolvedModel {
+    pub fn constructor_selection_report(
+        &mut self,
+        receiver: ElementRef,
+    ) -> ConstructorSelectionReport {
+        self.constructor_selection_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn constructor_selection_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> ConstructorSelectionReport {
+        let mut steps = initial;
+        let selection = (|| {
+            charge(&mut steps, 1)?;
+            if self.b.graph_format != crate::model::GraphFormat::CanonicalV3
+                || self.b.elements.get(receiver.0).ok_or(InvalidElement)?.ty
+                    != "ConstructorExpression"
+                || self.b.positional_planning
+            {
+                return Err(UnsupportedConfiguration);
+            }
+            let raw =
+                StoredStructure::for_query(&mut self.b, &mut steps).ok_or(IncompleteProvider)?;
+            let instantiated_type = membership_evidence::first_unowned_member(
+                &mut self.b,
+                &raw,
+                receiver.0,
+                "FeatureMembership",
+                "Type",
+                None,
+                &mut steps,
+            )
+            .ok_or(InvalidRelationship)?;
+            let result =
+                owned_result(&self.b, &raw, receiver.0, &mut steps).ok_or(InvalidRelationship)?;
+            // Local syntax selection does not establish the complete effective
+            // result family when metadata contributions are unavailable.
+            if raw.annotations_incomplete
+                || self.b.metadata_associations_incomplete
+                || [receiver.0, result].into_iter().any(|element| {
+                    raw.metadata_annotation_targets.contains(&element)
+                        || self
+                            .b
+                            .metadata_of
+                            .get(&element)
+                            .is_some_and(|m| !m.is_empty())
+                })
+            {
+                return Err(IncompleteProvider);
+            }
+            Ok(ConstructorSelection {
+                instantiated_type: ElementRef(instantiated_type),
+                result: ElementRef(result),
+            })
+        })();
+        ConstructorSelectionReport {
+            selection: if steps > crate::eval::MAX_STEPS {
+                Err(WorkLimit)
+            } else {
+                selection
+            },
+            steps,
+        }
+    }
+    /// Certify supplied canonical constructor arguments in complete public
+    /// instantiated-Type feature order. Named bindings use checked authored
+    /// Redefinitions; positional bindings require the shared published plan.
+    /// Omitted features are allowed. Default and result obligations have separate
+    /// reports; this does not certify whole-model conformance.
+    pub fn constructor_binding_report(&mut self, receiver: ElementRef) -> ConstructorBindingReport {
+        self.constructor_binding_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn constructor_binding_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> ConstructorBindingReport {
+        let mut steps = initial;
+        let arguments = self
+            .b
+            .checked_constructor_bindings(receiver.0, &mut steps, None);
+        ConstructorBindingReport {
+            arguments: if steps > crate::eval::MAX_STEPS {
+                Err(WorkLimit)
+            } else {
+                arguments
+            },
+            steps,
+        }
+    }
+}
+/// Query-local successful Type projections shared across one constructor batch.
+/// A source/publication change discards the complete cache before any reuse.
+#[derive(Default)]
+pub(super) struct ConstructorBatchEvidence {
+    stamp: Option<Stamp>,
+    features: HashMap<usize, super::TypeFeatures>,
+    numeric_targets: HashMap<&'static str, usize>,
+    relations: super::type_relations::TypeRelations,
+}
+fn projection_work(features: &super::TypeFeatures) -> usize {
+    [
+        features.owned_memberships.len(),
+        features.inherited_memberships.len(),
+        features.owned_feature_memberships.len(),
+        features.feature_memberships.len(),
+        features.features.len(),
+        features.inherited_features.len(),
+        features.inputs.len(),
+        features.outputs.len(),
+        features.directed_features.len(),
+        features.end_features.len(),
+        features.memberships.as_ref().map_or(0, Vec::len),
+        features.members.as_ref().map_or(0, Vec::len),
+    ]
+    .into_iter()
+    .fold(1usize, usize::saturating_add)
+}
+impl ConstructorBatchEvidence {
+    fn align(
+        &mut self,
+        b: &mut super::Builder,
+        steps: &mut usize,
+    ) -> Result<(), ConstructorBindingIssue> {
+        if self
+            .stamp
+            .as_ref()
+            .is_some_and(|stamp| stamp.current_builder(b))
+        {
+            return Ok(());
+        }
+        charge(
+            steps,
+            self.features
+                .capacity()
+                .saturating_add(self.numeric_targets.capacity()),
+        )?;
+        self.relations.reset_with_budget(steps).ok_or(WorkLimit)?;
+        self.features = HashMap::new();
+        self.numeric_targets = HashMap::new();
+        self.stamp = Some(Stamp::capture_builder(b));
+        Ok(())
+    }
+    pub(super) fn numeric_target(
+        &mut self,
+        b: &mut super::Builder,
+        receiver: usize,
+        steps: &mut usize,
+    ) -> Option<usize> {
+        let operator = super::invocation_bindings::numeric_operator_name(b, receiver)?;
+        self.align(b, steps).ok()?;
+        if let Some(&target) = self.numeric_targets.get(operator) {
+            charge(steps, 1).ok()?;
+            return Some(target);
+        }
+        let target = super::invocation_bindings::numeric_operator_target(b, receiver, steps)?;
+        self.align(b, steps).ok()?;
+        self.numeric_targets.insert(operator, target);
+        Some(target)
+    }
+    pub(super) fn features(
+        &mut self,
+        b: &mut super::Builder,
+        callee: usize,
+        steps: &mut usize,
+    ) -> Result<super::TypeFeatures, ConstructorBindingIssue> {
+        self.align(b, steps)?;
+        if let Some(features) = self.features.get(&callee) {
+            charge(steps, projection_work(features))?;
+            return Ok(features.clone());
+        }
+        let result = b.checked_type_features_with_relations(callee, steps, &mut self.relations);
+        // Even a failed projection may have prepared semantic state. Facts
+        // survive only under the same before/after authority; top-level failed
+        // projections themselves are never memoized.
+        self.align(b, steps)?;
+        let features = result.map_err(IncompleteFeatures)?;
+        charge(steps, projection_work(&features))?;
+        self.features.insert(callee, features.clone());
+        Ok(features)
+    }
+}
+
+impl super::Builder {
+    pub(super) fn checked_constructor_bindings(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        proposed: Option<&mut HashMap<usize, Vec<usize>>>,
+    ) -> Result<ConstructorBindings, ConstructorBindingIssue> {
+        self.checked_constructor_bindings_in_batch(
+            receiver,
+            steps,
+            proposed,
+            &mut ConstructorBatchEvidence::default(),
+        )
+    }
+    pub(super) fn checked_constructor_bindings_in_batch(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        mut proposed: Option<&mut HashMap<usize, Vec<usize>>>,
+        batch: &mut ConstructorBatchEvidence,
+    ) -> Result<ConstructorBindings, ConstructorBindingIssue> {
+        charge(steps, 1)?;
+        if self.elements.get(receiver).ok_or(InvalidElement)?.ty != "ConstructorExpression"
+            || self.graph_format != crate::model::GraphFormat::CanonicalV3
+            || self.positional_planning
+        {
+            return Err(UnsupportedConfiguration);
+        }
+        let raw = StoredStructure::for_query(self, steps).ok_or(IncompleteProvider)?;
+        let callee = membership_evidence::first_unowned_member(
+            self,
+            &raw,
+            receiver,
+            "FeatureMembership",
+            "Type",
+            None,
+            steps,
+        )
+        .ok_or(InvalidRelationship)?;
+        let features = batch.features(self, callee, steps)?.features;
+        // Callee preparation may change shared semantic state. Capture all local
+        // evidence afterward and recheck the selector against this same snapshot.
+        let raw = StoredStructure::for_query(self, steps).ok_or(IncompleteProvider)?;
+        if membership_evidence::first_unowned_member(
+            self,
+            &raw,
+            receiver,
+            "FeatureMembership",
+            "Type",
+            None,
+            steps,
+        ) != Some(callee)
+        {
+            return Err(StaleEvidence);
+        }
+        let domains = raw
+            .membership_domains(self, steps)
+            .ok_or(IncompleteProvider)?;
+        let inverse = raw.typing(self, steps).ok_or(IncompleteProvider)?;
+        if !raw.ids_unique
+            || raw.annotations_incomplete
+            || inverse.sources_incomplete
+            || self.metadata_associations_incomplete
+            || !domains.owner_complete(receiver)
+            || raw.metadata_annotation_targets.contains(&receiver)
+            || self
+                .metadata_of
+                .get(&receiver)
+                .is_some_and(|m| !m.is_empty())
+            || !semantic_ownership::owned_feature_projection_complete(self, receiver)
+        {
+            return Err(IncompleteProvider);
+        }
+        let result = owned_result(self, &raw, receiver, steps).ok_or(InvalidRelationship)?;
+        if !domains.owner_complete(result)
+            || raw.metadata_annotation_targets.contains(&result)
+            || self.metadata_of.get(&result).is_some_and(|m| !m.is_empty())
+        {
+            return Err(IncompleteProvider);
+        }
+        let stamp = Stamp::capture_builder(self);
+        charge(steps, features.len())?;
+        let mut public_features = Vec::new();
+        for feature in features {
+            let membership = self.elements[feature.0]
+                .owning_relationship
+                .ok_or(InvalidRelationship)?;
+            let visibility = match self.elements[membership].props.get("visibility") {
+                None => "public",
+                Some(value) => value.as_str().ok_or(InvalidRelationship)?,
+            };
+            match visibility {
+                "public" => public_features.push(feature),
+                "private" | "protected" => {}
+                _ => return Err(InvalidRelationship),
+            }
+        }
+        let eligible: HashSet<_> = public_features.iter().map(|e| e.0).collect();
+        let relationships =
+            semantic_ownership::owned_relationships(self, result).ok_or(IncompleteProvider)?;
+        charge(steps, relationships.len())?;
+        let relationships: Vec<_> = relationships.iter().collect();
+        let mut seen = HashSet::new();
+        let mut mapped = HashMap::new();
+
+        let mut position = 0;
+        for relationship in relationships {
+            if !seen.insert(relationship)
+                || semantic_ownership::checked_relationship_carrier(self, &raw, relationship, steps)
+                    != Some(Some(result))
+            {
+                return Err(InvalidRelationship);
+            }
+            let kind = self.elements[relationship].ty;
+            if !conforms(kind, "FeatureMembership") {
+                continue;
+            }
+            let parameter = membership_evidence::member(self, &raw, result, relationship, steps)
+                .ok_or(InvalidRelationship)?;
+            if !domains.owner_complete(parameter)
+                || raw.metadata_annotation_targets.contains(&parameter)
+                || self
+                    .metadata_of
+                    .get(&parameter)
+                    .is_some_and(|m| !m.is_empty())
+                || self.elements[parameter].ty != "Feature"
+            {
+                return Err(IncompleteProvider);
+            }
+            let direction = membership_evidence::parameter_direction(self, &raw, parameter, steps)
+                .ok_or(InvalidRelationship)?;
+            let valuation = membership_evidence::valuation(self, &raw, parameter, steps)
+                .ok_or(InvalidRelationship)?;
+            if kind != "ParameterMembership" || direction != Some("in") {
+                return Err(UnsupportedConfiguration);
+            }
+            let (value_membership, value) = valuation.ok_or(UnmappedArgument)?;
+            for key in ["isInitial", "isDefault"] {
+                if self.elements[value_membership]
+                    .props
+                    .get(key)
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+                {
+                    return Err(UnsupportedConfiguration);
+                }
+            }
+            let owned = semantic_ownership::owned_relationships(self, parameter)
+                .ok_or(IncompleteProvider)?;
+            charge(steps, owned.len())?;
+            let owned: Vec<_> = owned.iter().collect();
+            let mut target = None;
+            let mut witnessed = HashSet::new();
+            for rel in owned.iter().copied().chain(
+                inverse
+                    .relationships
+                    .get(&parameter)
+                    .into_iter()
+                    .flatten()
+                    .copied(),
+            ) {
+                charge(steps, 1)?;
+                if !witnessed.insert(rel) {
+                    continue;
+                }
+                let row = &self.elements[rel];
+                // Extra owned features, conjugation or value-affecting metadata
+                // require a broader provider; do not silently drop them.
+                if conforms(row.ty, "FeatureMembership")
+                    || conforms(row.ty, "Conjugation")
+                    || (rel < self.explicit_len()
+                        && conforms(row.ty, "Specialization")
+                        && !conforms(row.ty, "Redefinition"))
+                {
+                    return Err(UnsupportedConfiguration);
+                }
+                if !conforms(row.ty, "Redefinition") {
+                    continue;
+                }
+                if target.is_some() {
+                    return Err(UnsupportedConfiguration);
+                }
+                if !owned.contains(&rel)
+                    || semantic_ownership::checked_relationship_carrier(self, &raw, rel, steps)
+                        != Some(Some(parameter))
+                    || !self.static_chain_row_current(rel)
+                    || !self.result_redefinition_row_current(rel)
+                {
+                    return Err(InvalidRelationship);
+                }
+                let implied = match row.props.get("isImplied") {
+                    None => false,
+                    Some(v) => v.as_bool().ok_or(InvalidRelationship)?,
+                };
+                let mapped_input = type_relations::endpoint_with_carrier(
+                    self,
+                    parameter,
+                    Some(parameter),
+                    rel,
+                    &["specific", "subsettingFeature", "redefiningFeature"],
+                    &["general", "subsettedFeature", "redefinedFeature"],
+                    "Feature",
+                    steps,
+                )
+                .ok_or(InvalidRelationship)?;
+                if !eligible.contains(&mapped_input) {
+                    return Err(UnmappedArgument);
+                }
+                if implied {
+                    if rel < self.explicit_len()
+                        || public_features.get(position) != Some(&ElementRef(mapped_input))
+                        || !self.semantic_ownership.as_ref().is_some_and(|view| {
+                            view.matches_suffix(self)
+                                && view.generated_relationship_owner(rel) == Some(parameter)
+                        })
+                    {
+                        return Err(UnsupportedConfiguration);
+                    }
+                    let plan = self.effective_dynamic_plan().ok_or(StaleEvidence)?;
+                    let targets = plan
+                        .positional
+                        .targets
+                        .get(&parameter)
+                        .ok_or(UnmappedArgument)?;
+                    charge(steps, targets.len().saturating_add(1))?;
+                    if !plan.affected_owners.contains(&parameter)
+                        || plan.incomplete_bases.contains(&result)
+                        || plan.positional.incomplete.contains(&result)
+                        || targets.as_slice() != [mapped_input]
+                    {
+                        return Err(IncompleteProvider);
+                    }
+                } else if rel >= self.explicit_len() {
+                    return Err(InvalidRelationship);
+                }
+                target = Some(mapped_input);
+            }
+            let input = if let Some(target) = target {
+                target
+            } else if let Some(proposed) = proposed.as_deref_mut() {
+                let target = public_features.get(position).ok_or(UnmappedArgument)?.0;
+                proposed.insert(parameter, vec![target]);
+                target
+            } else {
+                return Err(UnmappedArgument);
+            };
+            position += 1;
+            if mapped
+                .insert(
+                    input,
+                    ConstructorBinding {
+                        feature: ElementRef(input),
+                        parameter: ElementRef(parameter),
+                        value: ElementRef(value),
+                    },
+                )
+                .is_some()
+            {
+                return Err(DuplicateArgument);
+            }
+        }
+        charge(steps, public_features.len())?;
+        let bindings = public_features
+            .iter()
+            .filter_map(|i| mapped.remove(&i.0))
+            .collect();
+        if !stamp.current_builder(self) {
+            return Err(StaleEvidence);
+        }
+        Ok(ConstructorBindings {
+            instantiated_type: ElementRef(callee),
+            result: ElementRef(result),
+            features: public_features,
+            bindings,
+        })
+    }
+}
+
+/// Canonical authored result selected through complete reciprocal ownership.
+/// This is deliberately independent of binding and specialization preparation.
+pub(super) fn owned_result(
+    b: &super::Builder,
+    raw: &StoredStructure,
+    receiver: usize,
+    steps: &mut usize,
+) -> Option<usize> {
+    charge(steps, 1).ok()?;
+    if b.graph_format != crate::model::GraphFormat::CanonicalV3
+        || b.elements.get(receiver)?.ty != "ConstructorExpression"
+        || !raw.membership_domains(b, steps)?.owner_complete(receiver)
+        || !semantic_ownership::owned_feature_projection_complete(b, receiver)
+    {
+        return None;
+    }
+    let relationships = semantic_ownership::owned_relationships(b, receiver)?;
+    charge(steps, relationships.len()).ok()?;
+    let mut result = None;
+    let mut seen = HashSet::new();
+    for relationship in relationships.iter() {
+        if !seen.insert(relationship)
+            || semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)?
+                != Some(receiver)
+        {
+            return None;
+        }
+        if !conforms(b.elements[relationship].ty, "FeatureMembership") {
+            continue;
+        }
+        if b.elements[relationship].ty != "ReturnParameterMembership" || result.is_some() {
+            return None;
+        }
+        let feature = membership_evidence::member(b, raw, receiver, relationship, steps)?;
+        if b.elements[feature].ty != "Feature"
+            || membership_evidence::parameter_direction(b, raw, feature, steps)? != Some("out")
+            || membership_evidence::valuation(b, raw, feature, steps)?.is_some()
+        {
+            return None;
+        }
+        result = Some(feature);
+    }
+    result
+}
+
+/// An effective omitted default, selected by checked redefinition identity.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorDefaultBinding {
+    pub feature: ElementRef,
+    pub feature_with_value: ElementRef,
+    pub valuation: ElementRef,
+    pub value: ElementRef,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorDefaultReport {
+    pub defaults: Result<Vec<ConstructorDefaultBinding>, ConstructorBindingIssue>,
+    pub steps: usize,
+}
+impl ResolvedModel {
+    /// Prove omitted effective defaults separately from supplied arguments.
+    /// Conflicting defaults, cycles and unsupported contributions are qualified.
+    pub fn constructor_default_report(&mut self, receiver: ElementRef) -> ConstructorDefaultReport {
+        let mut steps = 0;
+        let defaults = (|| {
+            let arguments = self
+                .b
+                .checked_constructor_bindings(receiver.0, &mut steps, None)?;
+            self.b.checked_constructor_defaults(&arguments, &mut steps)
+        })();
+        ConstructorDefaultReport {
+            defaults: if steps > crate::eval::MAX_STEPS {
+                Err(WorkLimit)
+            } else {
+                defaults
+            },
+            steps,
+        }
+    }
+}
+impl super::Builder {
+    pub(super) fn checked_constructor_defaults(
+        &mut self,
+        arguments: &ConstructorBindings,
+        steps: &mut usize,
+    ) -> Result<Vec<ConstructorDefaultBinding>, ConstructorBindingIssue> {
+        self.checked_constructor_defaults_in_batch(
+            arguments,
+            steps,
+            &mut ConstructorBatchEvidence::default(),
+        )
+    }
+    pub(super) fn checked_constructor_defaults_in_batch(
+        &mut self,
+        arguments: &ConstructorBindings,
+        steps: &mut usize,
+        batch: &mut ConstructorBatchEvidence,
+    ) -> Result<Vec<ConstructorDefaultBinding>, ConstructorBindingIssue> {
+        let features = batch
+            .features(self, arguments.instantiated_type.0, steps)?
+            .features;
+        let retained = self
+            .retained_typing_edges(steps)
+            .ok_or(IncompleteProvider)?;
+        let raw = StoredStructure::for_query(self, steps).ok_or(IncompleteProvider)?;
+        let inverse = raw.typing(self, steps).ok_or(IncompleteProvider)?;
+        if !raw.ids_unique
+            || raw.annotations_incomplete
+            || inverse.sources_incomplete
+            || self.metadata_associations_incomplete
+        {
+            return Err(IncompleteProvider);
+        }
+        let stamp = Stamp::capture_builder(self);
+        charge(steps, arguments.bindings.len())?;
+        let supplied: HashSet<_> = arguments.bindings.iter().map(|b| b.feature.0).collect();
+        let mut defaults = Vec::new();
+        let mut memo = HashMap::new();
+        for feature in features {
+            charge(steps, 1)?;
+            if supplied.contains(&feature.0) {
+                continue;
+            }
+            if let Some((owner, valuation, value)) = self.constructor_effective_default(
+                feature.0,
+                &raw,
+                &retained,
+                &mut memo,
+                &mut HashSet::new(),
+                steps,
+            )? {
+                defaults.push(ConstructorDefaultBinding {
+                    feature,
+                    feature_with_value: ElementRef(owner),
+                    valuation: ElementRef(valuation),
+                    value: ElementRef(value),
+                });
+            }
+        }
+        if !stamp.current_builder(self) {
+            return Err(StaleEvidence);
+        }
+        Ok(defaults)
+    }
+    #[allow(clippy::too_many_arguments)]
+    fn constructor_effective_default(
+        &mut self,
+        feature: usize,
+        raw: &StoredStructure,
+        retained: &super::implied::RetainedTypings,
+        memo: &mut HashMap<usize, Option<(usize, usize, usize)>>,
+        active: &mut HashSet<usize>,
+        steps: &mut usize,
+    ) -> Result<Option<(usize, usize, usize)>, ConstructorBindingIssue> {
+        charge(steps, 1)?;
+        if let Some(value) = memo.get(&feature) {
+            return Ok(*value);
+        }
+        if active.len() >= super::MAX_RESOLUTION_DEPTH || !active.insert(feature) {
+            return Err(IncompleteProvider);
+        }
+        if raw.metadata_annotation_targets.contains(&feature)
+            || self
+                .metadata_of
+                .get(&feature)
+                .is_some_and(|m| !m.is_empty())
+            || !raw
+                .membership_domains(self, steps)
+                .ok_or(IncompleteProvider)?
+                .owner_complete(feature)
+        {
+            return Err(IncompleteProvider);
+        }
+        let valuation =
+            membership_evidence::valuation(self, raw, feature, steps).ok_or(InvalidRelationship)?;
+        let inverse = raw.typing(self, steps).ok_or(IncompleteProvider)?;
+        let owned =
+            semantic_ownership::owned_relationships(self, feature).ok_or(IncompleteProvider)?;
+        charge(steps, owned.len())?;
+        let owned: Vec<_> = owned.iter().collect();
+        let mut targets = Vec::new();
+        let mut seen = HashSet::new();
+        for relationship in owned.iter().copied().chain(
+            inverse
+                .relationships
+                .get(&feature)
+                .into_iter()
+                .flatten()
+                .copied(),
+        ) {
+            charge(steps, 1)?;
+            if !seen.insert(relationship) {
+                continue;
+            }
+            let kind = self.elements[relationship].ty;
+            if conforms(kind, "Conjugation") {
+                return Err(UnsupportedConfiguration);
+            }
+            if !conforms(kind, "Redefinition") {
+                continue;
+            }
+            if !owned.contains(&relationship)
+                || semantic_ownership::checked_relationship_carrier(self, raw, relationship, steps)
+                    != Some(Some(feature))
+                || !self.static_chain_row_current(relationship)
+                || !self.result_redefinition_row_current(relationship)
+            {
+                return Err(InvalidRelationship);
+            }
+            let target = type_relations::endpoint_with_carrier(
+                self,
+                feature,
+                Some(feature),
+                relationship,
+                &["specific", "subsettingFeature", "redefiningFeature"],
+                &["general", "subsettedFeature", "redefinedFeature"],
+                "Feature",
+                steps,
+            )
+            .ok_or(InvalidRelationship)?;
+            targets.push(target);
+        }
+        if let Some(implied) = retained.get(&feature) {
+            charge(steps, implied.len())?;
+            for &(kind, id) in implied {
+                if conforms(kind, "Redefinition") {
+                    targets.push(raw.element_for_uuid(self, id).ok_or(IncompleteProvider)?);
+                }
+            }
+        }
+        // A complete shared positional plan can imply redefinitions before
+        // physical materialization. These identities belong to the same
+        // provider used by Type.feature, never an independent lexical search.
+        if let Some(plan) = self.effective_dynamic_plan() {
+            if plan.positional.incomplete.contains(&feature) {
+                return Err(IncompleteProvider);
+            }
+            if let Some(implied) = plan.positional.targets.get(&feature) {
+                charge(steps, implied.len())?;
+                targets.extend(implied);
+            }
+        } else if let Some(plan) = &self.positional_redefinitions {
+            if plan.incomplete.contains(&feature) {
+                return Err(IncompleteProvider);
+            }
+            if let Some(implied) = plan.targets.get(&feature) {
+                charge(steps, implied.len())?;
+                targets.extend(implied);
+            }
+        } else {
+            return Err(IncompleteProvider);
+        }
+        let mut inherited = HashSet::new();
+        for target in targets {
+            if let Some(candidate) =
+                self.constructor_effective_default(target, raw, retained, memo, active, steps)?
+            {
+                inherited.insert(candidate);
+            }
+        }
+        let selected = if let Some((membership, value)) = valuation {
+            self.elements[membership]
+                .props
+                .get("isDefault")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false)
+                .then_some((feature, membership, value))
+        } else {
+            if inherited.len() > 1 {
+                return Err(UnsupportedConfiguration);
+            }
+            inherited.into_iter().next()
+        };
+        active.remove(&feature);
+        memo.insert(feature, selected);
+        Ok(selected)
+    }
+}
+
+/// Certified constructor-result obligations in the supported graph domain.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorResult {
+    pub arguments: ConstructorBindings,
+    pub defaults: Vec<ConstructorDefaultBinding>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConstructorResultReport {
+    pub result: Result<ConstructorResult, ConstructorBindingIssue>,
+    pub steps: usize,
+}
+impl ResolvedModel {
+    /// Check result specialization, unique public supplied bindings and all
+    /// supported omitted-default BindingConnector obligations. This does not
+    /// assert unrelated expression or whole-model validation constraints.
+    pub fn constructor_result_report(&mut self, receiver: ElementRef) -> ConstructorResultReport {
+        let mut steps = 0;
+        let result = (|| {
+            let arguments = self
+                .b
+                .checked_constructor_bindings(receiver.0, &mut steps, None)?;
+            let defaults = self
+                .b
+                .checked_constructor_defaults(&arguments, &mut steps)?;
+            let stamp = Stamp::capture(self);
+            let mut relations = type_relations::TypeRelations::default();
+            if relations.specializes(
+                &mut self.b,
+                arguments.result.0,
+                arguments.instantiated_type.0,
+                &mut steps,
+            ) != type_relations::RelationFact::Yes
+            {
+                return Err(IncompleteProvider);
+            }
+            for default in &defaults {
+                if !super::owned_results::constructor_default_present(
+                    &mut self.b,
+                    arguments.result.0,
+                    default,
+                    &mut steps,
+                ) {
+                    return Err(IncompleteProvider);
+                }
+            }
+            if !stamp.current(self) {
+                return Err(StaleEvidence);
+            }
+            Ok(ConstructorResult {
+                arguments,
+                defaults,
+            })
+        })();
+        ConstructorResultReport {
+            result: if steps > crate::eval::MAX_STEPS {
+                Err(WorkLimit)
+            } else {
+                result
+            },
+            steps,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::ClosurePolicy,
+        model::{GraphFormat, Model},
+    };
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+    fn fixture(source: &str, format: GraphFormat) -> (ResolvedModel, ElementRef) {
+        let mut model = Model::with_graph_format(format);
+        assert!(
+            model
+                .add_library_source("constructor-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let parsed = model.add_source("constructors.kerml", source);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let r = ResolvedModel::build(&model);
+        let expression = ElementRef(
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "ConstructorExpression")
+                .unwrap(),
+        );
+        (r, expression)
+    }
+    #[test]
+    fn named_arguments_follow_public_type_features_including_undirected_and_output() {
+        for arguments in ["b=2,a=1", "b=2", ""] {
+            let (mut r, expression) = fixture(
+                &format!(
+                    "class C {{ feature a; out feature b; private feature hidden; }} feature x = new C({arguments});"
+                ),
+                GraphFormat::CanonicalV3,
+            );
+            let a = r.resolve_qualified("C::a").unwrap();
+            let b = r.resolve_qualified("C::b").unwrap();
+            let report = r.constructor_binding_report(expression).arguments.unwrap();
+            assert_eq!(report.features, [a, b]);
+            let expected = match arguments {
+                "" => vec![],
+                "b=2" => vec![b],
+                _ => vec![a, b],
+            };
+            assert_eq!(
+                report
+                    .bindings
+                    .iter()
+                    .map(|b| b.feature)
+                    .collect::<Vec<_>>(),
+                expected
+            );
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            assert_eq!(
+                r.property(expression, "argument")
+                    .unwrap()
+                    .as_array()
+                    .unwrap()
+                    .len(),
+                report.bindings.len()
+            );
+            assert_eq!(
+                r.property(expression, "result").unwrap(),
+                serde_json::json!({"@id":r.element_id(report.result)})
+            );
+            assert_eq!(
+                r.property(expression, "instantiatedType").unwrap(),
+                serde_json::json!({"@id":r.element_id(report.instantiated_type)})
+            );
+        }
+    }
+    #[test]
+    fn inherited_features_and_omissions_keep_complete_order() {
+        let (mut r, expression) = fixture(
+            "class A {feature a; feature b;} class C specializes A; feature x = new C(b=2);",
+            GraphFormat::CanonicalV3,
+        );
+        let b = r.resolve_qualified("A::b").unwrap();
+        let report = r.constructor_binding_report(expression).arguments.unwrap();
+        assert_eq!(report.bindings.len(), 1);
+        assert_eq!(report.bindings[0].feature, b);
+    }
+    #[test]
+    fn full_export_uses_the_same_supplied_argument_order_including_omissions() {
+        for arguments in ["b=2", "b=2,a=1", ""] {
+            let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+            model.add_library_source("constructor-library.kerml", LIB);
+            model.add_source(
+                "constructors.kerml",
+                &format!("class C {{feature a; out feature b;}} feature call=new C({arguments});"),
+            );
+            let mut r = ResolvedModel::build(&model);
+            let expression = r
+                .user_elements()
+                .find(|&e| r.element_type(e) == "ConstructorExpression")
+                .unwrap();
+            let report = r.constructor_binding_report(expression).arguments.unwrap();
+            let values: Vec<_> = report
+                .bindings
+                .iter()
+                .map(|binding| serde_json::json!({"@id":r.element_id(binding.value)}))
+                .collect();
+            let full = crate::full::model_to_full_json(&model);
+            let row = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|row| row["@type"] == "ConstructorExpression")
+                .unwrap();
+            assert_eq!(row["argument"], serde_json::json!(values), "{arguments}");
+        }
+    }
+    #[test]
+    fn canonical_full_carrier_defaults_do_not_overwrite_explicit_payload_values() {
+        let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+        model.add_source("constructors.kerml", "class C; feature call=new C();");
+        let original = crate::json::model_to_compact_json(&model);
+        let membership = original
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|row| row["@type"] == "ReturnParameterMembership")
+            .unwrap();
+        let result_id = membership["ownedRelatedElement"][0]["@id"]
+            .as_str()
+            .unwrap();
+        for stored in [
+            None,
+            Some(serde_json::Value::Null),
+            Some(serde_json::json!(false)),
+            Some(serde_json::json!("malformed")),
+        ] {
+            let mut compact = original.clone();
+            if let Some(value) = stored.clone() {
+                compact
+                    .as_array_mut()
+                    .unwrap()
+                    .iter_mut()
+                    .find(|row| row["@id"] == result_id)
+                    .unwrap()["isUnique"] = value;
+            }
+            let mut r = ResolvedModel::build(&model);
+            let full = crate::full::resolved_compact_to_full_json(
+                &mut r,
+                &model,
+                compact,
+                crate::full::EmissionPolicy::default(),
+            )
+            .unwrap();
+            let result = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|row| row["@id"] == result_id)
+                .unwrap();
+            assert_eq!(
+                result["isUnique"],
+                stored.unwrap_or(serde_json::json!(true))
+            );
+        }
+    }
+    #[test]
+    fn private_duplicate_unknown_and_positional_arguments_are_qualified() {
+        for arguments in ["hidden=1", "a=1,a=2", "missing=1", "1"] {
+            let (mut r, expression) = fixture(
+                &format!(
+                    "class C {{feature a; private feature hidden;}} feature x=new C({arguments});"
+                ),
+                GraphFormat::CanonicalV3,
+            );
+            assert!(
+                r.constructor_binding_report(expression).arguments.is_err(),
+                "{arguments}"
+            );
+            assert!(r.constructor_selection_report(expression).selection.is_ok());
+        }
+    }
+    #[test]
+    fn positional_arguments_use_admitted_public_feature_order() {
+        for (declarations, arguments, names) in [
+            (
+                "class C {private feature hidden; feature a; out feature b;}",
+                "1,2",
+                vec!["C::a", "C::b"],
+            ),
+            (
+                "class A {feature a; feature b;} class C specializes A;",
+                "1,2",
+                vec!["A::a", "A::b"],
+            ),
+            ("class C {feature a; feature b;}", "1", vec!["C::a"]),
+        ] {
+            let (mut r, expression) = fixture(
+                &format!("{declarations} feature x=new C({arguments});"),
+                GraphFormat::CanonicalV3,
+            );
+            assert!(r.constructor_binding_report(expression).arguments.is_err());
+            let expected: Vec<_> = names
+                .iter()
+                .map(|name| r.resolve_qualified(name).unwrap())
+                .collect();
+            let _ = r.implied_relationships(expression);
+            let report = r.constructor_binding_report(expression).arguments.unwrap();
+            assert_eq!(
+                report
+                    .bindings
+                    .iter()
+                    .map(|b| b.feature)
+                    .collect::<Vec<_>>(),
+                expected
+            );
+            assert_eq!(
+                r.model_level_evaluability(expression).classification,
+                crate::json::ModelLevelEvaluability::Evaluable
+            );
+        }
+    }
+    #[test]
+    fn constructor_evaluability_uses_complete_shared_arguments() {
+        use crate::json::ModelLevelEvaluability::{Evaluable, NotEvaluable, Unknown};
+        for arguments in ["", "b=2", "b=2,a=1"] {
+            let (mut r, expression) = fixture(
+                &format!("class C {{feature a; feature b;}} feature x=new C({arguments});"),
+                GraphFormat::CanonicalV3,
+            );
+            assert_eq!(
+                r.model_level_evaluability(expression).classification,
+                Evaluable
+            );
+            if let Some(binding) = r
+                .constructor_binding_report(expression)
+                .arguments
+                .unwrap()
+                .bindings
+                .first()
+            {
+                r.b.elements[binding.value.0].ty = "CalculationUsage";
+                assert_eq!(
+                    r.model_level_evaluability(expression).classification,
+                    NotEvaluable
+                );
+            }
+        }
+        for arguments in ["missing=1", "a=1,a=2", "1,2,3"] {
+            let (mut r, expression) = fixture(
+                &format!("class C {{feature a; feature b;}} feature x=new C({arguments});"),
+                GraphFormat::CanonicalV3,
+            );
+            let _ = r.implied_relationships(expression);
+            assert!(matches!(
+                r.model_level_evaluability(expression).classification,
+                Unknown(_)
+            ));
+        }
+    }
+    #[test]
+    fn omitted_defaults_publish_checked_binding_connectors_under_result() {
+        for (declarations, arguments, expected) in [
+            ("class C {feature a default = 1; feature b;}", "", 1),
+            (
+                "class C {private feature hidden default = 1; feature a;}",
+                "",
+                1,
+            ),
+            ("class C {feature a = 1;}", "", 0),
+            ("class C {feature a default = 1; feature b;}", "a=2", 0),
+            (
+                "class A {feature a default = 1;} class C specializes A;",
+                "",
+                1,
+            ),
+            (
+                "class A {feature a default = 1;} class C specializes A {feature b redefines a;}",
+                "",
+                1,
+            ),
+            (
+                "class A {feature a default = 1;} class C specializes A {feature b redefines a = 2;}",
+                "",
+                0,
+            ),
+        ] {
+            let (mut r, expression) = fixture(
+                &format!("{declarations} feature x=new C({arguments});"),
+                GraphFormat::CanonicalV3,
+            );
+            let defaults = r.constructor_default_report(expression).defaults.unwrap();
+            assert_eq!(defaults.len(), expected, "{declarations}");
+            assert!(r.constructor_result_report(expression).result.is_err());
+            let _ = r.implied_relationships(expression);
+            let result = r.constructor_result_report(expression).result.unwrap();
+            assert_eq!(result.defaults, defaults);
+            assert_eq!(
+                r.model_level_evaluability(expression).classification,
+                crate::json::ModelLevelEvaluability::Evaluable
+            );
+            if let Some(default) = defaults.first() {
+                let valuation = default.valuation.0;
+                r.b.elements[valuation]
+                    .props
+                    .insert("isDefault", serde_json::Value::Null);
+                assert!(r.constructor_default_report(expression).defaults.is_err());
+                assert!(r.constructor_result_report(expression).result.is_err());
+            }
+        }
+    }
+    #[test]
+    fn conflicting_and_cyclic_default_paths_are_not_first_found_guesses() {
+        for declarations in [
+            "class C {feature a default = 1; feature b default = 2; feature c redefines a, b;}",
+            "class C {feature a redefines b; feature b redefines a;}",
+        ] {
+            let (mut r, expression) = fixture(
+                &format!("{declarations} feature x=new C();"),
+                GraphFormat::CanonicalV3,
+            );
+            assert!(r.constructor_default_report(expression).defaults.is_err());
+            let _ = r.implied_relationships(expression);
+            assert!(r.constructor_result_report(expression).result.is_err());
+        }
+    }
+    #[test]
+    fn constructor_obligations_replay_across_prepared_library_paths() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut base = Model::with_graph_format(GraphFormat::CanonicalV3);
+        base.add_library_source("constructor-library.kerml", LIB);
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(143).unwrap(), 143).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut m = Model::with_graph_format(GraphFormat::CanonicalV3);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("constructor-library.kerml", LIB);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            m.add_source(
+                "constructors.kerml",
+                "class C {feature a; feature b default = 2;} feature x=new C(1);",
+            );
+            let mut r = ResolvedModel::build(&m);
+            let expression = r
+                .elements()
+                .find(|&e| r.element_type(e) == "ConstructorExpression")
+                .unwrap();
+            let full = crate::full::resolved_to_full_json(&mut r, &m, Default::default()).unwrap();
+            let report = r.constructor_result_report(expression).result.unwrap();
+            assert_eq!(report.arguments.bindings.len(), 1);
+            assert_eq!(report.defaults.len(), 1);
+            let ids = (
+                r.element_id(report.arguments.bindings[0].feature),
+                r.element_id(report.defaults[0].value),
+            );
+            if let Some(expected) = expected {
+                assert_eq!(ids, expected);
+            } else {
+                expected = Some(ids);
+            }
+            assert_eq!(
+                crate::full::resolved_to_full_json(&mut r, &m, Default::default()).unwrap(),
+                full
+            );
+        }
+    }
+    #[test]
+    fn constructor_batch_reuses_success_and_rejects_same_length_source_changes() {
+        let (mut r, expression) = fixture(
+            "class C {feature a;} feature x=new C(1);",
+            GraphFormat::CanonicalV3,
+        );
+        let mut batch = ConstructorBatchEvidence::default();
+        let mut steps = 0;
+        let first =
+            r.b.checked_constructor_bindings_in_batch(
+                expression.0,
+                &mut steps,
+                Some(&mut HashMap::new()),
+                &mut batch,
+            )
+            .unwrap();
+        let cold = steps;
+        steps = 0;
+        assert_eq!(
+            r.b.checked_constructor_bindings_in_batch(
+                expression.0,
+                &mut steps,
+                Some(&mut HashMap::new()),
+                &mut batch
+            )
+            .unwrap(),
+            first
+        );
+        assert!(steps < cold);
+        let member = r.b.elements[first.features[0].0]
+            .owning_relationship
+            .unwrap();
+        r.b.elements[member]
+            .props
+            .insert("visibility", serde_json::json!("private"));
+        assert!(
+            r.b.checked_constructor_bindings_in_batch(
+                expression.0,
+                &mut 0,
+                Some(&mut HashMap::new()),
+                &mut batch
+            )
+            .is_err()
+        );
+    }
+    #[test]
+    fn legacy_constructor_shape_is_not_reinterpreted() {
+        let (mut r, expression) = fixture(
+            "class C {feature a;} feature x = new C(a=1);",
+            GraphFormat::LegacyV2,
+        );
+        assert_eq!(
+            r.constructor_binding_report(expression).arguments,
+            Err(UnsupportedConfiguration)
+        );
+        assert_eq!(
+            r.constructor_selection_report(expression).selection,
+            Err(UnsupportedConfiguration)
+        );
+    }
+
+    #[test]
+    fn selected_result_refuses_incomplete_or_targeted_metadata() {
+        for mode in 0..3 {
+            let (mut r, expression) =
+                fixture("class C; feature call=new C();", GraphFormat::CanonicalV3);
+            let result = r
+                .constructor_selection_report(expression)
+                .selection
+                .unwrap()
+                .result;
+            match mode {
+                0 => r.b.metadata_associations_incomplete = true,
+                1 => {
+                    r.b.metadata_of.insert(expression.0, vec![expression.0]);
+                }
+                _ => {
+                    r.b.metadata_of.insert(result.0, vec![result.0]);
+                }
+            }
+            assert_eq!(
+                r.constructor_selection_report(expression).selection,
+                Err(IncompleteProvider)
+            );
+            r.b.metadata_associations_incomplete = false;
+            r.b.metadata_of = Default::default();
+            assert!(r.constructor_selection_report(expression).selection.is_ok());
+        }
+    }
+    #[test]
+    fn malformed_same_length_edits_and_work_limits_do_not_reuse_success() {
+        for key in [
+            "ownedMemberParameter",
+            "redefinedFeature",
+            "isDefault",
+            "visibility",
+        ] {
+            let (mut r, expression) = fixture(
+                "class C {feature a;} feature x = new C(a=1);",
+                GraphFormat::CanonicalV3,
+            );
+            let report = r.constructor_binding_report(expression).arguments.unwrap();
+            let binding = &report.bindings[0];
+            let row = match key {
+                "ownedMemberParameter" => r.b.elements[binding.parameter.0]
+                    .owning_relationship
+                    .unwrap(),
+                "visibility" => r.b.elements[binding.feature.0].owning_relationship.unwrap(),
+                _ => r.b.elements[binding.parameter.0]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&i| {
+                        r.b.elements[i].ty
+                            == if key == "isDefault" {
+                                "FeatureValue"
+                            } else {
+                                "Redefinition"
+                            }
+                    })
+                    .unwrap(),
+            };
+            r.b.elements[row].props.insert(key, serde_json::Value::Null);
+            assert!(
+                r.constructor_binding_report(expression).arguments.is_err(),
+                "{key}"
+            );
+        }
+        let (mut r, expression) = fixture(
+            "class C {feature a;} feature x = new C(a=1);",
+            GraphFormat::CanonicalV3,
+        );
+        assert_eq!(
+            r.constructor_binding_report_with_budget(expression, crate::eval::MAX_STEPS)
+                .arguments,
+            Err(WorkLimit)
+        );
+        assert!(r.constructor_binding_report(expression).arguments.is_ok());
+    }
+    #[test]
+    fn first_wrong_kind_selector_is_never_skipped() {
+        let (mut r, expression) = fixture(
+            "class C {feature a;} feature x = new C(a=1);",
+            GraphFormat::CanonicalV3,
+        );
+        let report = r.constructor_binding_report(expression).arguments.unwrap();
+        let selector = r.b.elements[expression.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| r.b.elements[i].ty == "Membership")
+            .unwrap();
+        let wrong = r.b.elements[report.result.0].owning_relationship.unwrap();
+        let wrong_id = r.b.elements[wrong].id;
+        r.b.elements[selector]
+            .props
+            .insert("memberElement", serde_json::json!({"@id":wrong_id}));
+        assert!(
+            r.constructor_selection_report(expression)
+                .selection
+                .is_err()
+        );
+        assert!(r.constructor_binding_report(expression).arguments.is_err());
+    }
+    #[test]
+    fn shared_dynamic_publisher_installs_constructor_result_specialization() {
+        let (mut r, expression) = fixture(
+            "class C {feature a;} feature x = new C(a=1);",
+            GraphFormat::CanonicalV3,
+        );
+        let report = r.constructor_binding_report(expression).arguments.unwrap();
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let _ = r.implied_relationships(expression);
+        let target = r.element_id(report.instantiated_type);
+        let relationships = semantic_ownership::owned_relationships(&r.b, report.result.0).unwrap();
+        assert!(relationships.iter().any(|i| {
+            r.b.elements[i].ty == "FeatureTyping"
+                && r.b.elements[i]
+                    .props
+                    .get("type")
+                    .and_then(|v| v.as_reference())
+                    == Some(target)
+        }));
+        assert_eq!(
+            r.constructor_binding_report(expression).arguments.unwrap(),
+            report
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/derived.rs b/crates/sysmlv2-model/src/json/derived.rs
index c08989d..15680e8 100644
--- a/crates/sysmlv2-model/src/json/derived.rs
+++ b/crates/sysmlv2-model/src/json/derived.rs
@@ -40,7 +40,7 @@ use uuid::Uuid;
 /// value" from "a value it has no element for". The full form spells an
 /// `External` id as it is and an `Unresolved` spelling as the dangling id
 /// the unresolved-reference policy derives from it.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[non_exhaustive]
 pub enum Reference {
     /// An element of the model.
@@ -138,7 +138,9 @@ pub enum Derives {
     Exact,
 }
 
-/// The names this module computes exactly (sorted; binary-searched).
+/// Handwritten computations with exact default fidelity (sorted). Explicit
+/// dependency qualifications below can downgrade a name without changing the
+/// public computed-name traversal order or the compatibility dispatch.
 const EXACT: &[&str] = &[
     "annotatedElement",
     "annotatingElement",
@@ -320,9 +322,13 @@ const PASSTHROUGH: &[&str] = &[
 /// related features past the source; `FeatureChainExpression::targetFeature`
 /// the accessed feature; `RequirementVerificationMembership::verifiedRequirement`
 /// one referenced requirement, a verification case's the list its
-/// objective verifies): computed, with the listed fidelity, only where
-/// the metaclass conforms to a listed kind.
+/// objective verifies): computed with the listed fidelity where the metaclass
+/// conforms to a listed kind. A name otherwise provided by a generated
+/// composition keeps that composition on its other declaring metaclasses.
 const HAND_WRITTEN_ON: &[(&str, &str, Derives)] = &[
+    ("portDefinition", "ConjugatedPortTyping", Derives::Exact),
+    ("relatedElement", "Connector", Derives::Passthrough),
+    ("relatedElement", "Relationship", Derives::Exact),
     ("targetFeature", "Connector", Derives::Passthrough),
     ("targetFeature", "FeatureChainExpression", Derives::Exact),
     (
@@ -487,6 +493,19 @@ fn composition(name: &str) -> Option<(&'static str, &'static str, bool)> {
         .map(|i| (COMPOSITIONS[i].1, COMPOSITIONS[i].2, COMPOSITIONS[i].3))
 }
 
+/// The generated composition applicable to this declaration. A same-named
+/// hand-written property or membership-side reference has its own derivation
+/// and must not borrow the composition's base chain or collection shape.
+fn composition_on(metaclass: &str, name: &str) -> Option<(&'static str, &'static str, bool)> {
+    composition(name).filter(|_| {
+        !is_hand_written(name)
+            && member_side(metaclass, name).is_none()
+            && !HAND_WRITTEN_ON
+                .iter()
+                .any(|(n, kind, _)| *n == name && conforms(metaclass, kind))
+    })
+}
+
 /// Whether `metaclass` carries the property `name` at all (owned or
 /// derived), per the schema catalog.
 fn carries(metaclass: &str, name: &str) -> bool {
@@ -517,6 +536,21 @@ fn declared(metaclass: &str, name: &str) -> bool {
             .any(|(n, classes)| *n == name && classes.contains(&metaclass))
 }
 
+/// These compatibility readers depend on Feature.type's incomplete graph.
+/// Keep their dispatch-list position stable; only fidelity changes. Generated
+/// kind-filtered compositions inherit the same qualification from their base.
+const TYPE_DEPENDENT: &[&str] = &[
+    "association",
+    "definition",
+    "function",
+    "individualDefinition",
+    "interaction",
+    "metaclass",
+    "payloadType",
+    "predicate",
+    "type",
+];
+
 /// The fidelity of a declared `name` on `metaclass`: hand-written names
 /// by their list; a composition by its base's fidelity *on the same
 /// metaclass* — the same name is a different property on a metaclass
@@ -532,17 +566,19 @@ fn fidelity(metaclass: &str, name: &str, depth: usize) -> Derives {
         .iter()
         .filter(|(n, _, _)| *n == name)
         .collect();
-    if !gated.is_empty() {
-        return gated
-            .iter()
-            .find(|(_, kind, _)| conforms(metaclass, kind))
-            .map_or(Derives::NotComputed, |(_, _, f)| *f);
+    if let Some((_, _, fidelity)) = gated.iter().find(|(_, kind, _)| conforms(metaclass, kind)) {
+        return *fidelity;
     }
-    if is_exact(name) {
+    if !gated.is_empty() && is_hand_written(name) {
+        return Derives::NotComputed;
+    }
+    if TYPE_DEPENDENT.binary_search(&name).is_ok() {
+        Derives::Passthrough
+    } else if is_exact(name) {
         Derives::Exact
     } else if is_passthrough(name) {
         Derives::Passthrough
-    } else if let Some((base, _, _)) = composition(name) {
+    } else if let Some((base, _, _)) = composition_on(metaclass, name) {
         if depth > 8 {
             return Derives::NotComputed;
         }
@@ -582,37 +618,15 @@ pub fn derives(metaclass: &str, name: &str) -> Derives {
     derives_under(metaclass, name, super::ClosurePolicy::Passthrough)
 }
 
-/// Passthrough names whose approximation is not the closure and that
-/// no policy makes exact: `isModelLevelEvaluable` (the library-function
-/// over-approximation), `exposedElement` (the exposed namespaces' own
-/// members, not their imported and inherited memberships) and
-/// `defaultFeaturingType` (the omitted `specializes` clauses).
-const APPROXIMATE: &[&str] = &[
-    "defaultFeaturingType",
-    "exposedElement",
-    "isModelLevelEvaluable",
-];
-
-/// [`derives`] under a closure policy: with the closures in force *and
-/// the implied heritage included* ([`super::ClosurePolicy::Closure`] with
-/// `include_implied: true` — the specification's `inheritedMemberships`
-/// does not exclude the implied heritage) every passthrough name but
-/// `defaultFeaturingType`, `exposedElement` and `isModelLevelEvaluable`
-/// is computed as specified and answers
-/// `Exact`; the written-heritage tier (`include_implied: false`) is a
-/// documented deviation and stays `Passthrough`.
-pub fn derives_under(metaclass: &str, name: &str, policy: super::ClosurePolicy) -> Derives {
+/// Fidelity under a closure policy. A closure changes the available values,
+/// not the completeness of their derivation: implied redefinitions and some
+/// import/inheritance cases are not fully implemented. Such properties remain
+/// `Passthrough` under every policy until their semantic dependencies are exact.
+pub fn derives_under(metaclass: &str, name: &str, _policy: super::ClosurePolicy) -> Derives {
     if !declared(metaclass, name) {
         return Derives::NotDeclared;
     }
-    match fidelity(metaclass, name, 0) {
-        Derives::Passthrough
-            if policy.include_implied() == Some(true) && !APPROXIMATE.contains(&name) =>
-        {
-            Derives::Exact
-        }
-        f => f,
-    }
+    fidelity(metaclass, name, 0)
 }
 
 /// Every derived name this module can answer on some metaclass: the
@@ -703,7 +717,15 @@ impl ResolvedModel {
     /// arm, so callers hold the invariant.
     pub(crate) fn derived_computable(&mut self, e: ElementRef, name: &str) -> Derived {
         let ty = self.b.elements[e.0].ty;
+        if ty == "FeatureReferenceExpression" {
+            self.ensure_implied();
+        }
         use DerivedValue as V;
+        // The typing-side original is a single reference, unlike PortUsage's
+        // same-named definition list generated below.
+        if conforms(ty, "ConjugatedPortTyping") && name == "portDefinition" {
+            return Derived::Value(opt(self.d_typing_port_definition(e)));
+        }
         // A membership-side reference: the owned member.
         if member_side(ty, name).is_some() {
             return Derived::Value(opt(self.d_owned_member_element(e)));
@@ -712,7 +734,7 @@ impl ResolvedModel {
         // wins (`ownedMembership` is spelled as a composition over the
         // owned relationships but computed directly): the base's list
         // filtered by kind.
-        if let Some((base, kind, single)) = composition(name).filter(|_| !is_hand_written(name)) {
+        if let Some((base, kind, single)) = composition_on(ty, name) {
             // A composition keeps its base's shape; over a reference-typed
             // base, a target outside the model passes the kind filter as
             // it is (see [`ResolvedModel::cast`]).
@@ -729,7 +751,7 @@ impl ResolvedModel {
                     Derived::Value(V::Element(x)) => (vec![Reference::Element(x)], false),
                     Derived::Value(V::References(items)) => (items, true),
                     Derived::Value(V::Reference(r)) => (vec![r], true),
-                    Derived::Value(V::Null) => (Vec::new(), by_reference_base(base)),
+                    Derived::Value(V::Null) => (Vec::new(), by_reference_base(ty, base)),
                     _ => return Derived::NotComputed,
                 }
             };
@@ -974,6 +996,12 @@ impl ResolvedModel {
                 .d_owned_specializations(e, "CrossSubsetting")
                 .into_iter()
                 .next()),
+            // Connector::relatedFeature redefines relatedElement as a
+            // non-unique sequence. Its targetFeature is an ordered set, so
+            // source + target cannot reconstruct repeated n-ary endpoints.
+            "relatedElement" if self.is_kind(e, "Connector") => {
+                V::References(self.d_related_features(e))
+            }
             "relatedElement" => {
                 let (mut source, target) = self.relationship_ends(e);
                 source.extend(target);
@@ -985,9 +1013,22 @@ impl ResolvedModel {
                 V::Elements(self.d_ends(features))
             }
             "relatedFeature" => V::References(self.d_related_features(e)),
-            "sourceFeature" => opt_ref(self.d_related_features(e).into_iter().next()),
+            "sourceFeature" => opt_ref(
+                self.d_related_feature_positions(e)
+                    .into_iter()
+                    .next()
+                    .flatten(),
+            ),
             "targetFeature" => {
-                V::References(self.d_related_features(e).into_iter().skip(1).collect())
+                let mut seen = std::collections::HashSet::new();
+                V::References(
+                    self.d_related_feature_positions(e)
+                        .into_iter()
+                        .skip(1)
+                        .flatten()
+                        .filter(|r| seen.insert(r.clone()))
+                        .collect(),
+                )
             }
             "sourceOutputFeature" => opt(self.d_flow_end_feature(e, 0)),
             "targetInputFeature" => opt(self.d_flow_end_feature(e, 1)),
@@ -1069,7 +1110,7 @@ impl ResolvedModel {
     }
 
     /// `Element::owningNamespace = owningMembership.membershipOwningNamespace`.
-    fn d_owning_namespace(&mut self, e: ElementRef) -> Option<ElementRef> {
+    pub(super) fn d_owning_namespace(&mut self, e: ElementRef) -> Option<ElementRef> {
         let m = self.d_owning_membership(e)?;
         self.d_owning_related_element(m)
     }
@@ -1077,10 +1118,9 @@ impl ResolvedModel {
     /// `Element::ownedElement = ownedRelationship.ownedRelatedElement`, in
     /// relationship order then related-element order.
     fn d_owned_elements(&self, e: ElementRef) -> Vec<ElementRef> {
-        self.b.elements[e.0]
-            .owned_relationships
-            .iter()
-            .flat_map(|&r| self.b.elements[r].children.iter().copied())
+        self.projected_owned_relationships(e)
+            .into_iter()
+            .flat_map(|r| self.b.elements[r.0].children.iter().copied())
             .map(ElementRef)
             .collect()
     }
@@ -1092,12 +1132,9 @@ impl ResolvedModel {
         e: ElementRef,
         general: &str,
     ) -> Vec<ElementRef> {
-        self.b.elements[e.0]
-            .owned_relationships
-            .iter()
-            .copied()
-            .filter(|&r| conforms(self.b.elements[r].ty, general))
-            .map(ElementRef)
+        self.projected_owned_relationships(e)
+            .into_iter()
+            .filter(|r| conforms(self.b.elements[r.0].ty, general))
             .collect()
     }
 
@@ -1224,12 +1261,23 @@ impl ResolvedModel {
     /// its source side taking the owner as its source. Both are *owned*
     /// properties of Relationship in the abstract syntax (derived only on
     /// `TransitionUsage`), so [`Self::derived`] does not answer them;
-    /// this is their navigation accessor, and the derived
-    /// `relatedElement` is their union. A target outside the model is
+    /// this is their navigation accessor. Connector source/target use its
+    /// sourceFeature/targetFeature projections; its relatedElement retains
+    /// the full non-unique relatedFeature sequence. A target outside the model is
     /// reported as such; empty for an element that is no relationship.
     pub fn relationship_ends(&mut self, e: ElementRef) -> (Vec<Reference>, Vec<Reference>) {
         self.ensure_by_id();
         let t = self.b.elements[e.0].ty;
+        if conforms(t, "Connector") {
+            let mut related = self.d_related_feature_positions(e).into_iter();
+            let source = related.next().flatten().into_iter().collect();
+            let mut seen = std::collections::HashSet::new();
+            let targets = related
+                .flatten()
+                .filter(|r| seen.insert(r.clone()))
+                .collect();
+            return (source, targets);
+        }
         let owner = self.d_owning_related_element(e).map(Reference::Element);
         let get = |this: &Self, key: &str| -> Option<Reference> {
             this.b.elements[e.0]
@@ -1545,12 +1593,13 @@ impl ResolvedModel {
     /// `Feature::type`: the targets of the feature's own typings
     /// (`FeatureTyping`, `ConjugatedPortTyping`) and, transitively, of its
     /// typing features — the features it subsets, redefines or references
-    /// through an owned Subsetting kind, and the last link of an owned
-    /// feature chain (KerML `Feature::typingFeatures`, closed). A typing
-    /// target outside the model (a library type when no library is
-    /// loaded) is reported as such; the walk through typing features stays
-    /// inside the model (library features included when loaded) and
-    /// guards cycles.
+    /// through an owned Subsetting kind, the features it redefines by
+    /// position (an implied Redefinition of another user feature), and the
+    /// last link of an owned feature chain (KerML `Feature::typingFeatures`,
+    /// closed). A typing target outside the model (a library type when no
+    /// library is loaded) is reported as such; the walk through typing
+    /// features stays inside the model (library features included when
+    /// loaded) and guards cycles.
     pub(super) fn d_types(&mut self, e: ElementRef) -> Vec<Reference> {
         self.ensure_by_id();
         let mut out: Vec<Reference> = Vec::new();
@@ -1560,19 +1609,34 @@ impl ResolvedModel {
             if !visited.insert(f) {
                 continue;
             }
-            // The explicit relationships and the implied *typings* (a
-            // variant's typing by its variation definition). The implied
-            // library subsettings are deliberately not followed: they
-            // would append the library chain (`Part`, `Item`, `Occurrence`,
-            // `Anything`) to every usage's types, a growth that belongs
-            // with the inheritance closure policy and its measurement.
+            // The explicit relationships, the implied *typings* (a
+            // variant's typing by its variation definition) and the implied
+            // *redefinitions* of user features (a parameter, end or result
+            // paired by position with its general's: `in q;` first under
+            // `Swapped :> A` is typed as `A`'s first parameter is). The
+            // implied library subsettings and redefinitions are deliberately
+            // not followed: they would append the library chain (`Part`,
+            // `Item`, `Occurrence`, `Anything`) to every usage's types, a
+            // growth that belongs with the inheritance closure policy and
+            // its measurement.
             let mut rels: Vec<usize> = self.b.elements[f].owned_relationships.to_vec();
-            rels.extend(
-                self.implied_relationships(ElementRef(f))
-                    .into_iter()
-                    .map(|r| r.0)
-                    .filter(|&r| self.b.elements[r].ty == "FeatureTyping"),
-            );
+            let implied: Vec<usize> = self
+                .implied_relationships(ElementRef(f))
+                .into_iter()
+                .map(|r| r.0)
+                .collect();
+            for r in implied {
+                let follows = match self.b.elements[r].ty {
+                    "FeatureTyping" => true,
+                    "Redefinition" => self
+                        .prop_target(r, "redefinedFeature")
+                        .is_some_and(|target| !self.is_library_element(ElementRef(target))),
+                    _ => false,
+                };
+                if follows {
+                    rels.push(r);
+                }
+            }
             let mut last_chain: Option<usize> = None;
             for r in rels {
                 let ty = self.b.elements[r].ty;
@@ -1651,18 +1715,25 @@ impl ResolvedModel {
     /// connector ends (`connectorEnd.ownedReferenceSubsetting.referencedFeature`),
     /// in end order; an end without a reference subsetting contributes
     /// nothing, a target outside the model is reported as such.
-    /// `sourceFeature` is the first, `targetFeature` the rest.
+    /// Source/target projections retain the original end positions even when
+    /// this compatibility sequence omits a missing reference.
     pub(super) fn d_related_features(&mut self, e: ElementRef) -> Vec<Reference> {
+        self.d_related_feature_positions(e)
+            .into_iter()
+            .flatten()
+            .collect()
+    }
+
+    fn d_related_feature_positions(&mut self, e: ElementRef) -> Vec<Option<Reference>> {
         self.ensure_by_id();
         let features = self.d_features(e);
-        let ends = self.d_ends(features);
-        ends.into_iter()
-            .filter_map(|end| {
-                self.owned_relationships_of_kind(end, "ReferenceSubsetting")
+        self.d_ends(features)
+            .into_iter()
+            .map(|end| {
+                let r = self
+                    .d_owned_specializations(end, "ReferenceSubsetting")
                     .into_iter()
-                    .next()
-            })
-            .filter_map(|r| {
+                    .next()?;
                 self.b.elements[r.0]
                     .props
                     .get("referencedFeature")
@@ -1775,7 +1846,7 @@ impl ResolvedModel {
 
 /// Whether a composition base answers by reference (so an empty base
 /// yields an empty `References` rather than `Elements`).
-fn by_reference_base(base: &str) -> bool {
+fn by_reference_base(metaclass: &str, base: &str) -> bool {
     matches!(
         base,
         "type"
@@ -1787,7 +1858,7 @@ fn by_reference_base(base: &str) -> bool {
             | "function"
             | "instantiatedType"
             | "referent"
-    ) || composition(base).is_some_and(|(b, _, _)| by_reference_base(b))
+    ) || composition_on(metaclass, base).is_some_and(|(b, _, _)| by_reference_base(metaclass, b))
 }
 
 fn opt(e: Option<ElementRef>) -> DerivedValue {
@@ -1827,6 +1898,7 @@ mod tests {
 
     #[test]
     fn hand_written_tables_are_sorted() {
+        assert!(super::TYPE_DEPENDENT.windows(2).all(|w| w[0] < w[1]));
         assert!(super::EXACT.windows(2).all(|w| w[0] < w[1]));
         assert!(super::PASSTHROUGH.windows(2).all(|w| w[0] < w[1]));
         let mut seen = std::collections::HashSet::new();
@@ -1840,21 +1912,14 @@ mod tests {
     /// declared there.
     #[test]
     fn composition_fidelity_follows_the_declared_base_chain() {
-        use super::{Derives, OWNED_BASES, carries, composition, declared, derives, member_side};
+        use super::{Derives, OWNED_BASES, carries, composition_on, declared, derives};
         for (m, _) in crate::schema_props::METACLASS_PROPS {
             for name in super::computed_names() {
                 if !matches!(derives(m, name), Derives::Exact | Derives::Passthrough) {
                     continue;
                 }
-                // A membership-side name is the owned member there, not the
-                // composition of the same name on the owner.
-                if member_side(m, name).is_some() {
-                    continue;
-                }
                 let mut at = name;
-                while let Some((base, _, _)) =
-                    composition(at).filter(|_| !super::is_hand_written(at))
-                {
+                while let Some((base, _, _)) = composition_on(m, at) {
                     if OWNED_BASES.contains(&base) {
                         assert!(
                             carries(m, base),
@@ -1869,6 +1934,24 @@ mod tests {
         }
     }
 
+    #[test]
+    fn port_definition_declarations_keep_their_distinct_derivations() {
+        use super::{Derives, composition_on, derives};
+        assert_eq!(
+            composition_on("ConjugatedPortTyping", "portDefinition"),
+            None
+        );
+        assert_eq!(
+            composition_on("PortUsage", "portDefinition"),
+            Some(("definition", "PortDefinition", false))
+        );
+        assert_eq!(
+            derives("ConjugatedPortTyping", "portDefinition"),
+            Derives::Exact
+        );
+        assert_eq!(derives("PortUsage", "portDefinition"), Derives::Passthrough);
+    }
+
     #[test]
     fn computed_names_are_declared_somewhere() {
         for name in super::computed_names() {
diff --git a/crates/sysmlv2-model/src/json/derived_compositions.rs b/crates/sysmlv2-model/src/json/derived_compositions.rs
index e14c20e..46ae623 100644
--- a/crates/sysmlv2-model/src/json/derived_compositions.rs
+++ b/crates/sysmlv2-model/src/json/derived_compositions.rs
@@ -82,8 +82,8 @@ pub(crate) static COMPOSITIONS: &[(&str, &str, &str, bool)] = &[
         "EnumerationUsage",
         false,
     ),
-    ("nestedFlow", "nestedUsage", "FlowConnectionUsage", false),
-    ("nestedInterface", "nestedUsage", "ReferenceUsage", false),
+    ("nestedFlow", "nestedUsage", "FlowUsage", false),
+    ("nestedInterface", "nestedUsage", "InterfaceUsage", false),
     ("nestedItem", "nestedUsage", "ItemUsage", false),
     ("nestedMetadata", "nestedUsage", "MetadataUsage", false),
     ("nestedOccurrence", "nestedUsage", "OccurrenceUsage", false),
@@ -144,9 +144,9 @@ pub(crate) static COMPOSITIONS: &[(&str, &str, &str, bool)] = &[
         "FeatureMembership",
         false,
     ),
-    ("ownedFlow", "ownedUsage", "FlowConnectionUsage", false),
+    ("ownedFlow", "ownedUsage", "FlowUsage", false),
     ("ownedImport", "ownedRelationship", "Import", false),
-    ("ownedInterface", "ownedUsage", "ReferenceUsage", false),
+    ("ownedInterface", "ownedUsage", "InterfaceUsage", false),
     (
         "ownedIntersecting",
         "ownedRelationship",
diff --git a/crates/sysmlv2-model/src/json/direction_proof.rs b/crates/sysmlv2-model/src/json/direction_proof.rs
new file mode 100644
index 0000000..0524500
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/direction_proof.rs
@@ -0,0 +1,366 @@
+//! Bounded direction facts for stored feature identities.
+use super::{Builder, provider_completeness::ProviderCompleteness};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Direction {
+    In,
+    Out,
+    InOut,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum DirectionFact {
+    Known(Option<Direction>),
+    Unknown,
+}
+impl DirectionFact {
+    pub(crate) fn compatible(self, own: Self) -> Option<bool> {
+        let Self::Known(own) = own else { return None };
+        match self {
+            Self::Known(None) => Some(true),
+            Self::Known(Some(Direction::InOut)) => Some(own.is_some()),
+            Self::Known(Some(required)) => Some(own == Some(required)),
+            Self::Unknown => None,
+        }
+    }
+}
+fn charge(steps: &mut usize, count: usize) -> Option<()> {
+    *steps = steps.saturating_add(count);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+pub(crate) fn authored_direction(b: &Builder, feature: usize) -> DirectionFact {
+    let Some(e) = b.elements.get(feature) else {
+        return DirectionFact::Unknown;
+    };
+    if !conforms(e.ty, "Feature") {
+        return DirectionFact::Unknown;
+    }
+    match e.props.get("direction") {
+        None => DirectionFact::Known(None),
+        Some(v) if v.is_null() => DirectionFact::Known(None),
+        Some(v) => match v.as_str() {
+            Some("in") => DirectionFact::Known(Some(Direction::In)),
+            Some("out") => DirectionFact::Known(Some(Direction::Out)),
+            Some("inout") => DirectionFact::Known(Some(Direction::InOut)),
+            _ => DirectionFact::Unknown,
+        },
+    }
+}
+/// Query-local only. Graph/identity mutation requires a fresh proof.
+#[derive(Default)]
+pub(crate) struct DirectionProof {
+    providers: ProviderCompleteness,
+    known: HashMap<(usize, usize, usize), Option<Direction>>,
+}
+impl DirectionProof {
+    pub(crate) fn through(
+        &mut self,
+        b: &mut Builder,
+        current: usize,
+        target: usize,
+        target_owner: Option<usize>,
+        is_chained: &dyn Fn(&Builder, usize, &mut usize) -> Option<bool>,
+        steps: &mut usize,
+    ) -> DirectionFact {
+        // A genuinely undirected feature cannot acquire direction by inheritance.
+        if charge(steps, 1).is_none() {
+            return DirectionFact::Unknown;
+        }
+        let raw = authored_direction(b, target);
+        match raw {
+            DirectionFact::Unknown | DirectionFact::Known(None) => raw,
+            DirectionFact::Known(Some(direction)) => {
+                let Some(owner) = target_owner else {
+                    // directionOf only returns a direction upon reaching owningType.
+                    // Caller must establish absence of owningType, not lose an endpoint.
+                    return DirectionFact::Known(None);
+                };
+                match self.walk(
+                    b,
+                    current,
+                    target,
+                    owner,
+                    direction,
+                    0,
+                    &mut HashSet::new(),
+                    is_chained,
+                    steps,
+                ) {
+                    Some(value) => DirectionFact::Known(value),
+                    None => DirectionFact::Unknown,
+                }
+            }
+        }
+    }
+    // The generic base helper chooses the first stored general endpoint. For a
+    // proof, redundant superclass/subsetting slots must agree, not hide corruption.
+    fn validate_endpoints(&self, b: &mut Builder, current: usize, steps: &mut usize) -> Option<()> {
+        let relationships = b.elements[current].owned_relationships.clone();
+        charge(steps, relationships.len())?;
+        for rel in relationships {
+            let relation = b.elements.get(rel)?;
+            if !conforms(relation.ty, "Specialization") {
+                continue;
+            }
+            let expected = if conforms(relation.ty, "Subsetting") {
+                "Feature"
+            } else if conforms(relation.ty, "Subclassification") {
+                "Classifier"
+            } else {
+                "Type"
+            };
+            let source_kind =
+                if conforms(relation.ty, "Subsetting") || conforms(relation.ty, "FeatureTyping") {
+                    "Feature"
+                } else if conforms(relation.ty, "Subclassification") {
+                    "Classifier"
+                } else {
+                    "Type"
+                };
+            if !conforms(b.elements[current].ty, source_kind) {
+                return None;
+            }
+            if relation
+                .props
+                .get("owningRelatedElement")
+                .is_some_and(|value| value.as_reference() != Some(b.elements[current].id))
+            {
+                return None;
+            }
+            let mut endpoint = None;
+            for key in [
+                "general",
+                "superclassifier",
+                "type",
+                "subsettedFeature",
+                "redefinedFeature",
+                "referencedFeature",
+                "crossedFeature",
+            ] {
+                if let Some(value) = relation.props.get(key) {
+                    let id = value.as_reference()?;
+                    if endpoint.is_some_and(|previous| previous != id) {
+                        return None;
+                    }
+                    endpoint = Some(id);
+                }
+            }
+            let target = b.element_index_of_uuid(endpoint?)?;
+            if !conforms(b.elements.get(target)?.ty, expected) {
+                return None;
+            }
+        }
+        Some(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn walk(
+        &mut self,
+        b: &mut Builder,
+        current: usize,
+        target: usize,
+        target_owner: usize,
+        direction: Direction,
+        depth: usize,
+        active: &mut HashSet<usize>,
+        is_chained: &dyn Fn(&Builder, usize, &mut usize) -> Option<bool>,
+        steps: &mut usize,
+    ) -> Option<Option<Direction>> {
+        charge(steps, 1)?;
+        if depth > super::MAX_RESOLUTION_DEPTH || !conforms(b.elements.get(current)?.ty, "Type") {
+            return None;
+        }
+        // Normative terminal comes before conjugation or supertypes.
+        if current == target_owner {
+            return Some(Some(direction));
+        }
+        if active.contains(&current) {
+            return None;
+        }
+        let key = (current, target, depth);
+        if let Some(&known) = self.known.get(&key) {
+            return Some(known);
+        }
+        active.insert(current);
+        let result = (|| {
+            let relations = &b.elements[current].owned_relationships;
+            charge(steps, relations.len())?;
+            // Feature::supertypes adds its chain target; do not silently omit it.
+            if is_chained(b, current, steps)?
+                || relations
+                    .iter()
+                    .any(|&r| conforms(b.elements[r].ty, "FeatureChaining"))
+            {
+                return None;
+            }
+            let conjugated = relations
+                .iter()
+                .any(|&r| conforms(b.elements[r].ty, "Conjugation"));
+            // The provider validates uniqueness/endpoints and gives conjugation
+            // precedence. Invalid mixed declarations remain unsupported here.
+            if conjugated
+                && relations
+                    .iter()
+                    .any(|&r| conforms(b.elements[r].ty, "Specialization"))
+            {
+                return None;
+            }
+            self.validate_endpoints(b, current, steps)?;
+            let scope = *b.elem_scope.get(&current)?;
+            if !self.providers.scope(b, scope, steps) {
+                return None;
+            }
+            let mut result = None;
+            // Uniform non-null paths are independent of the provider's ordering.
+            // Mixed paths are unknown rather than guessing the normative first.
+            for parent in b.value_context_bases(current, steps)? {
+                if let Some(found) = self.walk(
+                    b,
+                    parent,
+                    target,
+                    target_owner,
+                    direction,
+                    depth + 1,
+                    active,
+                    is_chained,
+                    steps,
+                )? {
+                    if result.is_some_and(|previous| previous != found) {
+                        return None;
+                    }
+                    result = Some(found);
+                }
+            }
+            Some(match (result, conjugated) {
+                (Some(Direction::In), true) => Some(Direction::Out),
+                (Some(Direction::Out), true) => Some(Direction::In),
+                _ => result,
+            })
+        })();
+        active.remove(&current);
+        if let Some(value) = result {
+            self.known.insert(key, value);
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn compatibility_includes_missing_direction() {
+        let dirs = [
+            None,
+            Some(Direction::In),
+            Some(Direction::Out),
+            Some(Direction::InOut),
+        ];
+        for target in dirs {
+            for own in dirs {
+                let expected = match target {
+                    None => true,
+                    Some(Direction::InOut) => own.is_some(),
+                    Some(d) => own == Some(d),
+                };
+                assert_eq!(
+                    DirectionFact::Known(target).compatible(DirectionFact::Known(own)),
+                    Some(expected)
+                );
+            }
+        }
+        assert_eq!(
+            DirectionFact::Unknown.compatible(DirectionFact::Known(None)),
+            None
+        );
+    }
+    #[test]
+    fn exhausted_provider_walk_does_not_poison_a_later_direction_query() {
+        let mut m = Model::new();
+        m.add_source(
+            "retry.kerml",
+            "classifier A {in feature p;} classifier B specializes A;",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let owner = r.resolve_qualified("A").unwrap().0;
+        let target = r.resolve_qualified("A::p").unwrap().0;
+        let current = r.resolve_qualified("B").unwrap().0;
+        let mut proof = DirectionProof::default();
+        // through + walk + relationship/endpoint scans leave one provider step;
+        // its dependency enumeration exhausts the remaining budget.
+        let count = r.b.elements[current].owned_relationships.len();
+        let mut steps = crate::eval::MAX_STEPS - (3 + 2 * count);
+        assert_eq!(
+            proof.through(
+                &mut r.b,
+                current,
+                target,
+                Some(owner),
+                &|_, _, _| Some(false),
+                &mut steps
+            ),
+            DirectionFact::Unknown
+        );
+        assert!(steps > crate::eval::MAX_STEPS);
+        steps = 0;
+        assert_eq!(
+            proof.through(
+                &mut r.b,
+                current,
+                target,
+                Some(owner),
+                &|_, _, _| Some(false),
+                &mut steps
+            ),
+            DirectionFact::Known(Some(Direction::In))
+        );
+    }
+
+    #[test]
+    fn conjugation_terminal_and_unknown_paths() {
+        let mut m = Model::new();
+        let u=m.add_source("directions.kerml", "classifier A {in feature p;} classifier B conjugates A; classifier C conjugates B; classifier D specializes A; classifier Broken specializes A, missing; classifier Cycle specializes A, Cycle;");
+        assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+        let mut r = ResolvedModel::build(&m);
+        let p = r.resolve_qualified("A::p").unwrap().0;
+        let owner = r.resolve_qualified("A").unwrap().0;
+        let mut proof = DirectionProof::default();
+        let mut steps = 0;
+        for (name, expected) in [
+            ("A", DirectionFact::Known(Some(Direction::In))),
+            ("B", DirectionFact::Known(Some(Direction::Out))),
+            ("C", DirectionFact::Known(Some(Direction::In))),
+            ("D", DirectionFact::Known(Some(Direction::In))),
+            ("Broken", DirectionFact::Unknown),
+            ("Cycle", DirectionFact::Unknown),
+        ] {
+            let e = r.resolve_qualified(name).unwrap().0;
+            assert_eq!(
+                proof.through(
+                    &mut r.b,
+                    e,
+                    p,
+                    Some(owner),
+                    &|_, _, _| Some(false),
+                    &mut steps
+                ),
+                expected,
+                "{name}"
+            );
+        }
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            proof.through(
+                &mut r.b,
+                owner,
+                p,
+                Some(owner),
+                &|_, _, _| Some(false),
+                &mut exhausted
+            ),
+            DirectionFact::Unknown
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/dynamic_graph.rs b/crates/sysmlv2-model/src/json/dynamic_graph.rs
new file mode 100644
index 0000000..f560fd7
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/dynamic_graph.rs
@@ -0,0 +1,1166 @@
+//! One accepted dynamic family, published with the independently admitted result tail.
+use super::{
+    Builder, Elem,
+    dynamic_invocations::{self, Refusal},
+    publication,
+    semantic_batch::Plan,
+    semantic_ownership::SemanticOwnership,
+};
+use crate::properties::Properties;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, OnceLock},
+};
+use uuid::Uuid;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum Outcome {
+    NotApplicable,
+    Declined(Refusal),
+    Accepted,
+}
+#[derive(Clone)]
+pub(super) struct Snapshot {
+    pub epoch: publication::Revision,
+    pub plan: Option<Arc<Plan>>,
+    pub outcome: Outcome,
+    metadata: Option<Arc<()>>,
+    rows: crate::layered::Revision,
+    names: crate::layered::Revision,
+    pub typing: OnceLock<Arc<super::implied::RetainedTypings>>,
+    pub local_featuring: Option<Arc<HashSet<usize>>>,
+    pub local_featuring_outcome: Outcome,
+    pub result_redefinition: Option<Arc<super::result_redefinition::Evidence>>,
+    pub result_redefinition_outcome: Outcome,
+}
+impl Snapshot {
+    pub(super) fn new(
+        b: &mut Builder,
+        epoch: publication::Revision,
+        rows: crate::layered::Revision,
+        plan: Result<Option<Plan>, Refusal>,
+    ) -> Self {
+        let (plan, outcome) = match plan {
+            Ok(Some(plan)) => (Some(Arc::new(plan)), Outcome::Accepted),
+            Ok(None) => (None, Outcome::NotApplicable),
+            Err(reason) => (None, Outcome::Declined(reason)),
+        };
+        Self {
+            epoch,
+            rows,
+            names: b.lib_qnames.observe_revision(),
+            plan,
+            outcome,
+            metadata: b.metadata_association_generation.clone(),
+            typing: OnceLock::new(),
+            local_featuring: None,
+            local_featuring_outcome: Outcome::NotApplicable,
+            result_redefinition: None,
+            result_redefinition_outcome: Outcome::NotApplicable,
+        }
+    }
+    pub(super) fn with_local(mut self, result: Result<HashSet<usize>, Refusal>) -> Self {
+        match result {
+            Ok(owners) if !owners.is_empty() => {
+                self.local_featuring = Some(Arc::new(owners));
+                self.local_featuring_outcome = Outcome::Accepted;
+            }
+            Ok(_) => {}
+            Err(reason) => self.local_featuring_outcome = Outcome::Declined(reason),
+        }
+        self
+    }
+    pub(super) fn with_result_redefinition(
+        mut self,
+        result: Result<super::result_redefinition::Evidence, Refusal>,
+    ) -> Self {
+        match result {
+            Ok(evidence) if !evidence.sources.is_empty() => {
+                self.result_redefinition = Some(Arc::new(evidence));
+                self.result_redefinition_outcome = Outcome::Accepted;
+            }
+            Ok(_) => {}
+            Err(reason) => self.result_redefinition_outcome = Outcome::Declined(reason),
+        }
+        self
+    }
+    pub(super) fn result_redefinition_current(&self, b: &Builder) -> bool {
+        self.result_redefinition_outcome == Outcome::Accepted && self.current(b)
+    }
+    /// These edges depend only on certified generated ownership and row defaults,
+    /// not on dynamic callee admission or metadata associations.
+    pub(super) fn local_current(&self, b: &Builder) -> bool {
+        self.local_featuring_outcome == Outcome::Accepted && self.rows_current(b)
+    }
+    fn rows_current(&self, b: &Builder) -> bool {
+        self.epoch.same_as(&b.publication.revision())
+            && b.elements
+                .revision()
+                .is_some_and(|now| now.same_as(&self.rows))
+    }
+    pub(super) fn current(&self, b: &Builder) -> bool {
+        b.lib_qnames
+            .revision()
+            .is_some_and(|now| now.same_as(&self.names))
+            && b.elements
+                .revision()
+                .is_some_and(|now| now.same_as(&self.rows))
+            && self.epoch.same_as(&b.publication.revision())
+            && match (&self.metadata, &b.metadata_association_generation) {
+                (None, None) => true,
+                (Some(a), Some(z)) => Arc::ptr_eq(a, z),
+                _ => false,
+            }
+    }
+}
+impl Builder {
+    /// Observation only. Construction routines retain their explicit static inputs.
+    pub(super) fn effective_dynamic_plan(&self) -> Option<&Plan> {
+        if self.static_planning {
+            return None;
+        }
+        let snapshot = self.dynamic_graph.as_ref()?;
+        (snapshot.current(self) && snapshot.outcome == Outcome::Accepted)
+            .then_some(snapshot.plan.as_deref())
+            .flatten()
+    }
+
+    /// Stale generated rows remain addressable for identity compatibility, but
+    /// cannot supply new checked semantic evidence for an affected owner.
+    pub(super) fn dynamic_evidence_current(&self, owner: usize) -> bool {
+        if self.static_planning {
+            return true;
+        }
+        let Some(snapshot) = &self.dynamic_graph else {
+            return true;
+        };
+        let affected = snapshot
+            .plan
+            .as_ref()
+            .is_some_and(|plan| plan.affected_owners.contains(&owner));
+        !affected || (snapshot.current(self) && snapshot.outcome == Outcome::Accepted)
+    }
+
+    pub(super) fn local_featuring_evidence_current(&self, owner: usize) -> bool {
+        let Some(snapshot) = &self.dynamic_graph else {
+            return true;
+        };
+        !snapshot
+            .local_featuring
+            .as_ref()
+            .is_some_and(|owners| owners.contains(&owner))
+            || snapshot.local_current(self)
+    }
+
+    pub(super) fn result_redefinition_evidence_current(&self, source: usize) -> bool {
+        self.dynamic_graph.as_ref().is_none_or(|snapshot| {
+            !snapshot
+                .result_redefinition
+                .as_ref()
+                .is_some_and(|e| e.sources.contains(&source))
+                || snapshot.result_redefinition_current(self)
+        })
+    }
+    pub(super) fn result_redefinition_row_current(&self, row: usize) -> bool {
+        self.dynamic_graph.as_ref().is_none_or(|snapshot| {
+            !snapshot
+                .result_redefinition
+                .as_ref()
+                .is_some_and(|e| e.relationships.contains(&row))
+                || snapshot.result_redefinition_current(self)
+        })
+    }
+    pub(super) fn effective_positional_redefinitions(
+        &self,
+    ) -> Option<&super::positional::PositionalRedefinitions> {
+        self.effective_dynamic_plan()
+            .map(|p| &p.positional)
+            .or_else(|| {
+                self.positional_redefinitions
+                    .as_ref()
+                    .filter(|_| self.supported_chain_evidence_current())
+            })
+    }
+    pub(super) fn dynamic_typing_edges(
+        &self,
+        steps: &mut usize,
+    ) -> Option<Arc<super::implied::RetainedTypings>> {
+        let plan = self.effective_dynamic_plan()?;
+        let snapshot = self.dynamic_graph.as_ref()?;
+        *steps = steps.saturating_add(1);
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        if let Some(value) = snapshot.typing.get() {
+            return Some(Arc::clone(value));
+        }
+        *steps = steps
+            .saturating_add(plan.static_prefix.rows.len())
+            .saturating_add(plan.tail.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        let mut values = super::implied::RetainedTypings::new();
+        for edge in plan.static_prefix.rows.iter().chain(&plan.tail) {
+            if crate::metaclass::conforms(edge.kind, "FeatureTyping")
+                || crate::metaclass::conforms(edge.kind, "Subsetting")
+            {
+                values
+                    .entry(edge.owner)
+                    .or_default()
+                    .push((edge.kind, edge.target));
+            }
+        }
+        let _ = snapshot.typing.set(Arc::new(values));
+        snapshot.typing.get().cloned()
+    }
+    pub(super) fn prepare_dynamic_graph(
+        &mut self,
+        reserved: &HashSet<Uuid>,
+        steps: &mut usize,
+        produced_prefix: Option<Arc<super::semantic_batch::StaticPrefix>>,
+    ) -> Result<Option<Plan>, Refusal> {
+        *steps = steps.saturating_add(self.explicit_len());
+        if *steps > crate::eval::MAX_STEPS {
+            return Err(Refusal::WorkLimit);
+        }
+        if !self.elements.iter().take(self.explicit_len()).any(|e| {
+            e.ty == "InvocationExpression"
+                || (self.graph_format == crate::model::GraphFormat::CanonicalV3
+                    && matches!(e.ty, "ConstructorExpression" | "OperatorExpression"))
+        }) {
+            return Ok(None);
+        }
+        for (_, parts) in &self.lib_qnames {
+            *steps = steps.saturating_add(1);
+            for part in parts {
+                *steps = steps.saturating_add(part.len());
+            }
+            if *steps > crate::eval::MAX_STEPS {
+                return Err(Refusal::WorkLimit);
+            }
+        }
+        for name in self.external_implied_names.keys() {
+            *steps = steps.saturating_add(name.len().saturating_add(1));
+            if *steps > crate::eval::MAX_STEPS {
+                return Err(Refusal::WorkLimit);
+            }
+        }
+        let names: HashMap<_, _> = self
+            .lib_qnames
+            .iter()
+            .map(|(id, parts)| (parts.join("::"), *id))
+            .chain(
+                self.external_implied_names
+                    .iter()
+                    .map(|(name, id)| (name.clone(), *id)),
+            )
+            .collect();
+        let metadata = self.metadata_association_generation.clone();
+        let mut positional_workspace = super::positional::PositionalWorkspace::default();
+        let prefix = if let Some(prefix) = produced_prefix {
+            // This is a same-transaction producer value, never a reconstructed
+            // cache. Capture below still checks every physical recipe/identity.
+            if !self.physical_static_authority_current() {
+                return Err(Refusal::Stale);
+            }
+            prefix
+        } else {
+            self.static_specialization_prefix_with_workspace(
+                &names,
+                self.external_implied_names.is_empty(),
+                Some(steps),
+                &mut positional_workspace,
+            )
+            .ok_or(Refusal::WorkLimit)?
+        };
+        let boundary = self.implied.as_ref().map(|t| t.owned_results_from);
+        let prefix = dynamic_invocations::capture_static_prefix(self, prefix, boundary, steps)?;
+        let plan = dynamic_invocations::prepare_with_workspace(
+            self,
+            prefix,
+            reserved,
+            boundary,
+            steps,
+            &mut positional_workspace,
+        )?;
+        let current = match (&metadata, &self.metadata_association_generation) {
+            (None, None) => true,
+            (Some(a), Some(z)) => Arc::ptr_eq(a, z),
+            _ => false,
+        };
+        if !current {
+            return Err(Refusal::Stale);
+        }
+        Ok(Some(plan))
+    }
+}
+
+/// Pure row construction. All indices and carriers are validated before the
+/// private view is changed. The caller discards this private staging on failure.
+pub(super) fn stage_dynamic_rows(
+    b: &Builder,
+    plan: &Plan,
+    start: usize,
+    ownership: &mut SemanticOwnership,
+    steps: &mut usize,
+) -> Result<Vec<Elem>, Refusal> {
+    let mut rows = Vec::new();
+    for edge in &plan.tail {
+        *steps = steps.saturating_add(16);
+        if *steps > crate::eval::MAX_STEPS {
+            return Err(Refusal::WorkLimit);
+        }
+        if edge.owner >= b.explicit_len() || b.elements[edge.owner].id != edge.owner_id {
+            return Err(Refusal::Stale);
+        }
+        let mut props = Properties::new();
+        props.insert("isImplied", serde_json::json!(true));
+        props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":edge.owner_id.to_string()}),
+        );
+        props.insert(
+            edge.source_key,
+            serde_json::json!({"@id":edge.owner_id.to_string()}),
+        );
+        props.insert(
+            edge.target_key,
+            serde_json::json!({"@id":edge.target.to_string()}),
+        );
+        ownership
+            .register(start + rows.len(), Some(edge.owner), edge.owner, true)
+            .ok_or(Refusal::Stale)?;
+        rows.push(Elem {
+            ty: edge.kind,
+            id: edge.id,
+            path: String::new(),
+            path_parent: None,
+            props,
+            owned_relationships: Default::default(),
+            children: Default::default(),
+            owning_relationship: None,
+        });
+    }
+    Ok(rows)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ElementRef, ResolvedModel},
+        model::Model,
+    };
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_source("dynamic-graph.kerml", source);
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+    #[test]
+    fn one_snapshot_exposes_dynamic_callee_and_positional_edges() {
+        let mut r = fixture("function F {in p; return result;} feature call=F(1);");
+        let f = r.resolve_qualified("F").unwrap();
+        let p = r.resolve_qualified("F::p").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        assert!(r.b.dynamic_graph.is_none());
+        r.implied_relationships(call);
+        let snapshot = r.b.dynamic_graph.clone().unwrap();
+        assert_eq!(snapshot.outcome, Outcome::Accepted);
+        assert!(snapshot.epoch.same_as(&r.b.publication.revision()));
+        let plan = snapshot.plan.as_ref().unwrap();
+        assert!(
+            r.b.value_context_bases(call.0, &mut 0)
+                .unwrap()
+                .contains(&f.0)
+        );
+        assert!(
+            plan.tail
+                .iter()
+                .any(|e| e.owner == call.0 && e.target == r.element_id(f))
+        );
+        let parameter = plan
+            .tail
+            .iter()
+            .find(|e| e.kind == "Redefinition" && e.target == r.element_id(p))
+            .unwrap()
+            .owner;
+        assert!(
+            r.b.cardinality_positional_targets(parameter, &mut 0)
+                .unwrap()
+                .contains(&p.0)
+        );
+        let count = r.b.elements.len();
+        r.implied_relationships(call);
+        assert_eq!(r.b.elements.len(), count);
+        assert!(Arc::ptr_eq(&snapshot, r.b.dynamic_graph.as_ref().unwrap()));
+        assert!(matches!(
+            r.model_level_evaluability(call).classification,
+            crate::json::ModelLevelEvaluability::Unknown(_)
+        ));
+    }
+    #[test]
+    fn dynamic_decline_preserves_independent_result_and_binding_rows() {
+        let mut r = fixture("feature n; feature read=n; feature bad=Missing();");
+        let reference = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(reference);
+        let snapshot = r.b.dynamic_graph.as_ref().unwrap();
+        assert!(matches!(snapshot.outcome, Outcome::Declined(_)));
+        assert!(snapshot.plan.is_none());
+        let view = r.b.semantic_ownership.as_ref().unwrap();
+        assert!(view.result(reference.0).is_some());
+        assert_eq!(
+            r.b.elements
+                .iter()
+                .filter(|e| e.ty == "BindingConnector")
+                .count(),
+            1
+        );
+        assert_eq!(
+            r.b.elements.len() - r.b.implied.as_ref().unwrap().owned_results_from,
+            14
+        );
+    }
+    #[test]
+    fn explicit_dynamic_and_result_ids_keep_handles_and_logical_endpoints() {
+        let mut r = fixture(
+            "function F {in p; return result;} feature n; feature read=n; feature call=F(1);",
+        );
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        let reference = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        let f = r.resolve_qualified("F").unwrap();
+        r.implied_relationships(call);
+        let snapshot = r.b.dynamic_graph.clone().unwrap();
+        assert_eq!(snapshot.outcome, Outcome::Accepted);
+        let dynamic_id = snapshot.plan.as_ref().unwrap().tail[0].id;
+        let dynamic_handle = r.element_by_id(&dynamic_id.to_string()).unwrap();
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(reference.0)
+                .unwrap()
+                .feature;
+        let result_id = r.b.elements[result].id;
+        let old_f = r.element_id(f);
+        let new_dynamic = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"explicit dynamic relationship");
+        let new_result = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"explicit generated result");
+        let new_f = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"explicit callee");
+        let before = r.b.elements.len();
+        assert_eq!(
+            r.override_ids(&HashMap::from([
+                (dynamic_id, new_dynamic),
+                (result_id, new_result),
+                (old_f, new_f)
+            ]))
+            .len(),
+            3
+        );
+        assert_eq!(r.b.elements.len(), before);
+        assert_eq!(r.element_id(dynamic_handle), new_dynamic);
+        assert_eq!(r.b.elements[result].id, new_result);
+        let current = r.b.dynamic_graph.as_ref().unwrap();
+        assert!(!Arc::ptr_eq(&snapshot, current));
+        assert!(current.epoch.same_as(&r.b.publication.revision()));
+        assert!(
+            current
+                .plan
+                .as_ref()
+                .unwrap()
+                .tail
+                .iter()
+                .any(|e| e.id == new_dynamic)
+        );
+        assert!(
+            current
+                .plan
+                .as_ref()
+                .unwrap()
+                .tail
+                .iter()
+                .any(|e| e.target == new_f)
+        );
+        r.implied_relationships(call);
+        assert_eq!(r.b.elements.len(), before);
+        assert_eq!(r.element_id(dynamic_handle), new_dynamic);
+    }
+
+    #[test]
+    fn proof_held_before_publication_refuses_after_epoch_change() {
+        let mut r = fixture("feature a; function F {return result;} feature call=F();");
+        let a = r.resolve_qualified("a").unwrap();
+        let mut proof = super::super::type_relations::TypeRelations::default();
+        assert_eq!(proof.owning_type(&mut r.b, a.0, &mut 0), Some(None));
+        let call =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap();
+        r.implied_relationships(ElementRef(call));
+        assert_eq!(proof.owning_type(&mut r.b, a.0, &mut 0), None);
+        assert_eq!(
+            super::super::type_relations::TypeRelations::default()
+                .owning_type(&mut r.b, a.0, &mut 0),
+            Some(None)
+        );
+    }
+}
+
+impl Builder {
+    /// Name tables affect held proofs, but an existing physical implied graph
+    /// intentionally retains the Builder names from its first materialization.
+    pub(super) fn library_names_changed(&mut self, preserve: bool, was_current: bool) {
+        let epoch = publication::Revision::next();
+        if preserve {
+            if let Some(previous) = self.dynamic_graph.as_ref() {
+                let mut next = previous.as_ref().clone();
+                next.epoch = epoch.clone();
+                if !was_current && next.plan.is_some() {
+                    next.outcome = Outcome::Declined(Refusal::Stale);
+                }
+                self.dynamic_graph = Some(Arc::new(next));
+            }
+        } else {
+            self.dynamic_graph = None;
+        }
+        self.publication.install(epoch);
+    }
+    /// ID overrides preserve physical rows/handles. Only immutable recipes are
+    /// replaced; explicit generated IDs are never re-derived from their owner.
+    pub(super) fn remap_dynamic_graph(
+        &mut self,
+        ids: &HashMap<Uuid, Uuid>,
+        admissible: bool,
+        local_admissible: bool,
+        result_admissible: bool,
+    ) {
+        let Some(previous) = self.dynamic_graph.clone() else {
+            self.publication.published();
+            return;
+        };
+        fn graph(
+            values: &HashMap<Uuid, Vec<Uuid>>,
+            ids: &HashMap<Uuid, Uuid>,
+        ) -> HashMap<Uuid, Vec<Uuid>> {
+            values
+                .iter()
+                .map(|(s, t)| {
+                    (
+                        *ids.get(s).unwrap_or(s),
+                        t.iter().map(|id| *ids.get(id).unwrap_or(id)).collect(),
+                    )
+                })
+                .collect()
+        }
+        fn edge(edge: &mut super::semantic_batch::Edge, ids: &HashMap<Uuid, Uuid>) {
+            edge.id = *ids.get(&edge.id).unwrap_or(&edge.id);
+            edge.owner_id = *ids.get(&edge.owner_id).unwrap_or(&edge.owner_id);
+            edge.target = *ids.get(&edge.target).unwrap_or(&edge.target);
+        }
+        let unique = self.literal_identities_unique(None) == Some(true);
+        let plan = if let Some(old) = &previous.plan {
+            let mut plan = old.as_ref().clone();
+            let mut prefix = plan.static_prefix.as_ref().clone();
+            for item in &mut prefix.rows {
+                edge(item, ids);
+            }
+            prefix.specializations = graph(&prefix.specializations, ids);
+            plan.static_prefix = Arc::new(prefix);
+            for item in &mut plan.tail {
+                edge(item, ids);
+            }
+            plan.specializations = graph(&plan.specializations, ids);
+            Ok(Some(plan))
+        } else {
+            match &previous.outcome {
+                Outcome::Declined(reason) => Err(reason.clone()),
+                _ => Ok(None),
+            }
+        };
+        let epoch = publication::Revision::next();
+        let rows = self.elements.observe_revision();
+        let mut snapshot = Snapshot::new(self, epoch.clone(), rows, plan);
+        snapshot.local_featuring = previous.local_featuring.clone();
+        snapshot.local_featuring_outcome = previous.local_featuring_outcome.clone();
+        if snapshot.local_featuring.is_some() && (!local_admissible || !unique) {
+            snapshot.local_featuring_outcome = Outcome::Declined(if unique {
+                Refusal::Stale
+            } else {
+                Refusal::Collision
+            });
+        }
+        snapshot.result_redefinition = previous.result_redefinition.clone();
+        snapshot.result_redefinition_outcome = previous.result_redefinition_outcome.clone();
+        if snapshot.result_redefinition.is_some() && (!result_admissible || !unique) {
+            snapshot.result_redefinition_outcome = Outcome::Declined(if unique {
+                Refusal::Stale
+            } else {
+                Refusal::Collision
+            });
+        }
+        if !admissible || !unique {
+            snapshot.outcome = Outcome::Declined(if unique {
+                Refusal::Stale
+            } else {
+                Refusal::Collision
+            });
+        }
+        self.dynamic_graph = Some(Arc::new(snapshot));
+        self.publication.install(epoch);
+    }
+}
+
+pub(super) fn stage_dynamic_adjacency(
+    plan: &Plan,
+    steps: &mut usize,
+) -> Result<HashMap<Uuid, Vec<Uuid>>, Refusal> {
+    *steps = steps.saturating_add(plan.specializations.capacity());
+    if *steps > crate::eval::MAX_STEPS {
+        return Err(Refusal::WorkLimit);
+    }
+    for targets in plan.specializations.values() {
+        *steps = steps.saturating_add(targets.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return Err(Refusal::WorkLimit);
+        }
+    }
+    Ok(plan.specializations.clone())
+}
+
+#[cfg(test)]
+mod replay_tests {
+    use super::*;
+    use crate::{
+        json::{ClosurePolicy, ElementRef, ResolvedModel},
+        libcache::LibraryCache,
+        model::Model,
+        prepared::PreparedLibrary,
+    };
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+    const USER: &str =
+        "function F {in p; return result;} feature n; feature read=n; feature call=F(1);";
+    #[test]
+    fn shared_dynamic_snapshot_replays_and_does_not_publish_during_preparation() {
+        let mut base = Model::new();
+        base.add_library_source("bases.kerml", LIB);
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(82).unwrap(), 82).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("bases.kerml", LIB);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("dynamic.kerml", USER);
+            assert!(!model.has_errors());
+            let compact = crate::json::model_to_compact_json(&model);
+            let mut r = ResolvedModel::build(&model);
+            assert!(r.b.dynamic_graph.is_none());
+            assert!(r.b.implied.is_none());
+            let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            let call = r
+                .user_elements()
+                .find(|&e| r.element_type(e) == "InvocationExpression")
+                .unwrap();
+            for policy in [
+                ClosurePolicy::Passthrough,
+                ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+                ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                r.implied_relationships(call);
+                assert_eq!(
+                    r.b.dynamic_graph.as_ref().unwrap().outcome,
+                    Outcome::Accepted
+                );
+            }
+            let rows: Vec<_> =
+                r.b.elements
+                    .iter()
+                    .skip(r.b.implied.as_ref().unwrap().from)
+                    .map(|e| (e.id, e.ty, e.props.to_json()))
+                    .collect();
+            if let Some(expected) = &expected {
+                assert_eq!(&rows, expected);
+            } else {
+                expected = Some(rows);
+            }
+            assert_eq!(
+                source_ids,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+            assert_eq!(compact, crate::json::model_to_compact_json(&model));
+        }
+    }
+    #[test]
+    fn identity_binding_gain_rebuilds_common_tail_and_keeps_static_handles() {
+        let target = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"dynamic bound callee");
+        let mut model = Model::new();
+        model.add_library_source("bases.kerml", LIB);
+        model.add_source("binding.kerml",&format!("function F {{in p;return result;}} feature n; feature read=n; feature call='{target}'(1);"));
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let f = r.resolve_qualified("F").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        assert!(matches!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Declined(_)
+        ));
+        let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+        let stable: Vec<_> = r.b.elements.iter().take(boundary).map(|e| e.id).collect();
+        let old_f = r.element_id(f);
+        r.override_ids(&HashMap::from([(old_f, target)]));
+        let old_epoch = r.b.publication.revision();
+        assert!(r.bind_id_spelled_references().contains(&target));
+        assert!(!old_epoch.same_as(&r.b.publication.revision()));
+        assert!(r.b.dynamic_graph.is_none());
+        assert_eq!(r.b.elements.len(), boundary);
+        for (index, expected) in stable.into_iter().enumerate() {
+            assert_eq!(
+                r.element_id(ElementRef(index)),
+                if expected == old_f { target } else { expected }
+            );
+        }
+        r.implied_relationships(call);
+        assert_eq!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Accepted
+        );
+        assert!(
+            r.b.value_context_bases(call.0, &mut 0)
+                .unwrap()
+                .contains(&f.0)
+        );
+        assert_eq!(
+            r.b.elements
+                .iter()
+                .filter(|e| e.ty == "BindingConnector")
+                .count(),
+            1
+        );
+    }
+}
+
+#[cfg(test)]
+mod freshness_tests {
+    use super::*;
+    use crate::{
+        json::{
+            ResolvedModel,
+            type_relations::{RelationFact, TypeRelations},
+        },
+        model::Model,
+    };
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        m.add_source("fresh.kerml", source);
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+    #[test]
+    fn completed_positional_reads_share_dynamic_owner_guards_without_static_preparation() {
+        let mut r = fixture("function F {in p;} feature call=F(1);");
+        let p = r.resolve_qualified("F::p").unwrap().0;
+        let f = r.resolve_qualified("F").unwrap().0;
+        let invocation = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(invocation);
+        assert!(r.b.effective_dynamic_plan().is_some());
+        r.b.positional_redefinitions = None;
+        r.b.supported_implied = None;
+        let before = r.b.elements.observe_revision();
+        assert!(r.b.completed_positional_targets(p).is_some());
+        assert!(r.b.semantic_inheritance_bases(p, true, &mut 0).is_some());
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(r.b.supported_implied.is_none());
+        let snapshot = Arc::make_mut(r.b.dynamic_graph.as_mut().unwrap());
+        let plan = Arc::make_mut(snapshot.plan.as_mut().unwrap());
+        plan.positional.incomplete.insert(f);
+        assert!(r.b.completed_positional_targets(p).is_none());
+        assert!(r.b.cardinality_positional_targets(p, &mut 0).is_none());
+        assert!(r.b.semantic_inheritance_bases(p, true, &mut 0).is_none());
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(r.b.supported_implied.is_none());
+        assert!(r.b.elements.revision().unwrap().same_as(&before));
+    }
+
+    #[test]
+    fn loaded_name_only_change_revokes_accepted_dynamic_static_dependencies() {
+        let mut r = fixture("function F {in p;} feature call=F(1);");
+        let invocation = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(invocation);
+        assert!(r.b.effective_dynamic_plan().is_some());
+        assert!(r.b.retained_typing_edges(&mut 0).is_some());
+        let rows = r.b.elements.observe_revision();
+        r.b.lib_qnames
+            .push((Uuid::new_v4(), vec!["changed loaded name evidence".into()]));
+        assert!(r.b.elements.revision().unwrap().same_as(&rows));
+        r.b.supported_implied = None;
+        r.b.positional_redefinitions = None;
+        assert!(r.b.effective_dynamic_plan().is_none());
+        assert!(!r.b.dynamic_evidence_current(invocation.0));
+        assert!(r.b.dynamic_typing_edges(&mut 0).is_none());
+    }
+    #[test]
+    fn unrelated_positional_cycle_remains_incomplete_after_dynamic_acceptance() {
+        let mut r = fixture(
+            "class Cycle specializes Cycle {in p;} function F {return result;} feature call=F();",
+        );
+        let p = r.resolve_qualified("Cycle::p").unwrap();
+        assert!(r.b.value_context_bases(p.0, &mut 0).is_none());
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        assert_eq!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Accepted
+        );
+        assert!(r.b.value_context_bases(p.0, &mut 0).is_none());
+    }
+    #[test]
+    fn stale_metadata_cannot_be_recertified_by_identity_override() {
+        let mut r = fixture("feature a; function F {in p;return result;} feature call=F(1);");
+        let f = r.resolve_qualified("F").unwrap();
+        let a = r.resolve_qualified("a").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Yes
+        );
+        let mut held = TypeRelations::default();
+        assert_eq!(
+            held.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Yes
+        );
+        let count = r.b.elements.len();
+        r.b.metadata_association_generation = Some(Arc::new(()));
+        assert_eq!(
+            held.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+        let old = r.element_id(f);
+        let next = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"stale override");
+        r.override_ids(&HashMap::from([(old, next)]));
+        assert_eq!(r.b.elements.len(), count);
+        assert!(matches!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Declined(Refusal::Stale)
+        ));
+        assert!(r.b.dynamic_graph.as_ref().unwrap().plan.is_some());
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().owning_type(&mut r.b, a.0, &mut 0),
+            Some(None)
+        );
+        assert!(r.b.value_context_bases(call.0, &mut 0).is_none());
+        r.implied_relationships(call);
+        assert_eq!(r.b.elements.len(), count);
+    }
+    #[test]
+    fn same_length_mutation_invalidates_new_and_memoized_positive_proofs() {
+        let mut r = fixture("function F {return result;} feature call=F();");
+        let f = r.resolve_qualified("F").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        let mut proof = TypeRelations::default();
+        assert_eq!(
+            proof.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Yes
+        );
+        // A value-preserving write must still revoke the row revision.
+        let id = r.element_id(call);
+        r.b.elements[call.0].id = id;
+        assert_eq!(
+            proof.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn changed_name_table_preserves_frozen_graph_and_invalidates_held_proofs() {
+        let mut r = fixture("function F {return result;} feature call=F();");
+        let f = r.resolve_qualified("F").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        let ids: Vec<_> = r.b.elements.iter().map(|e| e.id).collect();
+        let mut proof = TypeRelations::default();
+        assert_eq!(
+            proof.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Yes
+        );
+        r.set_library_names(&HashMap::from([(
+            Uuid::new_v5(&Uuid::NAMESPACE_OID, b"new names").to_string(),
+            vec!["New".into(), "Name".into()],
+        )]));
+        assert!(r.b.effective_dynamic_plan().is_some());
+        assert_eq!(
+            proof.specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, f.0, &mut 0),
+            RelationFact::Yes
+        );
+        assert_eq!(ids, r.b.elements.iter().map(|e| e.id).collect::<Vec<_>>());
+    }
+}
+
+#[cfg(test)]
+mod lookup_tests {
+    use super::*;
+    use crate::{
+        json::{
+            ResolvedModel,
+            type_relations::{RelationFact, TypeRelations},
+        },
+        model::Model,
+    };
+    #[test]
+    fn scoped_feature_callee_uses_identity_without_fabricating_invocation_scope() {
+        let mut m = Model::new();
+        m.add_source("lookup.kerml","class A {feature old;} class B specializes A {feature renamed redefines old;} feature callee {feature nested;} feature call=callee();");
+        assert!(!m.has_errors());
+        let mut r = ResolvedModel::build(&m);
+        let callee = r.resolve_qualified("callee").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        assert!(r.b.elem_scope.get(&call.0).is_none());
+        let callee_scope = *r.b.elem_scope.get(&callee.0).unwrap();
+        let before = r.b.base_scopes_split(callee_scope);
+        let scopes = r.b.scopes.len();
+        r.implied_relationships(call);
+        assert_eq!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Accepted
+        );
+        assert_eq!(r.b.scopes.len(), scopes);
+        assert!(r.b.elem_scope.get(&call.0).is_none());
+        assert!(
+            r.b.value_context_bases(call.0, &mut 0)
+                .unwrap()
+                .contains(&callee.0)
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, call.0, callee.0, &mut 0),
+            RelationFact::Yes
+        );
+        assert_eq!(r.b.base_scopes_split(callee_scope), before);
+        r.b.static_planning = true;
+        assert_eq!(r.b.base_scopes_split(callee_scope), before);
+        r.b.static_planning = false;
+        assert!(r.resolve_qualified("callee::nested").is_some());
+    }
+}
+
+#[cfg(test)]
+mod refusal_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    fn fixture() -> ResolvedModel {
+        let mut m = Model::new();
+        m.add_source("refusal.kerml","function F {return result;} feature spare; feature n; feature read=n; feature call=F();");
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+    #[test]
+    fn dynamic_row_collision_preserves_admitted_result_family() {
+        let mut r = fixture();
+        let f = r.resolve_qualified("F").unwrap();
+        let spare = r.resolve_qualified("spare").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        let reference = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        let collision = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!(
+                "{}/implied/FeatureTyping/{}",
+                r.element_id(call),
+                r.element_id(f)
+            )
+            .as_bytes(),
+        );
+        r.override_ids(&HashMap::from([(r.element_id(spare), collision)]));
+        r.implied_relationships(call);
+        assert!(matches!(
+            r.b.dynamic_graph.as_ref().unwrap().outcome,
+            Outcome::Declined(Refusal::Collision)
+        ));
+        assert!(
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(reference.0)
+                .is_some()
+        );
+        assert_eq!(
+            r.b.elements
+                .iter()
+                .filter(|e| e.ty == "BindingConnector")
+                .count(),
+            1
+        );
+        assert_eq!(
+            r.b.elements.len() - r.b.implied.as_ref().unwrap().owned_results_from,
+            14
+        );
+    }
+    #[test]
+    fn exhausted_dynamic_preparation_preserves_admitted_result_family_and_is_cached() {
+        let mut r = fixture();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        let reference = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        // Charge concrete input-string work before cloning the name table. This
+        // reaches the real transaction's dynamic refusal independently of the
+        // result family's untouched full admission allowance.
+        r.b.external_implied_names
+            .insert("X".repeat(crate::eval::MAX_STEPS), Uuid::nil());
+        r.implied_relationships(call);
+        let snapshot = r.b.dynamic_graph.clone().unwrap();
+        assert!(matches!(
+            snapshot.outcome,
+            Outcome::Declined(Refusal::WorkLimit)
+        ));
+        assert!(
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(reference.0)
+                .is_some()
+        );
+        assert_eq!(
+            r.b.elements.len() - r.b.implied.as_ref().unwrap().owned_results_from,
+            14
+        );
+        let count = r.b.elements.len();
+        r.implied_relationships(call);
+        assert!(Arc::ptr_eq(&snapshot, r.b.dynamic_graph.as_ref().unwrap()));
+        assert_eq!(r.b.elements.len(), count);
+    }
+}
+
+#[cfg(test)]
+mod mutation_replay_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn completed_identity_binding_no_work_path_preserves_admitted_snapshot() {
+        let target = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"bound callee lifecycle");
+        let mut m = Model::new();
+        m.add_source("lifecycle.kerml",&format!("function F {{in p;return result;}} feature n; feature read=n; feature call='{target}'(1);"));
+        assert!(!m.has_errors());
+        let mut r = ResolvedModel::build(&m);
+        let f = r.resolve_qualified("F").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(f), target)]));
+        r.bind_id_spelled_references();
+        r.implied_relationships(call);
+        assert!(r.b.id_binding_pending.is_empty());
+        assert!(!r.b.id_spelled_targets.is_empty());
+        let before = r.b.dynamic_graph.clone().unwrap();
+        let count = r.b.elements.len();
+        assert!(r.bind_id_spelled_references().is_empty());
+        assert!(Arc::ptr_eq(&before, r.b.dynamic_graph.as_ref().unwrap()));
+        assert!(before.epoch.same_as(&r.b.publication.revision()));
+        assert_eq!(count, r.b.elements.len());
+    }
+    #[test]
+    fn no_op_identity_calls_keep_accepted_epoch_and_snapshot() {
+        let mut m = Model::new();
+        m.add_source(
+            "noop.kerml",
+            "function F {return result;} feature call=F();",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let f = r.resolve_qualified("F").unwrap();
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        let before = r.b.dynamic_graph.clone().unwrap();
+        let id = r.element_id(f);
+        assert!(r.override_ids(&HashMap::new()).is_empty());
+        assert!(r.override_ids(&HashMap::from([(id, id)])).is_empty());
+        assert!(Arc::ptr_eq(&before, r.b.dynamic_graph.as_ref().unwrap()));
+        assert!(before.epoch.same_as(&r.b.publication.revision()));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/dynamic_invocations.rs b/crates/sysmlv2-model/src/json/dynamic_invocations.rs
new file mode 100644
index 0000000..19d130c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/dynamic_invocations.rs
@@ -0,0 +1,1535 @@
+//! Detached dynamic Invocation and constructor-result construction. No Builder cache, row or
+//! materialized relationship is published here. The common tail transaction
+//! must reserve these recipes together with result/Binding rows, validate its
+//! captured semantic_batch::Snapshot, then install every view atomically.
+use super::{
+    Builder, membership_evidence, positional_delta,
+    semantic_batch::{Edge, Plan, StaticPrefix},
+    structural_index::StoredStructure,
+    type_relations::{self, TypeRelations},
+};
+use crate::metaclass::conforms;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+use uuid::Uuid;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum Refusal {
+    WorkLimit,
+    Incomplete,
+    StaticMismatch,
+    Collision,
+    Stale,
+}
+fn charge(steps: &mut usize, n: usize) -> Result<(), Refusal> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(Refusal::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+fn incomplete(steps: &usize) -> Refusal {
+    if *steps > crate::eval::MAX_STEPS {
+        Refusal::WorkLimit
+    } else {
+        Refusal::Incomplete
+    }
+}
+
+fn consistent_unresolved_target(node: &super::Elem, steps: &mut usize) -> Result<bool, Refusal> {
+    let mut target = None;
+    for key in [
+        "general",
+        "superclassifier",
+        "type",
+        "subsettedFeature",
+        "redefinedFeature",
+        "referencedFeature",
+        "crossedFeature",
+    ] {
+        charge(steps, 1)?;
+        if let Some(value) = node.props.get(key) {
+            let crate::properties::Atom::Object(fields) = value else {
+                return Ok(false);
+            };
+            let Some(name) = value.get("@ref").and_then(|v| v.as_str()) else {
+                return Ok(false);
+            };
+            charge(steps, name.len().saturating_mul(4))?;
+            if fields.len() != 1
+                || name.is_empty()
+                || target.is_some_and(|previous| previous != value)
+            {
+                return Ok(false);
+            }
+            target = Some(value);
+        }
+    }
+    let Some(target) = target else {
+        return Ok(false);
+    };
+    for (key, length, index) in [("target", 1, 0), ("relatedElement", 2, 1)] {
+        if let Some(value) = node.props.get(key) {
+            let Some(values) = value.as_array() else {
+                return Ok(false);
+            };
+            charge(steps, values.len())?;
+            if values.len() != length || &values[index] != target {
+                return Ok(false);
+            }
+        }
+    }
+    Ok(node.children.is_empty()
+        && node
+            .props
+            .get("ownedRelatedElement")
+            .is_none_or(|value| value.as_array().is_some_and(Vec::is_empty)))
+}
+
+/// Capture the immutable prefix once for this source/configuration generation.
+/// Cold recipes retain the legacy emitter IDs. On a warm model, exact matching
+/// graph recipes adopt the already-existing physical row IDs (including public
+/// identity overrides); no rehash/replacement of a published row is permitted.
+/// The caller provides a freshly produced, unshared candidate and caches only
+/// the returned Arc. Existing shared prefix objects remain immutable.
+pub(super) fn capture_static_prefix(
+    b: &mut Builder,
+    mut candidate: Arc<StaticPrefix>,
+    physical_static_end: Option<usize>,
+    steps: &mut usize,
+) -> Result<Arc<StaticPrefix>, Refusal> {
+    let raw = StoredStructure::for_query(b, steps).ok_or_else(|| incomplete(steps))?;
+    if !raw.ids_unique {
+        return Err(Refusal::Incomplete);
+    }
+    validate_fixed_prefix(b, &candidate, &raw, physical_static_end, false, steps)?;
+    if physical_static_end.is_some() {
+        charge(steps, candidate.rows.len())?;
+        let prefix = Arc::get_mut(&mut candidate).ok_or(Refusal::Stale)?;
+        for (offset, edge) in prefix.rows.iter_mut().enumerate() {
+            edge.id = b.elements[prefix.authored_end + offset].id;
+        }
+        b.recertify_physical_static_authority(steps)
+            .ok_or(Refusal::WorkLimit)?;
+    }
+    Ok(candidate)
+}
+
+/// Caller obtains prefix from the common static recipe source, not a historical
+/// candidate list. If rows exist, their exact recipes must have been checked
+/// against this prefix; a changed static prediction cannot rewrite old rows.
+/// `physical_static_end` comes from ImpliedTable.owned_results_from when
+/// materialized, not a length inferred from the proposed recipes.
+/// `reserved` includes every other admitted semantic-tail ID. The caller must
+/// reserve returned tail IDs against later result-family plans as well.
+#[cfg(test)]
+pub(super) fn prepare(
+    b: &mut Builder,
+    prefix: Arc<StaticPrefix>,
+    reserved: &HashSet<Uuid>,
+    physical_static_end: Option<usize>,
+    steps: &mut usize,
+) -> Result<Plan, Refusal> {
+    prepare_with_workspace(
+        b,
+        prefix,
+        reserved,
+        physical_static_end,
+        steps,
+        &mut super::positional::PositionalWorkspace::default(),
+    )
+}
+
+pub(super) fn prepare_with_workspace(
+    b: &mut Builder,
+    prefix: Arc<StaticPrefix>,
+    reserved: &HashSet<Uuid>,
+    physical_static_end: Option<usize>,
+    steps: &mut usize,
+    workspace: &mut super::positional::PositionalWorkspace,
+) -> Result<Plan, Refusal> {
+    charge(steps, 1)?;
+    if !b.semantic_ready || prefix.authored_end != b.explicit_len() {
+        return Err(Refusal::Incomplete);
+    }
+    let raw = StoredStructure::for_query(b, steps).ok_or_else(|| incomplete(steps))?;
+    if !raw.ids_unique {
+        return Err(Refusal::Incomplete);
+    }
+    validate_fixed_prefix(b, &prefix, &raw, physical_static_end, true, steps)?;
+    let revision = b.elements.observe_revision();
+    let authored = b.explicit_len();
+    charge(steps, b.elements.len())?;
+    let mut owners = vec![None; b.elements.len()];
+    let mut conjugated = HashSet::new();
+    let mut unresolved_sources = HashSet::new();
+    // The legacy minimizer accepts a compatibility graph. A new positive batch
+    // must not use contradictory redundant endpoints to eliminate its required
+    // callee edge. Validate the authored graph through the shared typed reader.
+    for (relation, owner) in owners.iter_mut().enumerate().take(authored) {
+        charge(steps, 1)?;
+        let node = &b.elements[relation];
+        if !conforms(node.ty, "Specialization") && !conforms(node.ty, "Conjugation") {
+            continue;
+        }
+        let carrier = if b.graph_format == crate::model::GraphFormat::CanonicalV3 {
+            super::semantic_ownership::checked_relationship_carrier(b, &raw, relation, steps)
+                .ok_or_else(|| incomplete(steps))?
+        } else {
+            Some(
+                raw.carrier(b, relation)
+                    .flatten()
+                    .ok_or_else(|| incomplete(steps))?,
+            )
+        };
+        *owner = carrier;
+        if let Some(membership) = node.owning_relationship {
+            if b.graph_format != crate::model::GraphFormat::CanonicalV3
+                || !conforms(b.elements[membership].ty, "OwningMembership")
+            {
+                return Err(incomplete(steps));
+            }
+            let namespace =
+                super::semantic_ownership::checked_relationship_carrier(b, &raw, membership, steps)
+                    .flatten()
+                    .ok_or_else(|| incomplete(steps))?;
+            if !raw
+                .membership_domains(b, steps)
+                .is_some_and(|domains| domains.owner_complete(namespace))
+                || membership_evidence::member(b, &raw, namespace, membership, steps)
+                    != Some(relation)
+            {
+                return Err(incomplete(steps));
+            }
+        }
+        if conforms(node.ty, "Conjugation") {
+            let source_id = node
+                .props
+                .get("conjugatedType")
+                .map(|v| v.as_reference())
+                .unwrap_or_else(|| carrier.map(|owner| b.elements[owner].id))
+                .ok_or_else(|| incomplete(steps))?;
+            let source = raw
+                .element_for_uuid(b, source_id)
+                .ok_or_else(|| incomplete(steps))?;
+            if !conforms(b.elements[source].ty, "Type") {
+                return Err(incomplete(steps));
+            }
+            type_relations::endpoint_with_carrier(
+                b,
+                source,
+                carrier,
+                relation,
+                &["conjugatedType"],
+                &["originalType"],
+                "Type",
+                steps,
+            )
+            .ok_or_else(|| incomplete(steps))?;
+            conjugated.insert(source_id);
+            continue;
+        }
+        let source = [
+            "specific",
+            "subclassifier",
+            "typedFeature",
+            "subsettingFeature",
+            "redefiningFeature",
+            "referencingFeature",
+            "crossingFeature",
+        ]
+        .iter()
+        .find_map(|key| node.props.get(key))
+        .map(|v| v.as_reference())
+        .unwrap_or_else(|| carrier.map(|owner| b.elements[owner].id))
+        .ok_or_else(|| incomplete(steps))?;
+        let source = raw
+            .element_for_uuid(b, source)
+            .ok_or_else(|| incomplete(steps))?;
+        let target_kind = if conforms(node.ty, "Subsetting") {
+            "Feature"
+        } else if conforms(node.ty, "Subclassification") {
+            "Classifier"
+        } else {
+            "Type"
+        };
+        let source_kind = if conforms(node.ty, "Subclassification") {
+            "Classifier"
+        } else if conforms(node.ty, "FeatureTyping") || conforms(node.ty, "Subsetting") {
+            "Feature"
+        } else {
+            "Type"
+        };
+        if !conforms(b.elements[source].ty, source_kind) {
+            return Err(incomplete(steps));
+        }
+        // A local unresolved target cannot enter the minimizer's identity
+        // graph. Canonical planning may retain an unrelated complete component,
+        // but only after proving this row's source through the shared inverse
+        // domain and quarantining every dependency that reaches it.
+        if b.graph_format == crate::model::GraphFormat::CanonicalV3
+            && (conforms(node.ty, "Subsetting") || conforms(node.ty, "FeatureTyping"))
+            && super::implied::specialization_target(node).is_none()
+        {
+            if !consistent_unresolved_target(node, steps)? {
+                return Err(incomplete(steps));
+            }
+            let typing = raw.typing(b, steps).ok_or_else(|| incomplete(steps))?;
+            charge(steps, typing.relationships.get(&source).map_or(0, Vec::len))?;
+            if typing.sources_incomplete
+                || !typing
+                    .relationships
+                    .get(&source)
+                    .is_some_and(|rows| rows.contains(&relation))
+                || super::semantic_ownership::checked_relationship_carrier(b, &raw, relation, steps)
+                    != Some(carrier)
+            {
+                return Err(incomplete(steps));
+            }
+            unresolved_sources.insert(source);
+
+            continue;
+        }
+        type_relations::endpoint_with_carrier(
+            b,
+            source,
+            carrier,
+            relation,
+            &[
+                "specific",
+                "subclassifier",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ],
+            &[
+                "general",
+                "superclassifier",
+                "type",
+                "subsettedFeature",
+                "redefinedFeature",
+                "referencedFeature",
+                "crossedFeature",
+            ],
+            target_kind,
+            steps,
+        )
+        .ok_or_else(|| incomplete(steps))?;
+    }
+    let mut owning = TypeRelations::default();
+    charge(steps, unresolved_sources.len())?;
+    let unresolved: Vec<_> = unresolved_sources.iter().copied().collect();
+    for source in unresolved {
+        charge(steps, 1)?;
+        // A source's immediate owning Type consumes its feature-domain
+        // projection. Do not recursively lift that qualification: a nested
+        // feature's signature is not the outer owner's own specialization or
+        // slot direction. Actual nested consumers remain checked by the final
+        // specialization/delta dependency audit.
+        if !conforms(b.elements[source].ty, "Feature") {
+            continue;
+        }
+        if let Some(owner) = owning
+            .owning_type(b, source, steps)
+            .ok_or_else(|| incomplete(steps))?
+        {
+            if unresolved_sources.insert(owner) {}
+        }
+    }
+
+    charge(steps, prefix.rows.len())?;
+    let mut candidates: Vec<_> = prefix
+        .rows
+        .iter()
+        .map(|r| (r.owner, (r.kind, r.source_key, r.target_key, r.target)))
+        .collect();
+    let fixed = candidates.len();
+    let mut required = Vec::new();
+    let mut constructor_positional = HashMap::new();
+    let mut unadmitted = HashSet::new();
+    let mut constructor_batch = super::constructor_bindings::ConstructorBatchEvidence::default();
+    for invocation in 0..authored {
+        charge(steps, 1)?;
+        let constructor = b.graph_format == crate::model::GraphFormat::CanonicalV3
+            && b.elements[invocation].ty == "ConstructorExpression";
+        let operator = b.graph_format == crate::model::GraphFormat::CanonicalV3
+            && b.elements[invocation].ty == "OperatorExpression";
+        if b.elements[invocation].ty != "InvocationExpression" && !constructor && !operator {
+            continue;
+        }
+        let constructor_result = if constructor {
+            Some(
+                super::constructor_bindings::owned_result(b, &raw, invocation, steps)
+                    .ok_or_else(|| incomplete(steps))?,
+            )
+        } else {
+            None
+        };
+        let operator_target = if operator {
+            let mut proposed = HashMap::new();
+            match b.checked_invocation_bindings_in_batch(
+                invocation,
+                steps,
+                Some(&mut proposed),
+                &mut constructor_batch,
+            ) {
+                Ok(arguments) => {
+                    constructor_positional.extend(proposed);
+                    Some(arguments.callee.0)
+                }
+                Err(_) if *steps > crate::eval::MAX_STEPS => return Err(Refusal::WorkLimit),
+                Err(_) => {
+                    unadmitted.insert(invocation);
+                    continue;
+                }
+            }
+        } else {
+            None
+        };
+        // Legacy publication retains whole-batch refusal. Canonical candidates
+        // with a localized missing callee remain unadmitted; the final closure
+        // audit prevents any accepted family from consuming their signatures.
+        let target = if let Some(target) = operator_target {
+            target
+        } else {
+            match membership_evidence::first_unowned_member(
+                b,
+                &raw,
+                invocation,
+                "FeatureMembership",
+                "Type",
+                None,
+                steps,
+            ) {
+                Some(target) => target,
+                None if b.graph_format == crate::model::GraphFormat::CanonicalV3
+                    && *steps <= crate::eval::MAX_STEPS =>
+                {
+                    unadmitted.insert(invocation);
+                    if let Some(result) = constructor_result {
+                        unadmitted.insert(result);
+                    }
+                    continue;
+                }
+                None => {
+                    return Err(incomplete(steps));
+                }
+            }
+        };
+        let id = b.elements[target].id;
+        let edge = if conforms(b.elements[target].ty, "Feature") {
+            ("Subsetting", "subsettingFeature", "subsettedFeature", id)
+        } else {
+            ("FeatureTyping", "typedFeature", "type", id)
+        };
+        let source = constructor_result.unwrap_or(invocation);
+        if constructor {
+            let mut proposed = HashMap::new();
+            match b.checked_constructor_bindings_in_batch(
+                invocation,
+                steps,
+                Some(&mut proposed),
+                &mut constructor_batch,
+            ) {
+                Ok(_) => constructor_positional.extend(proposed),
+                Err(_) => {
+                    charge(steps, 0)?;
+                    unadmitted.insert(invocation);
+                    unadmitted.insert(source);
+                    continue;
+                }
+            }
+        }
+        required.push(source);
+        candidates.push((source, edge));
+    }
+
+    let (retained, mut graph) = b
+        .required_specialization_edges_with_chain_bases(
+            &candidates,
+            fixed,
+            authored,
+            &owners,
+            &prefix.chain_bases,
+            Some(steps),
+        )
+        .ok_or_else(|| incomplete(steps))?;
+    let mut bases = HashMap::new();
+    for (&owner, targets) in &prefix.planner_bases {
+        charge(steps, targets.len().saturating_add(1))?;
+        bases.insert(owner, targets.clone());
+    }
+    charge(steps, prefix.planner_incomplete.len())?;
+    let mut incomplete_bases = prefix.planner_incomplete.clone();
+
+    let mut tail = Vec::new();
+    for (index, &(source, edge)) in candidates.iter().enumerate().skip(fixed) {
+        charge(steps, 1)?;
+        if !retained[index] {
+            continue;
+        }
+        let target = raw.element_for_uuid(b, edge.3).ok_or(Refusal::Incomplete)?;
+        let targets = bases.entry(source).or_insert_with(Vec::new);
+        charge(steps, targets.len().saturating_add(1))?;
+        if !targets.contains(&target) {
+            targets.push(target);
+        }
+        tail.push(recipe(b, source, edge));
+    }
+    // Every immutable positional edge visible to minimization is also visible
+    // to candidate inheritance. New positional rows can in turn enable more
+    // rows, so require an actual bounded fixed point, never a one-pass guess.
+    let foundation = bases;
+    let mut prior = Arc::clone(&prefix.positional);
+    if !constructor_positional.is_empty() {
+        // These pairs already have complete checked argument witnesses. Seed
+        // the same fixed point with them so their consequences are considered
+        // on the first pass; convergence and the immutable-prefix audit still
+        // run over the full candidate graph below.
+        charge(
+            steps,
+            prior.targets.len().saturating_add(prior.incomplete.len()),
+        )?;
+        for targets in prior.targets.values() {
+            charge(steps, targets.len())?;
+        }
+        let mut seeded = (*prior).clone();
+        for (&source, targets) in &constructor_positional {
+            charge(steps, targets.len().saturating_add(1))?;
+            if seeded
+                .targets
+                .get(&source)
+                .is_some_and(|existing| existing != targets)
+            {
+                return Err(Refusal::Incomplete);
+            }
+            seeded.targets.insert(source, targets.clone());
+        }
+        prior = Arc::new(seeded);
+    }
+    let mut stable = None;
+    for _ in 0..64 {
+        let mut next_bases = HashMap::new();
+        for (&owner, targets) in &foundation {
+            charge(steps, targets.len().saturating_add(1))?;
+            next_bases.insert(owner, targets.clone());
+        }
+        for (&source, targets) in &prior.targets {
+            charge(steps, targets.len().saturating_add(1))?;
+            let direct = next_bases.entry(source).or_insert_with(Vec::new);
+            for &target in targets {
+                charge(steps, direct.len().saturating_add(1))?;
+                if !direct.contains(&target) {
+                    direct.push(target);
+                }
+            }
+        }
+        let mut next = b
+            .plan_positional_redefinitions_with_workspace(
+                &next_bases,
+                &incomplete_bases,
+                Some(steps),
+                workspace,
+            )
+            .ok_or_else(|| incomplete(steps))?;
+        // Constructor argument ordinals use the complete public feature
+        // sequence, not the generic Behavior parameter sequence. Keep these
+        // checked pairs inside the same fixed point and immutable-prefix gate.
+        for (&source, targets) in &constructor_positional {
+            charge(steps, targets.len().saturating_add(1))?;
+            if next
+                .targets
+                .get(&source)
+                .is_some_and(|existing| existing != targets)
+            {
+                return Err(Refusal::Incomplete);
+            }
+            next.targets.insert(source, targets.clone());
+        }
+        let additions = positional_delta::certify(
+            &prefix.positional,
+            &next,
+            &required,
+            |source, steps| owning.owning_type(b, source, steps).flatten(),
+            steps,
+        )
+        .map_err(|e| match e {
+            positional_delta::Refusal::WorkLimit => Refusal::WorkLimit,
+            _ => Refusal::Incomplete,
+        })?;
+        charge(
+            steps,
+            next.targets.len().saturating_add(next.incomplete.len()),
+        )?;
+        for targets in next.targets.values() {
+            charge(steps, targets.len())?;
+        }
+        if next.targets == prior.targets && next.incomplete == prior.incomplete {
+            stable = Some((next, next_bases, additions));
+            break;
+        }
+        prior = Arc::new(next);
+    }
+    let (positional, mut bases, delta) = stable.ok_or(Refusal::Incomplete)?;
+    // Generic positional matching includes output parameters. A newly inferred
+    // Invocation input cannot be bound to an output-only parameter merely by
+    // that ordinal. Full effective-input argument mapping remains separate.
+    for (&source, targets) in &delta {
+        charge(steps, targets.len().saturating_add(1))?;
+        let owner = owning
+            .owning_type(b, source, steps)
+            .flatten()
+            .ok_or_else(|| incomplete(steps))?;
+        if !matches!(
+            b.elements[owner].ty,
+            "InvocationExpression" | "OperatorExpression"
+        ) {
+            continue;
+        }
+        match membership_evidence::parameter_direction(b, &raw, source, steps) {
+            Some(Some("in" | "inout")) => {
+                for &target in targets {
+                    if !matches!(
+                        membership_evidence::parameter_direction(b, &raw, target, steps),
+                        Some(Some("in" | "inout"))
+                    ) {
+                        return Err(incomplete(steps));
+                    }
+                }
+            }
+            Some(Some("out")) => {}
+            _ => return Err(incomplete(steps)),
+        }
+    }
+    charge(
+        steps,
+        delta
+            .len()
+            .saturating_mul((usize::BITS - delta.len().max(1).leading_zeros()) as usize + 1),
+    )?;
+    let mut sources: Vec<_> = delta.keys().copied().collect();
+    sources.sort_unstable();
+    for source in sources {
+        for &target in &delta[&source] {
+            charge(steps, 1)?;
+            tail.push(recipe(
+                b,
+                source,
+                (
+                    "Redefinition",
+                    "redefiningFeature",
+                    "redefinedFeature",
+                    b.elements[target].id,
+                ),
+            ));
+        }
+    }
+    // Publish the converged semantic direct bases and reachability graph. The
+    // fixed-point planner consumed these same certified positional identities;
+    // identity dedup below preserves each owner's existing semantic order.
+    for (&source, targets) in &positional.targets {
+        for &target in targets {
+            charge(steps, 1)?;
+            let direct = bases.entry(source).or_insert_with(Vec::new);
+            charge(steps, direct.len().saturating_add(1))?;
+            if !direct.contains(&target) {
+                direct.push(target);
+            }
+            let direct_ids = graph.entry(b.elements[source].id).or_insert_with(Vec::new);
+            charge(steps, direct_ids.len().saturating_add(1))?;
+            if !direct_ids.contains(&b.elements[target].id) {
+                direct_ids.push(b.elements[target].id);
+            }
+        }
+    }
+    // Audit final positional edges as well as direct callee obligations: a
+    // newly mapped argument can consume a tainted owned parameter even when
+    // the callee's own specialization path does not traverse that parameter.
+    // Conjugation changes specialization reachability. Until the minimizer's
+    // graph models that override, refuse a reachable such context rather than
+    // accepting a callee obligation via the legacy raw-specialization path.
+    let mut seen = HashSet::new();
+    let mut todo = Vec::new();
+    for &source in &required {
+        charge(steps, 1)?;
+        todo.push(b.elements[source].id);
+    }
+    for &source in delta.keys() {
+        charge(steps, 1)?;
+        todo.push(b.elements[source].id);
+        let owner = owning
+            .owning_type(b, source, steps)
+            .flatten()
+            .ok_or_else(|| incomplete(steps))?;
+        todo.push(b.elements[owner].id);
+    }
+    while let Some(source) = todo.pop() {
+        charge(steps, 1)?;
+        if !seen.insert(source) {
+            continue;
+        }
+        if conjugated.contains(&source) {
+            return Err(Refusal::Incomplete);
+        }
+        // Feature::supertypes includes its final chaining Feature. The shared
+        // positional base projection does not yet include that derived base;
+        // accepting this context could certify an empty parameter set while
+        // omitting inherited inputs. Refuse only reachable chain contexts.
+        if let Some(element) = raw.element_for_uuid(b, source) {
+            if unresolved_sources.contains(&element)
+                || unadmitted.contains(&element)
+                || raw.bad_chains.contains(&element)
+            {
+                return Err(Refusal::Incomplete);
+            }
+            let relationships = &b.elements[element].owned_relationships;
+            charge(steps, relationships.len())?;
+            for &relationship in relationships {
+                let relation = b.elements.get(relationship).ok_or(Refusal::Incomplete)?;
+                if conforms(relation.ty, "FeatureChaining") {
+                    return Err(Refusal::Incomplete);
+                }
+            }
+        }
+        let next = graph.get(&source).map_or(&[][..], Vec::as_slice);
+        charge(steps, next.len())?;
+        todo.extend_from_slice(next);
+    }
+    // Missing dynamic-family coverage is not a change to the immutable static
+    // positional sequence. Qualify these owners only after proving that no
+    // admitted required edge or positional addition consumes their domain.
+    charge(
+        steps,
+        unresolved_sources.len().saturating_add(unadmitted.len()),
+    )?;
+    incomplete_bases.extend(unresolved_sources);
+    incomplete_bases.extend(unadmitted);
+    let mut assigned = HashSet::new();
+    for row in &prefix.rows {
+        charge(steps, 1)?;
+        if !assigned.insert(row.id) {
+            return Err(Refusal::Collision);
+        }
+    }
+    for row in &tail {
+        charge(steps, 1)?;
+        if raw.element_for_uuid(b, row.id).is_some()
+            || reserved.contains(&row.id)
+            || !assigned.insert(row.id)
+        {
+            return Err(Refusal::Collision);
+        }
+    }
+    if !raw.is_current(b)
+        || !b
+            .elements
+            .revision()
+            .is_some_and(|now| now.same_as(&revision))
+    {
+        return Err(Refusal::Stale);
+    }
+    let mut added_bases = HashMap::<usize, Vec<usize>>::new();
+    for edge in &tail {
+        charge(steps, 1)?;
+        let target = raw
+            .element_for_uuid(b, edge.target)
+            .ok_or(Refusal::Incomplete)?;
+        let targets = added_bases.entry(edge.owner).or_default();
+        charge(steps, targets.len().saturating_add(1))?;
+        if !targets.contains(&target) {
+            targets.push(target);
+        }
+    }
+    charge(steps, required.len().saturating_add(delta.len()))?;
+    let affected_owners = required.into_iter().chain(delta.keys().copied()).collect();
+    Ok(Plan {
+        affected_owners,
+        added_bases,
+        static_prefix: prefix,
+        direct_bases: bases,
+        incomplete_bases,
+        specializations: graph,
+        positional,
+        tail,
+    })
+}
+fn recipe(
+    b: &Builder,
+    owner: usize,
+    edge: (&'static str, &'static str, &'static str, Uuid),
+) -> Edge {
+    let (kind, source_key, target_key, target) = edge;
+    let owner_id = b.elements[owner].id;
+    let id = Uuid::new_v5(
+        &Uuid::NAMESPACE_OID,
+        format!("{owner_id}/implied/{kind}/{target}").as_bytes(),
+    );
+    Edge {
+        owner,
+        owner_id,
+        id,
+        kind,
+        source_key,
+        target_key,
+        target,
+    }
+}
+
+/// Static identity gate used both before detached construction and by the final
+/// transaction's snapshot check. Cold recipes cannot collide with source rows;
+/// a warm prefix must be the exact already-published static relationship view.
+fn validate_fixed_prefix(
+    b: &mut Builder,
+    prefix: &StaticPrefix,
+    raw: &StoredStructure,
+    physical_static_end: Option<usize>,
+    require_recipe_id: bool,
+    steps: &mut usize,
+) -> Result<(), Refusal> {
+    let authored = prefix.authored_end;
+    let materialized = b.implied_from;
+    if materialized.is_some() != physical_static_end.is_some()
+        || physical_static_end
+            .is_some_and(|end| authored.checked_add(prefix.rows.len()) != Some(end))
+    {
+        return Err(Refusal::StaticMismatch);
+    }
+    if materialized.is_some_and(|from| from != authored) {
+        return Err(Refusal::StaticMismatch);
+    }
+    if materialized.is_none() && b.elements.len() != authored {
+        return Err(Refusal::StaticMismatch);
+    }
+    let mut ids = HashSet::new();
+    for (offset, edge) in prefix.rows.iter().enumerate() {
+        charge(steps, 1)?;
+        if edge.owner >= authored || b.elements[edge.owner].id != edge.owner_id {
+            return Err(Refusal::StaticMismatch);
+        }
+        if !ids.insert(edge.id) {
+            return Err(Refusal::Collision);
+        }
+        if materialized.is_none() {
+            if raw.element_for_uuid(b, edge.id).is_some() {
+                return Err(Refusal::Collision);
+            }
+            continue;
+        }
+        let index = authored
+            .checked_add(offset)
+            .ok_or(Refusal::StaticMismatch)?;
+        let node = b.elements.get(index).ok_or(Refusal::StaticMismatch)?;
+        if (require_recipe_id && node.id != edge.id)
+            || node.ty != edge.kind
+            || node.props.get("isImplied").and_then(|v| v.as_bool()) != Some(true)
+            || !node.children.is_empty()
+            || !node.owned_relationships.is_empty()
+            || node.owning_relationship.is_some()
+            || node
+                .props
+                .get(edge.source_key)
+                .and_then(|v| v.as_reference())
+                != Some(edge.owner_id)
+            || node
+                .props
+                .get(edge.target_key)
+                .and_then(|v| v.as_reference())
+                != Some(edge.target)
+        {
+            return Err(Refusal::StaticMismatch);
+        }
+        if super::semantic_ownership::checked_relationship_carrier(b, raw, index, steps)
+            != Some(Some(edge.owner))
+        {
+            return Err(incomplete(steps));
+        }
+        type_relations::endpoint_with_carrier(
+            b,
+            edge.owner,
+            Some(edge.owner),
+            index,
+            &[
+                "specific",
+                "subclassifier",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ],
+            &[
+                "general",
+                "superclassifier",
+                "type",
+                "subsettedFeature",
+                "redefinedFeature",
+                "referencedFeature",
+                "crossedFeature",
+            ],
+            "Type",
+            steps,
+        )
+        .ok_or_else(|| incomplete(steps))?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::json::ResolvedModel;
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut model = crate::model::Model::new();
+        model.add_source("dynamic.kerml", source);
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+    fn static_prefix(r: &mut ResolvedModel) -> Arc<StaticPrefix> {
+        r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+            .unwrap()
+    }
+    #[test]
+    fn canonical_nested_signature_qualification_tracks_actual_consumers() {
+        for (feature, succeeds) in [("feature n", true), ("in p", false)] {
+            let parameter = if succeeds { "in p;" } else { "" };
+            let source = format!(
+                "function F {{{feature} {{feature nested redefines Missing::q;}} {parameter} return result;}} feature call=F(1);"
+            );
+            let mut model =
+                crate::model::Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+            let parsed = model.add_source("nested-signature.kerml", &source);
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let prefix = static_prefix(&mut r);
+            assert_eq!(
+                prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0).is_ok(),
+                succeeds,
+                "{source}"
+            );
+        }
+    }
+
+    #[test]
+    fn canonical_missing_callee_is_qualified_without_poisoning_independent_calls() {
+        for format in [
+            crate::model::GraphFormat::LegacyV2,
+            crate::model::GraphFormat::CanonicalV3,
+        ] {
+            let mut model = crate::model::Model::with_graph_format(format);
+            model.add_source(
+                "scoped-missing-call.kerml",
+                "function F {in p;} feature valid=F(1); feature missing=Missing();",
+            );
+            let mut r = ResolvedModel::build(&model);
+            let calls: Vec<_> = r
+                .elements()
+                .filter(|&e| r.element_type(e) == "InvocationExpression")
+                .collect();
+            let prefix = static_prefix(&mut r);
+            let plan = prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0);
+            if format == crate::model::GraphFormat::CanonicalV3 {
+                let plan = plan.unwrap();
+                assert!(plan.incomplete_bases.contains(&calls[1].0));
+                assert!(!plan.affected_owners.contains(&calls[1].0));
+                assert!(!plan.tail.iter().any(|edge| edge.owner == calls[1].0));
+                assert!(plan.affected_owners.contains(&calls[0].0));
+            } else {
+                assert!(plan.is_err());
+            }
+        }
+    }
+    #[test]
+    fn canonical_unresolved_feature_dependencies_do_not_certify_affected_signatures() {
+        for source in [
+            "function F {in p redefines Missing::q;} feature call=F(1);",
+            "function G {in q;} function F specializes G {in p redefines Missing::q;} feature call=F(1);",
+        ] {
+            let mut model =
+                crate::model::Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+            let parsed = model.add_source("tainted-parameter.kerml", source);
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let prefix = static_prefix(&mut r);
+            assert!(
+                prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0).is_err(),
+                "{source}"
+            );
+        }
+    }
+    #[test]
+    fn canonical_unresolved_target_quarantine_rejects_conflicting_aliases() {
+        for corruption in 0..4 {
+            let mut model =
+                crate::model::Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+            model.add_source("unresolved-aliases.kerml", "class Unused {feature p redefines Missing::q;} function F {return result;} feature call=F();");
+            let mut r = ResolvedModel::build(&model);
+            let relationship =
+                r.b.elements
+                    .iter()
+                    .position(|e| e.ty == "Redefinition")
+                    .unwrap();
+            let p = r.resolve_qualified("Unused::p").unwrap();
+            let f = r.resolve_qualified("F").unwrap();
+            let p_id = r.element_id(p).to_string();
+            let f_id = r.element_id(f).to_string();
+            let (key, value) = match corruption {
+                0 => ("general", serde_json::json!({"@id":f_id})),
+                1 => ("target", serde_json::json!([{"@id":f_id}])),
+                2 => (
+                    "relatedElement",
+                    serde_json::json!([{"@id":p_id},{"@ref":"Different"}]),
+                ),
+                _ => ("general", serde_json::json!(7)),
+            };
+            r.b.elements[relationship].props.insert(key, value);
+            let prefix = static_prefix(&mut r);
+            assert!(
+                prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0).is_err(),
+                "corruption {corruption}"
+            );
+        }
+    }
+    #[test]
+    fn no_argument_and_argument_plans_are_detached_and_keep_static_targets() {
+        for source in [
+            "function F {return result;} feature call=F();",
+            "function F {in p; return result;} feature call=F(1);",
+        ] {
+            let mut r = fixture(source);
+            let f = r.resolve_qualified("F").unwrap().0;
+            let inv =
+                r.b.elements
+                    .iter()
+                    .position(|e| e.ty == "InvocationExpression")
+                    .unwrap();
+            let prefix = static_prefix(&mut r);
+            let n = r.b.elements.len();
+            let old = r.b.positional_redefinitions.clone();
+            let plan =
+                prepare(&mut r.b, Arc::clone(&prefix), &HashSet::new(), None, &mut 0).unwrap();
+            assert_eq!(r.b.elements.len(), n);
+            assert!(r.b.implied.is_none());
+            assert_eq!(
+                r.b.positional_redefinitions.as_ref().map(|p| &p.targets),
+                old.as_ref().map(|p| &p.targets)
+            );
+            assert!(plan.direct_bases[&inv].contains(&f));
+            assert!(
+                plan.tail
+                    .iter()
+                    .any(|e| e.owner == inv && e.target == r.b.elements[f].id)
+            );
+            for (&source, old) in &prefix.positional.targets {
+                assert!(plan.positional.targets[&source].starts_with(old));
+            }
+            if source.contains("in p") {
+                let p = r.resolve_qualified("F::p").unwrap().0;
+                assert!(
+                    plan.tail
+                        .iter()
+                        .any(|e| e.kind == "Redefinition" && e.target == r.b.elements[p].id)
+                );
+            }
+        }
+    }
+    #[test]
+    fn failure_and_colliding_other_tail_ids_never_publish_a_prefix() {
+        let mut r = fixture("function F {return result;} feature call=F();");
+        let prefix = static_prefix(&mut r);
+        let plan = prepare(&mut r.b, Arc::clone(&prefix), &HashSet::new(), None, &mut 0).unwrap();
+        let n = r.b.elements.len();
+        let collision = HashSet::from([plan.tail[0].id]);
+        assert!(matches!(
+            prepare(&mut r.b, Arc::clone(&prefix), &collision, None, &mut 0),
+            Err(Refusal::Collision)
+        ));
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(matches!(
+            prepare(
+                &mut r.b,
+                Arc::clone(&prefix),
+                &HashSet::new(),
+                None,
+                &mut exhausted
+            ),
+            Err(Refusal::WorkLimit)
+        ));
+        assert_eq!(r.b.elements.len(), n);
+        assert!(r.b.implied.is_none());
+        assert!(prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0).is_ok());
+        let mut bad = fixture(
+            "function F {return result;} feature firstCall=F(); feature otherCall=missing();",
+        );
+        let p = static_prefix(&mut bad);
+        let n = bad.b.elements.len();
+        assert!(matches!(
+            prepare(&mut bad.b, p, &HashSet::new(), None, &mut 0),
+            Err(Refusal::Incomplete)
+        ));
+        assert_eq!(bad.b.elements.len(), n);
+    }
+    #[test]
+    fn warmed_static_row_mismatch_is_not_repaired_by_dynamic_admission() {
+        let mut r = fixture(
+            "class A; class B specializes A; function F {return result;} feature call=F();",
+        );
+        let p = static_prefix(&mut r);
+        r.ensure_implied();
+        r.discard_owned_result_tail();
+        let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+        assert!(
+            prepare(
+                &mut r.b,
+                Arc::clone(&p),
+                &HashSet::new(),
+                Some(boundary),
+                &mut 0
+            )
+            .is_ok()
+        );
+        assert!(matches!(
+            prepare(&mut r.b, p, &HashSet::new(), Some(boundary + 1), &mut 0),
+            Err(Refusal::StaticMismatch)
+        ));
+    }
+    #[test]
+    fn contradictory_authored_path_cannot_discharge_a_dynamic_requirement() {
+        let mut r = fixture(
+            "class A; class B specializes A; function F {return result;} feature call=F();",
+        );
+        let p = static_prefix(&mut r);
+        let b = r.resolve_qualified("B").unwrap().0;
+        let relation = r.b.elements[b]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| conforms(r.b.elements[i].ty, "Specialization"))
+            .unwrap();
+        let conflicting = r.b.elements[b].id.to_string();
+        r.b.elements[relation]
+            .props
+            .insert("target", serde_json::json!([{"@id":conflicting}]));
+        assert!(matches!(
+            prepare(&mut r.b, p, &HashSet::new(), None, &mut 0),
+            Err(Refusal::Incomplete)
+        ));
+    }
+}
+
+#[cfg(test)]
+mod indirect_tests {
+    use super::*;
+    use crate::json::{Elem, ResolvedModel};
+    #[test]
+    fn eliminated_callee_edge_still_exposes_its_static_positional_path() {
+        let mut model = crate::model::Model::new();
+        model.add_source("indirect.kerml", "function T {in z; return result;} function Base {in p:T; return result;} function Child specializes Base {in q; return result;} feature call=Base::p(1);");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let p = r.resolve_qualified("Base::p").unwrap().0;
+        let q = r.resolve_qualified("Child::q").unwrap().0;
+        let z = r.resolve_qualified("T::z").unwrap().0;
+        let invocation =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap();
+        // Exercise the effective-end positional rule through the indirect path.
+        // Ordinary parameter pairing deliberately uses a direct base's OWNED
+        // parameters, so an argument→T.z expectation alone would be incorrect.
+        // These two flags make this a graph-level end-pairing control.
+        let argument =
+            r.b.owned_member_elems(invocation, true)
+                .into_iter()
+                .find(|&e| r.b.is_parameter(e))
+                .unwrap();
+        r.b.elements[argument]
+            .props
+            .insert("isEnd", serde_json::json!(true));
+        r.b.elements[z]
+            .props
+            .insert("isEnd", serde_json::json!(true));
+        let source_id = r.b.elements[invocation].id;
+        let q_id = r.b.elements[q].id;
+        let mut props = crate::properties::Properties::new();
+        props.insert(
+            "subsettingFeature",
+            serde_json::json!({"@id":source_id.to_string()}),
+        );
+        props.insert(
+            "subsettedFeature",
+            serde_json::json!({"@id":q_id.to_string()}),
+        );
+        let relation = r.b.elements.len();
+        r.b.elements.push(Elem {
+            ty: "Subsetting",
+            id: Uuid::new_v5(&Uuid::NAMESPACE_OID, b"dynamic indirect test"),
+            path: String::new(),
+            path_parent: None,
+            props,
+            owned_relationships: Default::default(),
+            children: Default::default(),
+            owning_relationship: None,
+        });
+        r.b.elements[invocation].owned_relationships.push(relation);
+        r.b.supported_implied = None;
+        r.b.positional_redefinitions = None;
+        r.b.reset_lookup_caches();
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        assert!(
+            prefix
+                .positional
+                .targets
+                .get(&q)
+                .is_some_and(|targets| targets.contains(&p))
+        );
+        let n = r.b.elements.len();
+        let plan = prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0).unwrap();
+        assert!(
+            !plan
+                .tail
+                .iter()
+                .any(|edge| edge.owner == invocation && edge.target == r.b.elements[p].id),
+            "actual immutable q→p path discharges the direct callee requirement"
+        );
+        assert!(
+            plan.direct_bases
+                .get(&q)
+                .is_some_and(|targets| targets.contains(&p))
+        );
+        assert!(
+            plan.tail.iter().any(|edge| edge.owner == argument
+                && edge.kind == "Redefinition"
+                && edge.target == r.b.elements[z].id),
+            "effective-end pairing must see the actual indirect path"
+        );
+        assert_eq!(r.b.elements.len(), n);
+    }
+}
+
+#[cfg(test)]
+mod warm_prefix_tests {
+    use super::*;
+    use crate::json::ResolvedModel;
+    fn fixture() -> ResolvedModel {
+        let mut model = crate::model::Model::new();
+        model.add_library_source("performances.kerml", "standard library package Performances { function Evaluation {return result;} feature evaluations : Evaluation; }");
+        model.add_source(
+            "user.kerml",
+            "function F {return result;} feature call=F();",
+        );
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+    fn predicted(r: &mut ResolvedModel) -> Arc<StaticPrefix> {
+        let names =
+            r.b.lib_qnames
+                .iter()
+                .map(|(id, qn)| (qn.join("::"), *id))
+                .collect();
+        r.b.static_specialization_prefix(&names, true, Some(&mut 0))
+            .unwrap()
+    }
+    #[test]
+    fn public_row_id_override_keeps_physical_static_identity() {
+        let mut r = fixture();
+        let initial = predicted(&mut r);
+        assert!(!initial.rows.is_empty());
+        r.ensure_implied();
+        r.discard_owned_result_tail();
+        let old = initial.rows[0].id;
+        let new = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"overridden static prefix row");
+        r.override_ids(&HashMap::from([(old, new)]));
+        let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+        let proposed = predicted(&mut r);
+        let captured = capture_static_prefix(&mut r.b, proposed, Some(boundary), &mut 0).unwrap();
+        assert_eq!(captured.rows[0].id, new);
+        assert_eq!(r.b.elements[captured.authored_end].id, new);
+        assert!(prepare(&mut r.b, captured, &HashSet::new(), Some(boundary), &mut 0).is_ok());
+    }
+    #[test]
+    fn warm_generic_alias_corruption_cannot_be_recaptured() {
+        let mut r = fixture();
+        let p = predicted(&mut r);
+        r.ensure_implied();
+        r.discard_owned_result_tail();
+        let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+        let f = r.resolve_qualified("F").unwrap();
+        let wrong = r.element_id(f).to_string();
+        r.b.elements[p.authored_end]
+            .props
+            .insert("target", serde_json::json!([{"@id":wrong}]));
+        let proposed = predicted(&mut r);
+        assert!(capture_static_prefix(&mut r.b, proposed, Some(boundary), &mut 0).is_err());
+    }
+    #[test]
+    fn unrelated_unresolved_specialization_is_an_explicit_batch_limit() {
+        let mut model = crate::model::Model::new();
+        model.add_source(
+            "user.kerml",
+            "class Unused specializes Missing; function F {return result;} feature call=F();",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let prefix = predicted(&mut r);
+        assert!(matches!(
+            prepare(&mut r.b, prefix, &HashSet::new(), None, &mut 0),
+            Err(Refusal::Incomplete)
+        ));
+        assert!(r.b.implied.is_none());
+    }
+}
+
+#[cfg(test)]
+mod named_callee_chain_gap_tests {
+    use super::*;
+    use crate::{
+        json::{ResolvedModel, id_ref},
+        model::Model,
+    };
+    fn fixture(call: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        let source = format!(
+            "function F {{in p; return r;}} class Holder {{feature fnMember : F;}} feature h : Holder; feature chain chains h.fnMember; feature indirect :> chain; feature safe=F(1); feature call = {call}(1);"
+        );
+        let result = m.add_source("chain.kerml", &source);
+        assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
+        ResolvedModel::build(&m)
+    }
+    fn plan(r: &mut ResolvedModel, steps: &mut usize) -> Result<Plan, Refusal> {
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        prepare(&mut r.b, prefix, &HashSet::new(), None, steps)
+    }
+    #[test]
+    fn named_chain_callee_cannot_certify_empty_inputs() {
+        for call in ["chain", "indirect"] {
+            let mut r = fixture(call);
+            let before = r.b.elements.len();
+            assert!(
+                matches!(plan(&mut r, &mut 0), Err(Refusal::Incomplete)),
+                "{call}"
+            );
+            assert_eq!(r.b.elements.len(), before);
+            assert!(r.b.implied.is_none());
+        }
+    }
+    #[test]
+    fn malformed_cyclic_and_inverse_chain_evidence_cannot_hide_from_guard() {
+        for mode in 0..5 {
+            let mut r = fixture("chain");
+            let chain = r.resolve_qualified("chain").unwrap().0;
+            let indirect = r.resolve_qualified("indirect").unwrap().0;
+            let first = r.b.elements[chain]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&e| r.b.elements[e].ty == "FeatureChaining")
+                .unwrap();
+            match mode {
+                0 => r.b.set(first, "chainingFeature", serde_json::json!(null)),
+                1 => {
+                    let id = r.b.elements[chain].id;
+                    r.b.set(first, "chainingFeature", id_ref(id));
+                }
+                2 => {
+                    let id = r.b.elements[indirect].id;
+                    r.b.set(first, "featureChained", id_ref(id));
+                }
+                3 => r.b.elements[chain].owned_relationships.push(first),
+                4 => {
+                    // The declared source remains chain, but only another
+                    // Feature carries the row: inverse bad_chains must refuse.
+                    let id = r.b.elements[chain].id;
+                    r.b.set(first, "featureChained", id_ref(id));
+                    r.b.elements[chain].owned_relationships = Vec::new().into();
+                    r.b.elements[indirect].owned_relationships.push(first);
+                    let id = r.b.elements[indirect].id;
+                    r.b.set(first, "owningRelatedElement", id_ref(id));
+                }
+                _ => unreachable!(),
+            }
+            assert!(
+                matches!(plan(&mut r, &mut 0), Err(Refusal::Incomplete)),
+                "mode {mode}"
+            );
+        }
+    }
+    #[test]
+    fn unrelated_chains_preserve_valid_inputs_and_budget_retry() {
+        let mut r = fixture("F");
+        let p = r.resolve_qualified("F::p").unwrap().0;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(matches!(
+            plan(&mut r, &mut exhausted),
+            Err(Refusal::WorkLimit)
+        ));
+        let accepted = plan(&mut r, &mut 0).unwrap();
+        assert_eq!(
+            accepted
+                .tail
+                .iter()
+                .filter(|e| e.kind == "Redefinition" && e.target == r.b.elements[p].id)
+                .count(),
+            2
+        );
+        let n = r.b.elements.len();
+        assert!(r.b.implied.is_none());
+        assert!(plan(&mut r, &mut 0).is_ok());
+        assert_eq!(r.b.elements.len(), n);
+    }
+}
+
+#[cfg(test)]
+mod input_direction_tests {
+    use super::*;
+    use crate::{
+        json::{ElementRef, ResolvedModel, id_ref},
+        model::Model,
+    };
+    fn fixture(parameters: &str, arguments: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        let parsed = model.add_source(
+            "directions.kerml",
+            &format!("function F {{{parameters} return r;}} feature call=F({arguments});"),
+        );
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        ResolvedModel::build(&model)
+    }
+    fn plan(r: &mut ResolvedModel, steps: &mut usize) -> Result<Plan, Refusal> {
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        prepare(&mut r.b, prefix, &HashSet::new(), None, steps)
+    }
+    #[test]
+    fn output_before_input_refuses_entire_new_batch() {
+        let mut r = fixture("out ignored; in p;", "1");
+        let rows = r.b.elements.len();
+        assert!(matches!(plan(&mut r, &mut 0), Err(Refusal::Incomplete)));
+        assert_eq!(r.b.elements.len(), rows);
+        assert!(r.b.implied.is_none());
+        let call =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap();
+        let emitted = r.implied_relationships(ElementRef(call));
+        assert!(
+            !emitted
+                .iter()
+                .any(|e| r.b.elements[e.0].ty == "FeatureTyping")
+        );
+        assert!(r.feature_type_report(ElementRef(call)).function.is_err());
+    }
+    #[test]
+    fn input_inout_and_named_argument_controls_preserve_correct_identity() {
+        for (params, args) in [
+            ("in p; out ignored;", "1"),
+            ("inout p; out ignored;", "1"),
+            ("out ignored; in p;", "p=1"),
+        ] {
+            let mut r = fixture(params, args);
+            let p = r.resolve_qualified("F::p").unwrap().0;
+            let ignored = r.resolve_qualified("F::ignored").unwrap().0;
+            let accepted = plan(&mut r, &mut 0).unwrap();
+            assert!(
+                !accepted
+                    .tail
+                    .iter()
+                    .any(|e| e.kind == "Redefinition" && e.target == r.b.elements[ignored].id)
+            );
+            if args == "1" {
+                assert!(
+                    accepted
+                        .tail
+                        .iter()
+                        .any(|e| e.kind == "Redefinition" && e.target == r.b.elements[p].id)
+                );
+            }
+        }
+    }
+    #[test]
+    fn default_direction_needs_exact_membership_evidence_and_malformed_values_refuse() {
+        for bad in 0..5 {
+            let mut r = fixture("in p;", "1");
+            let p = r.resolve_qualified("F::p").unwrap().0;
+            let membership = r.b.elements[p].owning_relationship.unwrap();
+            r.b.elements[membership].ty = "ParameterMembership";
+            match bad {
+                0 => {
+                    r.b.elements[p]
+                        .props
+                        .entries
+                        .make_mut()
+                        .retain(|(key, _)| key.name() != "direction");
+                }
+                1 => r.b.set(p, "direction", serde_json::json!(null)),
+                2 => r.b.set(p, "direction", serde_json::json!("invalid")),
+                3 => {
+                    let id = r.b.elements[membership].id;
+                    r.b.set(membership, "ownedMemberParameter", id_ref(id));
+                }
+                4 => {
+                    r.b.elements[p]
+                        .props
+                        .entries
+                        .make_mut()
+                        .retain(|(key, _)| key.name() != "direction");
+                    r.b.elements[p].owning_relationship = None;
+                }
+                _ => unreachable!(),
+            }
+            if bad == 4 {
+                // The legacy positional selector omits this malformed member,
+                // so no new edge reaches the direction guard. The shared
+                // direction witness must still refuse its broken reciprocity;
+                // full Invocation input cardinality is a separate obligation.
+                let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+                assert!(membership_evidence::parameter_direction(&r.b, &raw, p, &mut 0).is_none());
+            } else {
+                let result = plan(&mut r, &mut 0);
+                assert_eq!(result.is_ok(), bad == 0, "case {bad}");
+            }
+        }
+    }
+    #[test]
+    fn ordinary_null_direction_cannot_admit_an_input_redefinition() {
+        let mut r = fixture("in p;", "1");
+        let p = r.resolve_qualified("F::p").unwrap().0;
+        let membership = r.b.elements[p].owning_relationship.unwrap();
+        assert_eq!(r.b.elements[membership].ty, "FeatureMembership");
+        r.b.set(p, "direction", serde_json::json!(null));
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            membership_evidence::parameter_direction(&r.b, &raw, p, &mut 0),
+            Some(None)
+        );
+        // A plan may omit the undirected target altogether. It must never
+        // accept it as an input argument; arity is a separate certificate.
+        if let Ok(accepted) = plan(&mut r, &mut 0) {
+            assert!(
+                !accepted
+                    .tail
+                    .iter()
+                    .any(|e| e.kind == "Redefinition" && e.target == r.b.elements[p].id)
+            );
+        }
+    }
+    #[test]
+    fn exhausted_direction_admission_retries_without_partial_rows() {
+        let mut r = fixture("in p;", "1");
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(matches!(plan(&mut r, &mut steps), Err(Refusal::WorkLimit)));
+        assert!(r.b.implied.is_none());
+        assert!(plan(&mut r, &mut 0).is_ok());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/end_constancy.rs b/crates/sysmlv2-model/src/json/end_constancy.rs
new file mode 100644
index 0000000..f691bf8
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/end_constancy.rs
@@ -0,0 +1,553 @@
+//! Local constancy obligations over owned flags and checked Usage variability.
+//! Canonical textual completion shares the checked Usage variability evidence.
+use super::{ElementRef, ResolvedModel, UsageVariabilityIssue, structural_index::StoredStructure};
+use crate::metaclass::conforms;
+
+/// Why the local constancy obligations cannot be certified.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum EndConstancyIssue {
+    InvalidElement,
+    InvalidBoolean(&'static str),
+    UnsupportedConfiguration,
+    StaleEvidence,
+    WorkLimit,
+    UsageVariability(UsageVariabilityIssue),
+}
+
+/// Results of the two independent KerML Feature constancy implications.
+/// `Ok(false)` is a witnessed violation; an error is unavailable evidence.
+/// Success does not certify ownership, featuring or whole-model validity.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct EndConstancyReport {
+    /// `isEnd and isVariable implies isConstant`.
+    pub variable_end_is_constant: Result<bool, EndConstancyIssue>,
+    /// `isConstant implies isVariable` (also applies to non-end Features).
+    pub constant_is_variable: Result<bool, EndConstancyIssue>,
+    pub steps: usize,
+}
+
+impl EndConstancyReport {
+    fn refused(issue: EndConstancyIssue, steps: usize) -> Self {
+        Self {
+            variable_end_is_constant: Err(issue),
+            constant_is_variable: Err(issue),
+            steps,
+        }
+    }
+}
+
+fn owned_boolean(
+    r: &ResolvedModel,
+    feature: ElementRef,
+    key: &'static str,
+) -> Result<bool, EndConstancyIssue> {
+    // These three owned Feature declarations have a normative false default.
+    // Absence and explicit false have the same implication truth, but neither
+    // is rewritten as a textual/default repair. Explicit null is malformed.
+    match r.b.elements[feature.0].props.get(key) {
+        None => Ok(false),
+        Some(value) => value
+            .as_bool()
+            .ok_or(EndConstancyIssue::InvalidBoolean(key)),
+    }
+}
+
+impl ResolvedModel {
+    /// Canonical textual defaults are completed only with shared variability
+    /// evidence. Imported flags and explicit textual constant prefixes remain
+    /// owned evidence, including inconsistent values diagnosed by the report.
+    pub(crate) fn canonical_end_constant_with_budget(
+        &mut self,
+        feature: ElementRef,
+        initial_steps: usize,
+    ) -> Option<super::UsageVariabilityReport> {
+        if !self.canonical_text_end(feature) {
+            return None;
+        }
+        let steps = initial_steps.saturating_add(1);
+        let stored = self.b.elements[feature.0].props.get("isConstant");
+        let value = match stored {
+            None => Ok(false),
+            Some(value) => value
+                .as_bool()
+                .ok_or(UsageVariabilityIssue::InvalidBoolean("isConstant")),
+        };
+        if steps > crate::eval::MAX_STEPS {
+            return Some(super::UsageVariabilityReport {
+                value: Err(UsageVariabilityIssue::WorkLimit),
+                steps,
+            });
+        }
+        match value {
+            Ok(false) => Some(self.usage_variability_report_with_budget(feature, steps)),
+            value => Some(super::UsageVariabilityReport { value, steps }),
+        }
+    }
+
+    /// Check the conditional constant-end and constant-variable obligations.
+    ///
+    /// Exact Features use their owned isVariable value/default. Usages use the
+    /// shared mayTimeVary certificate for their effective isVariable declaration;
+    /// stored derived aliases do not override that result. Other Feature kinds
+    /// remain qualified. Malformed flags are refused before Boolean shortcuts.
+    /// CanonicalV3 textual ends use the same proven completion as checked reads
+    /// and emission. Imported flags are retained. This never mutates rows or certifies evaluability.
+    pub fn end_constancy_report(&mut self, feature: ElementRef) -> EndConstancyReport {
+        self.end_constancy_report_with_budget(feature, 0)
+    }
+
+    pub(in crate::json) fn end_constancy_report_with_budget(
+        &mut self,
+        feature: ElementRef,
+        initial_steps: usize,
+    ) -> EndConstancyReport {
+        use EndConstancyIssue::*;
+        let mut steps = initial_steps.saturating_add(4);
+        if steps > crate::eval::MAX_STEPS {
+            return EndConstancyReport::refused(WorkLimit, steps);
+        }
+        let Some(row) = self.b.elements.get(feature.0) else {
+            return EndConstancyReport::refused(InvalidElement, steps);
+        };
+        let usage = conforms(row.ty, "Usage");
+        if row.ty != "Feature" && !usage {
+            return EndConstancyReport::refused(UnsupportedConfiguration, steps);
+        }
+        if self.b.positional_planning {
+            return EndConstancyReport::refused(UnsupportedConfiguration, steps);
+        }
+        let flags = (|| {
+            Ok((
+                owned_boolean(self, feature, "isEnd")?,
+                owned_boolean(self, feature, "isConstant")?,
+                owned_boolean(self, feature, "isVariable")?,
+            ))
+        })();
+        let (is_end, constant, owned_variable) = match flags {
+            Ok(flags) => flags,
+            Err(issue) => return EndConstancyReport::refused(issue, steps),
+        };
+        let Some(structure) = StoredStructure::for_query(&mut self.b, &mut steps) else {
+            return EndConstancyReport::refused(
+                if steps > crate::eval::MAX_STEPS {
+                    WorkLimit
+                } else {
+                    InvalidElement
+                },
+                steps,
+            );
+        };
+        if !structure.ids_unique {
+            return EndConstancyReport::refused(InvalidElement, steps);
+        }
+        let variable = if usage {
+            let report = self.usage_variability_report_with_budget(feature, steps);
+            steps = report.steps;
+            match report.value {
+                // Malformed retained input is not a missing optional dependency.
+                Err(UsageVariabilityIssue::InvalidBoolean(key)) => {
+                    return EndConstancyReport::refused(InvalidBoolean(key), steps);
+                }
+                Err(
+                    issue @ (UsageVariabilityIssue::InvalidElement
+                    | UsageVariabilityIssue::InvalidOwnership),
+                ) => {
+                    return EndConstancyReport::refused(UsageVariability(issue), steps);
+                }
+                result => result.map_err(UsageVariability),
+            }
+        } else {
+            Ok(owned_variable)
+        };
+        if steps > crate::eval::MAX_STEPS {
+            return EndConstancyReport::refused(WorkLimit, steps);
+        }
+        if !structure.is_current(&self.b) {
+            return EndConstancyReport::refused(StaleEvidence, steps);
+        }
+        if self.canonical_text_end(feature) && !constant {
+            // Completion is conditional on this exact certificate. Unknown
+            // evidence cannot certify either implication via a stored false.
+            return EndConstancyReport {
+                variable_end_is_constant: variable.map(|_| true),
+                constant_is_variable: variable.map(|_| true),
+                steps,
+            };
+        }
+        EndConstancyReport {
+            variable_end_is_constant: if !is_end || constant {
+                Ok(true)
+            } else {
+                variable.map(|variable| !variable)
+            },
+            constant_is_variable: if !constant { Ok(true) } else { variable },
+            steps,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::{GraphFormat, Model};
+    use serde_json::json;
+
+    fn feature() -> (ResolvedModel, ElementRef) {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("flags.kerml", "feature x;")
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("x").unwrap();
+        (r, x)
+    }
+
+    fn canonical(source: &str) -> Model {
+        let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+        model.add_library_source(
+            "links.kerml",
+            "standard library package Links { assoc SelfLink; }",
+        );
+        let result = model.add_source("ends.sysml", source);
+        assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
+        model
+    }
+
+    fn named_row(document: &serde_json::Value) -> &serde_json::Value {
+        document
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|row| row["declaredName"] == "x")
+            .unwrap()
+    }
+
+    #[test]
+    fn canonical_excluded_end_uses_proven_false_across_reads_and_emission() {
+        let model = canonical("part def P { end ref x : Links::SelfLink; }");
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("P::x").unwrap();
+        let before = r.element_properties(x);
+        assert_eq!(r.usage_variability_report(x).value, Ok(false));
+        assert_eq!(r.property(x, "isConstant"), Ok(json!(false)));
+        let report = r.end_constancy_report(x);
+        assert_eq!(report.variable_end_is_constant, Ok(true));
+        assert_eq!(report.constant_is_variable, Ok(true));
+        assert_eq!(
+            named_row(&super::super::model_to_compact_json(&model))["isConstant"],
+            false
+        );
+        let full = crate::full::model_to_full_json(&model);
+        for property in ["isConstant", "isVariable", "mayTimeVary"] {
+            assert_eq!(named_row(&full)[property], false, "{property}");
+        }
+        assert_eq!(r.element_properties(x), before);
+        assert!(matches!(
+            r.canonical_end_constant_with_budget(x, crate::eval::MAX_STEPS)
+                .unwrap()
+                .value,
+            Err(UsageVariabilityIssue::WorkLimit)
+        ));
+        assert_eq!(r.property(x, "isConstant"), Ok(json!(false)));
+    }
+
+    #[test]
+    fn canonical_unknown_end_stays_qualified_and_never_acquires_blanket_true() {
+        let model = canonical("part def P { end ref x; }");
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("P::x").unwrap();
+        assert!(matches!(
+            r.property(x, "isConstant"),
+            Err(super::super::PropertyError::IncompleteUsageVariability(_))
+        ));
+        assert!(r.end_constancy_report(x).constant_is_variable.is_err());
+        assert!(r.end_constancy_report(x).variable_end_is_constant.is_err());
+        for doc in [
+            super::super::model_to_compact_json(&model),
+            crate::full::model_to_full_json(&model),
+        ] {
+            assert_eq!(named_row(&doc)["isConstant"], false);
+            assert_ne!(named_row(&doc)["mayTimeVary"], true);
+            assert_ne!(named_row(&doc)["isVariable"], true);
+        }
+        let errors = r.to_full_json_strict().unwrap_err();
+        assert!(
+            errors
+                .issues
+                .iter()
+                .any(|issue| issue.element_id == r.element_id(x) && issue.property == "isConstant")
+        );
+    }
+
+    #[test]
+    fn canonical_payload_flags_remain_owned_across_rebuild_and_new_source_units() {
+        use std::collections::HashMap;
+        for constant in [
+            None,
+            Some(json!(false)),
+            Some(json!(true)),
+            Some(json!(null)),
+        ] {
+            let mut doc = super::super::model_to_compact_json(&canonical(
+                "part def P { end ref x : Links::SelfLink; }",
+            ));
+            let row = doc
+                .as_array_mut()
+                .unwrap()
+                .iter_mut()
+                .find(|row| row["declaredName"] == "x")
+                .unwrap();
+            row.as_object_mut().unwrap().remove("isConstant");
+            if let Some(value) = &constant {
+                row["isConstant"] = value.clone();
+            }
+            let (mut model, mut loaded, _, _) = crate::loader::load_document_with_format(
+                &doc,
+                &HashMap::new(),
+                GraphFormat::CanonicalV3,
+            )
+            .unwrap();
+            let x = loaded.resolve_qualified("P::x").unwrap();
+            assert!(!loaded.canonical_text_end(x));
+            if constant.as_ref().is_some_and(serde_json::Value::is_null) {
+                assert!(loaded.property(x, "isConstant").is_err());
+            } else {
+                assert_eq!(
+                    loaded.property(x, "isConstant"),
+                    Ok(constant.clone().unwrap_or(json!(false)))
+                );
+                if constant == Some(json!(true)) {
+                    // The library is intentionally absent on this imported
+                    // graph, so the retained inconsistency is not guessed.
+                    assert!(loaded.end_constancy_report(x).constant_is_variable.is_err());
+                }
+            }
+            model.add_library_source("extra.kerml", "package Extra { class C; }");
+            model.add_source("new.sysml", "end ref y;");
+            let mut rebuilt = ResolvedModel::build(&model);
+            let x = rebuilt.resolve_qualified("P::x").unwrap();
+            let y = rebuilt.resolve_qualified("y").unwrap();
+            assert!(!rebuilt.canonical_text_end(x));
+            assert!(rebuilt.canonical_text_end(y));
+            let full = crate::full::model_to_full_json(&model);
+            assert_eq!(
+                named_row(&full)["isConstant"],
+                constant.unwrap_or(json!(false))
+            );
+        }
+    }
+
+    #[test]
+    fn canonical_text_provenance_survives_prepared_library_paths() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut base = Model::with_graph_format(GraphFormat::CanonicalV3);
+        base.add_library_source(
+            "base.kerml",
+            "standard library package Base { classifier Anything; feature things : Anything; } standard library package Links { assoc SelfLink; }",
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(151).unwrap(), 151).unwrap());
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("base.kerml", "standard library package Base { classifier Anything; feature things : Anything; } standard library package Links { assoc SelfLink; }");
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("ends.sysml", "part def P { end ref x : Links::SelfLink; }");
+            let mut r = ResolvedModel::build(&model);
+            let x = r.resolve_qualified("P::x").unwrap();
+            assert!(r.canonical_text_end(x));
+            assert_eq!(r.property(x, "isConstant"), Ok(json!(false)));
+            assert_eq!(
+                named_row(&crate::full::model_to_full_json(&model))["isConstant"],
+                false
+            );
+        }
+    }
+
+    #[test]
+    fn exact_feature_truth_table_preserves_rows_and_same_length_edits() {
+        let (mut r, x) = feature();
+        for end in [false, true] {
+            for variable in [false, true] {
+                for constant in [false, true] {
+                    r.b.set(x.0, "isEnd", json!(end));
+                    r.b.set(x.0, "isVariable", json!(variable));
+                    r.b.set(x.0, "isConstant", json!(constant));
+                    let before = r.element_properties(x);
+                    let count = r.b.elements.len();
+                    let report = r.end_constancy_report(x);
+                    assert_eq!(
+                        report.variable_end_is_constant,
+                        Ok(!end || !variable || constant)
+                    );
+                    assert_eq!(report.constant_is_variable, Ok(!constant || variable));
+                    assert_eq!(r.element_properties(x), before);
+                    assert_eq!(r.b.elements.len(), count);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn defaults_are_false_and_malformed_flags_precede_shortcuts() {
+        let (mut r, x) = feature();
+        for key in ["isEnd", "isVariable", "isConstant"] {
+            r.b.elements[x.0]
+                .props
+                .entries
+                .make_mut()
+                .retain(|(k, _)| k.name() != key);
+        }
+        let report = r.end_constancy_report(x);
+        assert_eq!(report.variable_end_is_constant, Ok(true));
+        assert_eq!(report.constant_is_variable, Ok(true));
+        for key in ["isEnd", "isVariable", "isConstant"] {
+            for value in [serde_json::Value::Null, json!("false"), json!(0), json!([])] {
+                r.b.set(x.0, key, value);
+                let report = r.end_constancy_report(x);
+                assert_eq!(
+                    report.variable_end_is_constant,
+                    Err(EndConstancyIssue::InvalidBoolean(key))
+                );
+                assert_eq!(
+                    report.constant_is_variable,
+                    Err(EndConstancyIssue::InvalidBoolean(key))
+                );
+                r.b.elements[x.0]
+                    .props
+                    .entries
+                    .make_mut()
+                    .retain(|(k, _)| k.name() != key);
+            }
+        }
+    }
+
+    #[test]
+    fn work_and_identity_failures_do_not_poison_retry() {
+        let (mut r, x) = feature();
+        let report = r.end_constancy_report_with_budget(x, crate::eval::MAX_STEPS);
+        assert_eq!(
+            report.variable_end_is_constant,
+            Err(EndConstancyIssue::WorkLimit)
+        );
+        assert_eq!(
+            report.constant_is_variable,
+            Err(EndConstancyIssue::WorkLimit)
+        );
+        assert!(r.end_constancy_report(x).constant_is_variable.is_ok());
+        let other = r.b.elements[0].id;
+        let original = r.b.elements[x.0].id;
+        r.b.elements[x.0].id = other;
+        assert_eq!(
+            r.end_constancy_report(x).constant_is_variable,
+            Err(EndConstancyIssue::InvalidElement)
+        );
+        r.b.elements[x.0].id = original;
+        assert!(r.end_constancy_report(x).constant_is_variable.is_ok());
+    }
+
+    #[test]
+    fn usage_uses_checked_variability_instead_of_stored_aliases() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut model = Model::with_graph_format(format);
+            assert!(
+                model
+                    .add_source("root.sysml", "ref x;")
+                    .diagnostics
+                    .is_empty()
+            );
+            let mut r = ResolvedModel::build(&model);
+            let x = r.resolve_qualified("x").unwrap();
+            r.b.set(x.0, "isEnd", json!(true));
+            r.b.set(x.0, "isConstant", json!(true));
+            r.b.set(x.0, "isVariable", json!(true));
+            r.b.set(x.0, "mayTimeVary", json!(true));
+            assert_eq!(r.usage_variability_report(x).value, Ok(false));
+            let before = r.element_properties(x);
+            let report = r.end_constancy_report(x);
+            assert_eq!(report.variable_end_is_constant, Ok(true));
+            assert_eq!(report.constant_is_variable, Ok(false));
+            assert_eq!(r.element_properties(x), before);
+            r.b.set(x.0, "mayTimeVary", json!(null));
+            assert_eq!(
+                r.end_constancy_report(x).constant_is_variable,
+                Err(EndConstancyIssue::InvalidBoolean("mayTimeVary"))
+            );
+        }
+    }
+
+    #[test]
+    fn unknown_usage_variability_cannot_become_a_missing_false() {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("unknown.sysml", "part def P { ref x; }")
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("P::x").unwrap();
+        assert!(r.usage_variability_report(x).value.is_err());
+        r.b.set(x.0, "isEnd", json!(true));
+        r.b.set(x.0, "isConstant", json!(false));
+        let report = r.end_constancy_report(x);
+        assert!(report.variable_end_is_constant.is_err());
+        assert_eq!(report.constant_is_variable, Ok(true));
+        r.b.set(x.0, "isConstant", json!(true));
+        let report = r.end_constancy_report(x);
+        assert_eq!(report.variable_end_is_constant, Ok(true));
+        assert!(report.constant_is_variable.is_err());
+    }
+
+    #[test]
+    fn positive_usage_variability_ignores_false_derived_aliases() {
+        let mut model = Model::new();
+        assert!(model.add_library_source("roles.kerml", "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; assoc HappensLink specializes Base::Anything;} standard library package Links {assoc SelfLink specializes Base::Anything;}").diagnostics.is_empty());
+        assert!(
+            model
+                .add_source(
+                    "positive.sysml",
+                    "part def P :> Occurrences::Occurrence { ref x :> Base::things; }"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("P::x").unwrap();
+        r.b.set(x.0, "isConstant", json!(true));
+        r.b.set(x.0, "isVariable", json!(false));
+        r.b.set(x.0, "mayTimeVary", json!(false));
+        let report = r.end_constancy_report(x);
+        assert_eq!(report.variable_end_is_constant, Ok(true));
+        assert_eq!(report.constant_is_variable, Ok(true));
+        let p = r.resolve_qualified("P").unwrap();
+        assert_eq!(
+            r.end_constancy_report(p).constant_is_variable,
+            Err(EndConstancyIssue::UnsupportedConfiguration)
+        );
+        assert_eq!(
+            r.end_constancy_report(ElementRef(usize::MAX))
+                .constant_is_variable,
+            Err(EndConstancyIssue::InvalidElement)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/exposure.rs b/crates/sysmlv2-model/src/json/exposure.rs
new file mode 100644
index 0000000..99f9432
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/exposure.rs
@@ -0,0 +1,190 @@
+//! Compatibility exposure projection using import Membership identities.
+use super::{
+    Builder, ElementRef, InheritedBindings, LookupAccess, LookupResult, MembershipContext,
+    ResolvedModel,
+};
+use std::collections::{HashMap, HashSet};
+
+impl ResolvedModel {
+    /// Elements contributed by the view's owned `expose` relationships, in
+    /// relationship/import discovery order, deduplicated after Membership
+    /// projection. Ordinary imports can resolve exposure names but do not
+    /// themselves expose elements. Owned, imported, and inherited view conditions apply.
+    ///
+    /// This retains the compatibility filter policy: an unknown condition
+    /// admits the element. Imported-membership completeness and normative
+    /// metadata-witness evaluation remain qualified. Inherited contributions are
+    /// reduced within each operation's namespace/type exclusion context. The
+    /// scoped base adapter retains compatibility lookup, chain, and metadata
+    /// behavior; it is not a complete identity-based supertypes proof. This is not an exact
+    /// `includeAsExposed` conformance certificate.
+    pub fn view_exposed_elements(&mut self, view: ElementRef) -> Vec<ElementRef> {
+        let Some(&scope) = self.b.elem_scope.get(&view.0) else {
+            return Vec::new();
+        };
+        if self.b.semantic_ready {
+            self.b.ensure_positional_redefinitions();
+        }
+        let mut context = MembershipContext::default();
+        let filters = self.b.exposure_condition_ids(scope, &mut context);
+        let memberships = self.b.exposure_memberships(view.0, scope, &mut context);
+        let mut emitted = HashSet::new();
+        memberships
+            .into_iter()
+            .filter_map(|membership| {
+                let element = self.b.stored_membership_member(membership)?;
+                if !emitted.insert(element) {
+                    return None;
+                }
+                self.b
+                    .import_filter_set_admits(&filters, element)
+                    .then_some(ElementRef(element))
+            })
+            .collect()
+    }
+}
+
+impl Builder {
+    /// The scope already indexes local filter ASTs. Imported and inherited
+    /// conditions are selected through actual surviving ElementFilterMembership
+    /// identities,
+    /// not through an unfiltered walk of every ancestor's filter list.
+    fn exposure_condition_ids(
+        &mut self,
+        scope: usize,
+        context: &mut MembershipContext,
+    ) -> Vec<usize> {
+        // Every supported condition is indexed here, including imported and
+        // inherited declarations. No condition projection is needed if the
+        // entire model has no filter expression.
+        if self.filter_exprs.is_empty() {
+            return Vec::new();
+        }
+        let mut filters = self.scopes[scope].filters.clone();
+        let inherited = self.inherited_bindings(scope, true);
+        let mut imported = InheritedBindings::default();
+        let imported_order = self.imported_bindings_with_context(
+            scope,
+            true,
+            LookupAccess::All,
+            &mut imported,
+            context,
+        );
+        let mut wanted = HashSet::new();
+        let mut scopes = Vec::new();
+        let mut seen_scopes = HashSet::new();
+        for &membership in inherited.membership_order.iter().chain(&imported_order) {
+            if !crate::metaclass::conforms(self.elements[membership].ty, "ElementFilterMembership")
+            {
+                continue;
+            }
+            wanted.insert(membership);
+            let owner = self.elements[membership]
+                .props
+                .get("owningRelatedElement")
+                .and_then(|value| value.as_reference())
+                .and_then(|id| self.element_index_of_uuid(id));
+            if let Some(declaration_scope) =
+                owner.and_then(|owner| self.elem_scope.get(&owner).copied())
+            {
+                if seen_scopes.insert(declaration_scope) {
+                    scopes.push(declaration_scope);
+                }
+            }
+        }
+        for declaration_scope in scopes {
+            filters.extend(
+                self.scopes[declaration_scope]
+                    .filters
+                    .iter()
+                    .copied()
+                    .filter(|&id| wanted.contains(&self.filter_exprs[id].0)),
+            );
+        }
+        let mut seen_filters = HashSet::new();
+        filters.retain(|id| seen_filters.insert(*id));
+        filters
+    }
+
+    /// Project each Expose's import operation before final element dedup.
+    /// A filtered expose's anonymous FilterPackage is represented in the
+    /// resolution indexes by the original target plus its recorded filters.
+    fn exposure_memberships(
+        &mut self,
+        view: usize,
+        scope: usize,
+        context: &mut MembershipContext,
+    ) -> Vec<usize> {
+        let members = self.scopes[scope].member_imports.clone();
+        let namespaces = self.import_scopes(scope);
+        let member_by_rel: HashMap<_, _> = members
+            .iter()
+            .enumerate()
+            .map(|(index, entry)| (entry.relationship, index))
+            .collect();
+        let namespace_by_rel: HashMap<_, _> = namespaces
+            .iter()
+            .enumerate()
+            .map(|(index, entry)| (entry.relationship, index))
+            .collect();
+        let relationships = self.elements[view].owned_relationships.to_vec();
+        let mut order = Vec::new();
+        let mut out = InheritedBindings::default();
+        // This memo's key includes access, recursion, and the filter path.
+        // Sharing it avoids diamond expansion without conflating filtered paths.
+        let mut seen = HashMap::new();
+        // Expose.importedMemberships starts with the empty exclusion set.
+        // collect_import_scope adds each visited namespace to break cycles.
+        let mut excluded = Vec::new();
+        for relationship in relationships {
+            if !crate::metaclass::conforms(self.elements[relationship].ty, "Expose") {
+                continue;
+            }
+            if let Some(&index) = member_by_rel.get(&relationship) {
+                let entry = &members[index];
+                // A plain Expose is import-all. A bracket wrapper owns an
+                // ordinary, non-import-all inner import (FilterPackageImport).
+                let all = entry.filters.is_empty();
+                let origin = self.set_identity_origin(relationship);
+                let resolved = self.resolve_result(scope, &entry.target, 0, all);
+                self.identity_origin_unit = origin;
+                if let LookupResult::Found(element, _, membership) = resolved {
+                    if self.import_filter_set_admits(&entry.filters, element) {
+                        if let Some(membership) =
+                            membership.or(self.elements[element].owning_relationship)
+                        {
+                            order.push(membership);
+                        }
+                    }
+                }
+            }
+            if let Some(&index) = namespace_by_rel.get(&relationship) {
+                let entry = &namespaces[index];
+                let access = if entry.filters.is_empty() {
+                    LookupAccess::All
+                } else {
+                    LookupAccess::Public
+                };
+                // View conditions apply after each import operation; they must
+                // not prevent descent into a container whose child qualifies.
+                let chain = [(scope, entry.filters.clone())];
+                self.collect_import_scope(
+                    &mut excluded,
+                    entry.scope,
+                    access,
+                    entry.recursive,
+                    true,
+                    &chain,
+                    &mut seen,
+                    &mut out,
+                    &mut order,
+                    0,
+                    context,
+                );
+            }
+        }
+        // Do not Namespace::importedMemberships-prune this operation result:
+        // Expose.importedMemberships is a different normative boundary.
+        order
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/feature_type_projection.rs b/crates/sysmlv2-model/src/json/feature_type_projection.rs
new file mode 100644
index 0000000..1f684a4
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/feature_type_projection.rs
@@ -0,0 +1,426 @@
+//! Complete collections for Feature.type, Step.behavior and Expression.function.
+//!
+//! Candidates are not certified final types when graph/required-family evidence
+//! is incomplete. InstantiatedType is deliberately absent from this interface.
+mod adapter;
+mod report;
+pub use report::{FeatureTypeIssue, FeatureTypeReport};
+#[cfg(test)]
+mod readiness_tests;
+#[cfg(test)]
+mod repository_tests;
+
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Comparison {
+    Yes,
+    No,
+    Unknown,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Incomplete {
+    Budget,
+    Depth,
+    InvalidElement,
+    InvalidRelationship,
+    ExternalEndpoint,
+    MissingRequiredFamilies,
+    UnsupportedProjection,
+    AmbiguousSpecialization,
+    InvalidFunctionMultiplicity,
+    InvalidBehaviorKind,
+}
+#[derive(Clone, Debug)]
+pub(super) struct Inputs {
+    /// Complete direct inverse FeatureTyping targets, in stable identity order.
+    pub(super) typings: Vec<usize>,
+    /// Complete typingFeatures: non-cross inverse subsettings plus final owned
+    /// chain, or only the original Feature when conjugated. Own typings still
+    /// count when conjugated; conjugation changes dependencies, not this vector.
+    pub(super) features: Vec<usize>,
+    pub(super) graph_issue: Option<Incomplete>,
+    /// Required implied-family coverage is separate from a complete stored read.
+    pub(super) required_issue: Option<Incomplete>,
+    /// Audited domain obligations. Each must have a positive witness in the
+    /// SAME collected typingFeatures graph, starting from this Feature.
+    pub(super) required_features: Vec<usize>,
+    pub(super) required_typings: Vec<usize>,
+}
+pub(super) trait Evidence {
+    fn inputs(&mut self, feature: usize, steps: &mut usize) -> Result<Inputs, Incomplete>;
+    fn specializes(&mut self, specific: usize, general: usize, steps: &mut usize) -> Comparison;
+    fn is_behavior(&self, element: usize) -> bool;
+    fn is_function(&self, element: usize) -> bool;
+}
+#[derive(Clone, Debug)]
+pub(super) struct Projection {
+    /// Possible surviving types. On incomplete input this is neither a complete
+    /// collection nor a proof that each listed candidate actually survives.
+    pub(super) candidates: Vec<usize>,
+    pub(super) graph_issue: Option<Incomplete>,
+    pub(super) required_issue: Option<Incomplete>,
+    pub(super) steps: usize,
+}
+impl Projection {
+    pub(super) fn complete(&self) -> bool {
+        self.graph_issue.is_none() && self.required_issue.is_none()
+    }
+    pub(super) fn function<E: Evidence>(&self, evidence: &E) -> Result<Option<usize>, Incomplete> {
+        if let Some(issue) = self.graph_issue.or(self.required_issue) {
+            return Err(issue);
+        }
+        let mut function = None;
+        for &ty in &self.candidates {
+            if !evidence.is_behavior(ty) {
+                continue;
+            }
+            // Expression.function redefines behavior. A Behavior that is not a
+            // Function violates the narrowing; filtering it away is unsound.
+            if !evidence.is_function(ty) {
+                return Err(Incomplete::InvalidBehaviorKind);
+            }
+            if function.replace(ty).is_some() {
+                return Err(Incomplete::InvalidFunctionMultiplicity);
+            }
+        }
+        Ok(function)
+    }
+    pub(super) fn behaviors<E: Evidence>(&self, evidence: &E) -> Result<Vec<usize>, Incomplete> {
+        if let Some(issue) = self.graph_issue.or(self.required_issue) {
+            return Err(issue);
+        }
+        Ok(self
+            .candidates
+            .iter()
+            .copied()
+            .filter(|&ty| evidence.is_behavior(ty))
+            .collect())
+    }
+}
+fn charge(steps: &mut usize, amount: usize, maximum: usize) -> bool {
+    *steps = steps.saturating_add(amount);
+    *steps <= maximum
+}
+
+fn required_paths(
+    graph: &HashMap<usize, Inputs>,
+    source: usize,
+    input: &Inputs,
+    steps: &mut usize,
+    maximum: usize,
+) -> Result<(), Incomplete> {
+    if input.required_features.is_empty() && input.required_typings.is_empty() {
+        return Ok(());
+    }
+    if !charge(
+        steps,
+        input
+            .required_features
+            .len()
+            .saturating_add(input.required_typings.len()),
+        maximum,
+    ) {
+        return Err(Incomplete::Budget);
+    }
+    let mut features: HashSet<_> = input.required_features.iter().copied().collect();
+    let mut typings: HashSet<_> = input.required_typings.iter().copied().collect();
+    let mut visited = HashSet::new();
+    let mut todo = vec![source];
+    while let Some(feature) = todo.pop() {
+        if !charge(steps, 1, maximum) {
+            return Err(Incomplete::Budget);
+        }
+        if !visited.insert(feature) {
+            continue;
+        }
+        features.remove(&feature);
+        let row = graph
+            .get(&feature)
+            .ok_or(Incomplete::MissingRequiredFamilies)?;
+        if !charge(
+            steps,
+            row.features.len().saturating_add(row.typings.len()),
+            maximum,
+        ) {
+            return Err(Incomplete::Budget);
+        }
+        for target in &row.typings {
+            typings.remove(target);
+        }
+        if features.is_empty() && typings.is_empty() {
+            return Ok(());
+        }
+        todo.extend(row.features.iter().copied());
+    }
+    Err(Incomplete::MissingRequiredFamilies)
+}
+
+/// Ordered closure reads every reachable Feature once. A cycle is finite OCL
+/// closure, not an automatic failure. No partial/negative projection is cached.
+/// The same caller-owned budget also bounds endpoint and comparison providers.
+pub(super) fn project<E: Evidence>(
+    evidence: &mut E,
+    feature: usize,
+    steps: &mut usize,
+    maximum: usize,
+    depth_limit: usize,
+) -> Projection {
+    let mut graph_issue = None;
+    let mut required_issue = None;
+    let mut inputs = HashMap::new();
+    let mut input_order = Vec::new();
+    let mut seen_features = HashSet::new();
+    let mut seen_types = HashSet::new();
+    let mut types = Vec::new();
+    let mut queue = vec![(feature, 0usize)];
+    let mut at = 0;
+    while at < queue.len() {
+        if !charge(steps, 1, maximum) {
+            graph_issue = Some(Incomplete::Budget);
+            break;
+        }
+        let (current, depth) = queue[at];
+        at += 1;
+        if !seen_features.insert(current) {
+            continue;
+        }
+        if depth > depth_limit {
+            graph_issue.get_or_insert(Incomplete::Depth);
+            continue;
+        }
+        let input = match evidence.inputs(current, steps) {
+            Ok(input) => input,
+            Err(issue) => {
+                graph_issue.get_or_insert(issue);
+                continue;
+            }
+        };
+        if !charge(
+            steps,
+            input.typings.len().saturating_add(input.features.len()),
+            maximum,
+        ) {
+            graph_issue = Some(Incomplete::Budget);
+            break;
+        }
+        if let Some(issue) = input.graph_issue {
+            graph_issue.get_or_insert(issue);
+        }
+        if let Some(issue) = input.required_issue {
+            required_issue.get_or_insert(issue);
+        }
+        for &target in &input.typings {
+            if seen_types.insert(target) {
+                types.push(target);
+            }
+        }
+        queue.extend(
+            input
+                .features
+                .iter()
+                .copied()
+                .map(|target| (target, depth + 1)),
+        );
+        input_order.push(current);
+        inputs.insert(current, input);
+    }
+    // Required paths are certified over the exact graph already used to gather
+    // candidate types. No separate implied graph or recursive provider call can
+    // satisfy a missing obligation. Domain applicability remains the adapter's
+    // responsibility; missing paths never synthesize an edge.
+    if graph_issue.is_none() && required_issue.is_none() {
+        for source in input_order {
+            let input = &inputs[&source];
+            if let Err(issue) = required_paths(&inputs, source, input, steps, maximum) {
+                required_issue = Some(issue);
+                break;
+            }
+        }
+    }
+    let mut candidates = Vec::new();
+    for &general in &types {
+        let mut removed = false;
+        let mut ambiguous = false;
+        for &specific in &types {
+            if specific == general {
+                continue;
+            }
+            if !charge(steps, 1, maximum) {
+                graph_issue = Some(Incomplete::Budget);
+                break;
+            }
+            match evidence.specializes(specific, general, steps) {
+                Comparison::Yes => {
+                    removed = true;
+                    break;
+                }
+                Comparison::Unknown => ambiguous = true,
+                Comparison::No => {}
+            }
+        }
+        if !removed {
+            candidates.push(general);
+            if ambiguous {
+                graph_issue.get_or_insert(Incomplete::AmbiguousSpecialization);
+            }
+        }
+        if *steps > maximum {
+            break;
+        }
+    }
+    // Exhaustion overrides other qualifications, including an apparent positive
+    // from a provider that returned after consuming its final allowed step.
+    if *steps > maximum {
+        graph_issue = Some(Incomplete::Budget);
+    }
+    Projection {
+        candidates,
+        graph_issue,
+        required_issue,
+        steps: *steps,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+    #[derive(Default)]
+    struct Graph {
+        inputs: HashMap<usize, Inputs>,
+        pairs: HashMap<(usize, usize), Comparison>,
+        functions: HashSet<usize>,
+        behaviors: HashSet<usize>,
+    }
+    impl Evidence for Graph {
+        fn inputs(&mut self, f: usize, steps: &mut usize) -> Result<Inputs, Incomplete> {
+            *steps += 1;
+            self.inputs
+                .get(&f)
+                .cloned()
+                .ok_or(Incomplete::InvalidElement)
+        }
+        fn specializes(&mut self, s: usize, g: usize, steps: &mut usize) -> Comparison {
+            *steps += 1;
+            self.pairs.get(&(s, g)).copied().unwrap_or(Comparison::No)
+        }
+        fn is_behavior(&self, e: usize) -> bool {
+            self.behaviors.contains(&e) || self.functions.contains(&e)
+        }
+        fn is_function(&self, e: usize) -> bool {
+            self.functions.contains(&e)
+        }
+    }
+    fn input(typings: Vec<usize>, features: Vec<usize>) -> Inputs {
+        Inputs {
+            typings,
+            features,
+            graph_issue: None,
+            required_issue: None,
+            required_features: Vec::new(),
+            required_typings: Vec::new(),
+        }
+    }
+    fn run(g: &mut Graph) -> Projection {
+        project(g, 0, &mut 0, 1000, 16)
+    }
+    #[test]
+    fn closure_keeps_identity_order_handles_cycles_and_removes_only_proven_redundancy() {
+        let mut g = Graph::default();
+        g.inputs.insert(0, input(vec![5], vec![1, 2]));
+        g.inputs.insert(1, input(vec![6], vec![0]));
+        g.inputs.insert(2, input(vec![7], vec![]));
+        g.functions.insert(6);
+        g.pairs.insert((6, 5), Comparison::Yes);
+        g.pairs.insert((6, 7), Comparison::Yes);
+        let p = run(&mut g);
+        assert!(p.complete());
+        assert_eq!(p.candidates, vec![6]);
+        assert_eq!(p.function(&g), Ok(Some(6)));
+    }
+    #[test]
+    fn unknown_comparison_cannot_choose_an_arbitrary_function() {
+        let mut g = Graph::default();
+        g.inputs.insert(0, input(vec![5, 6], vec![]));
+        g.functions.extend([5, 6]);
+        g.pairs.insert((5, 6), Comparison::Unknown);
+        assert_eq!(
+            run(&mut g).function(&g),
+            Err(Incomplete::AmbiguousSpecialization)
+        );
+        g.pairs.clear();
+        assert_eq!(
+            run(&mut g).function(&g),
+            Err(Incomplete::InvalidFunctionMultiplicity)
+        );
+    }
+    #[test]
+    fn required_coverage_and_missing_dependency_prevent_empty_or_unique_success() {
+        let mut g = Graph::default();
+        let mut i = input(vec![5], vec![]);
+        i.required_issue = Some(Incomplete::MissingRequiredFamilies);
+        g.inputs.insert(0, i);
+        g.functions.insert(5);
+        assert_eq!(
+            run(&mut g).function(&g),
+            Err(Incomplete::MissingRequiredFamilies)
+        );
+        g.inputs.insert(0, input(vec![], vec![1]));
+        assert_eq!(run(&mut g).function(&g), Err(Incomplete::InvalidElement));
+    }
+    #[test]
+    fn expression_narrowing_does_not_filter_away_other_behaviors() {
+        let mut g = Graph::default();
+        g.inputs.insert(0, input(vec![5], vec![]));
+        g.behaviors.insert(5);
+        let p = run(&mut g);
+        assert_eq!(p.behaviors(&g), Ok(vec![5]));
+        assert_eq!(p.function(&g), Err(Incomplete::InvalidBehaviorKind));
+    }
+    #[test]
+    fn bounded_failure_does_not_poison_fresh_retry() {
+        let mut g = Graph::default();
+        g.inputs.insert(0, input(vec![5], vec![]));
+        g.functions.insert(5);
+        let p = project(&mut g, 0, &mut 10, 10, 16);
+        assert_eq!(p.function(&g), Err(Incomplete::Budget));
+        assert_eq!(run(&mut g).function(&g), Ok(Some(5)));
+    }
+    #[test]
+    fn required_paths_are_source_local_and_cannot_use_a_sibling_witness() {
+        let mut g = Graph::default();
+        g.inputs.insert(0, input(vec![5], vec![1, 2]));
+        let mut first = input(vec![], vec![]);
+        first.required_features.push(2);
+        g.inputs.insert(1, first);
+        g.inputs.insert(2, input(vec![], vec![]));
+        g.functions.insert(5);
+        assert_eq!(
+            run(&mut g).function(&g),
+            Err(Incomplete::MissingRequiredFamilies)
+        );
+        g.inputs.get_mut(&1).unwrap().features.push(2);
+        assert_eq!(run(&mut g).function(&g), Ok(Some(5)));
+    }
+    #[test]
+    fn required_typing_witness_uses_complete_shared_closure_and_retries() {
+        let mut g = Graph::default();
+        let mut root = input(vec![5], vec![1]);
+        root.required_features = vec![0, 1];
+        root.required_typings = vec![6];
+        g.inputs.insert(0, root);
+        g.inputs.insert(1, input(vec![], vec![0]));
+        g.functions.insert(5);
+        assert_eq!(
+            run(&mut g).function(&g),
+            Err(Incomplete::MissingRequiredFamilies)
+        );
+        g.inputs.get_mut(&1).unwrap().typings.push(6);
+        g.pairs.insert((5, 6), Comparison::Yes);
+        assert_eq!(run(&mut g).function(&g), Ok(Some(5)));
+        let failed = project(&mut g, 0, &mut 0, 8, 16);
+        assert_eq!(failed.function(&g), Err(Incomplete::Budget));
+        assert_eq!(run(&mut g).function(&g), Ok(Some(5)));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/feature_type_projection/adapter.rs b/crates/sysmlv2-model/src/json/feature_type_projection/adapter.rs
new file mode 100644
index 0000000..1945a63
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/feature_type_projection/adapter.rs
@@ -0,0 +1,534 @@
+//! Repository adapter with a bounded structural-context readiness
+//! certificate. Invocation and owned-result families remain explicitly outside it.
+use super::{Comparison, Evidence, Incomplete, Inputs, Projection};
+use crate::json::{
+    Builder,
+    provider_completeness::ProviderCompleteness,
+    semantic_ownership,
+    structural_index::{StoredStructure, StoredTyping},
+    type_relations::{CompositionOwner, RelationFact, TypeRelations, endpoint_with_carrier},
+};
+use crate::metaclass::conforms;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+pub(super) struct RepositoryTyping<'a> {
+    builder: &'a mut Builder,
+    contextual_active: HashSet<usize>,
+    contextual_owners: HashMap<usize, CompositionOwner>,
+    structure: Arc<StoredStructure>,
+    typing: Arc<StoredTyping>,
+    ownership: Option<Arc<semantic_ownership::SemanticOwnership>>,
+    metadata_generation: Option<Arc<()>>,
+    publication: crate::json::publication::Revision,
+    relations: TypeRelations,
+    providers: ProviderCompleteness,
+    retained: Arc<crate::json::implied::RetainedTypings>,
+    retained_plan: Option<Arc<crate::json::implied::SupportedImpliedSpecializations>>,
+}
+fn charge(steps: &mut usize, amount: usize) -> Result<(), Incomplete> {
+    *steps = steps.saturating_add(amount);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(Incomplete::Budget)
+    } else {
+        Ok(())
+    }
+}
+impl<'a> RepositoryTyping<'a> {
+    pub(super) fn new(builder: &'a mut Builder, steps: &mut usize) -> Result<Self, Incomplete> {
+        if builder.positional_planning {
+            return Err(Incomplete::UnsupportedProjection);
+        }
+        let retained = builder.retained_typing_edges(steps).ok_or({
+            if *steps > crate::eval::MAX_STEPS {
+                Incomplete::Budget
+            } else {
+                Incomplete::UnsupportedProjection
+            }
+        })?;
+        let structure = StoredStructure::for_query(builder, steps).ok_or({
+            if *steps > crate::eval::MAX_STEPS {
+                Incomplete::Budget
+            } else {
+                Incomplete::InvalidRelationship
+            }
+        })?;
+        if !structure.ids_unique {
+            return Err(Incomplete::InvalidElement);
+        }
+        let typing = structure.typing(builder, steps).ok_or({
+            if *steps > crate::eval::MAX_STEPS {
+                Incomplete::Budget
+            } else {
+                Incomplete::InvalidRelationship
+            }
+        })?;
+        let retained_plan = builder.supported_implied.clone();
+        let ownership = builder.semantic_ownership.clone();
+        let metadata_generation = builder.metadata_association_generation.clone();
+        let publication = builder.publication.revision();
+        Ok(Self {
+            contextual_active: HashSet::new(),
+            contextual_owners: HashMap::new(),
+            publication,
+            builder,
+            ownership,
+            metadata_generation,
+            structure,
+            typing,
+            retained,
+            retained_plan,
+            relations: TypeRelations::default(),
+            providers: ProviderCompleteness::default(),
+        })
+    }
+    pub(super) fn project(&mut self, feature: usize, steps: &mut usize) -> Projection {
+        if self.contextual_active.len() > crate::json::MAX_RESOLUTION_DEPTH
+            || !self.contextual_active.insert(feature)
+        {
+            return Projection {
+                candidates: Vec::new(),
+                graph_issue: Some(Incomplete::UnsupportedProjection),
+                required_issue: None,
+                steps: *steps,
+            };
+        }
+        let result = super::project(
+            self,
+            feature,
+            steps,
+            crate::eval::MAX_STEPS,
+            crate::json::MAX_RESOLUTION_DEPTH,
+        );
+        self.contextual_active.remove(&feature);
+        result
+    }
+    fn current(&self) -> bool {
+        let ownership_current = match (&self.ownership, &self.builder.semantic_ownership) {
+            (None, None) => true,
+            (Some(stored), Some(current)) => Arc::ptr_eq(stored, current),
+            _ => false,
+        };
+        let metadata_current = match (
+            &self.metadata_generation,
+            &self.builder.metadata_association_generation,
+        ) {
+            (None, None) => true,
+            (Some(stored), Some(current)) => Arc::ptr_eq(stored, current),
+            _ => false,
+        };
+        let retained_current = match (&self.retained_plan, &self.builder.supported_implied) {
+            (None, None) => true,
+            (Some(old), Some(current)) => Arc::ptr_eq(old, current),
+            _ => false,
+        };
+        self.structure.is_current(self.builder)
+            && ownership_current
+            && metadata_current
+            && retained_current
+            && self
+                .publication
+                .same_as(&self.builder.publication.revision())
+    }
+    fn carrier(&self, relationship: usize, steps: &mut usize) -> Result<Option<usize>, Incomplete> {
+        let result = semantic_ownership::checked_relationship_carrier(
+            self.builder,
+            &self.structure,
+            relationship,
+            steps,
+        );
+        result.ok_or(Incomplete::InvalidRelationship)
+    }
+    fn endpoint(
+        &mut self,
+        source: usize,
+        relation: usize,
+        kind: &str,
+        steps: &mut usize,
+    ) -> Result<usize, Incomplete> {
+        if !self.builder.static_chain_row_current(relation) {
+            return Err(Incomplete::UnsupportedProjection);
+        }
+        let carrier = self.carrier(relation, steps)?;
+        endpoint_with_carrier(
+            self.builder,
+            source,
+            carrier,
+            relation,
+            &[
+                "specific",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ],
+            &[
+                "general",
+                "type",
+                "subsettedFeature",
+                "redefinedFeature",
+                "referencedFeature",
+                "crossedFeature",
+            ],
+            kind,
+            steps,
+        )
+        .ok_or({
+            if *steps > crate::eval::MAX_STEPS {
+                Incomplete::Budget
+            } else {
+                Incomplete::InvalidRelationship
+            }
+        })
+    }
+    fn owned_relationships(
+        &self,
+        feature: usize,
+        steps: &mut usize,
+    ) -> Result<Vec<usize>, Incomplete> {
+        let rows = semantic_ownership::owned_relationships(self.builder, feature)
+            .ok_or(Incomplete::InvalidRelationship)?;
+        charge(steps, rows.len())?;
+        let relationships = rows.iter().collect::<Vec<_>>();
+        let mut seen = HashSet::new();
+        for &relationship in &relationships {
+            if !seen.insert(relationship) || self.carrier(relationship, steps)? != Some(feature) {
+                return Err(Incomplete::InvalidRelationship);
+            }
+        }
+        Ok(relationships)
+    }
+    /// An intentionally narrow but complete applicability audit for obligations
+    /// that can change this Feature's typing closure. Every required path is
+    /// checked later against the collected graph; this never adds an edge.
+    fn requirements(
+        &mut self,
+        feature: usize,
+        owned: &[usize],
+        typings: &[usize],
+        original: Option<usize>,
+        steps: &mut usize,
+    ) -> Result<(Vec<usize>, Vec<usize>), Incomplete> {
+        let mut owner_types = None;
+        let element = &self.builder.elements[feature];
+        if conforms(element.ty, "OccurrenceUsage")
+            && element.props.get("isComposite").and_then(|v| v.as_bool()) == Some(true)
+        {
+            let owner = self
+                .relations
+                .owning_type(self.builder, feature, steps)
+                .ok_or(Incomplete::InvalidRelationship)?;
+            if let Some(owner) =
+                owner.filter(|&owner| conforms(self.builder.elements[owner].ty, "Feature"))
+            {
+                charge(steps, 1)?;
+                let certificate = if let Some(certificate) = self.contextual_owners.get(&owner) {
+                    *certificate
+                } else {
+                    // The complete owner projection uses the same stored graph,
+                    // canonical obligations and budget. Recursion through owner
+                    // typing dependencies is bounded and never cached partially.
+                    let projection = self.project(owner, steps);
+                    if let Some(issue) = projection.graph_issue.or(projection.required_issue) {
+                        return Err(issue);
+                    }
+                    charge(steps, projection.candidates.len())?;
+                    let certificate = CompositionOwner {
+                        object: projection
+                            .candidates
+                            .iter()
+                            .any(|&ty| conforms(self.builder.elements[ty].ty, "Structure")),
+                        occurrence: projection
+                            .candidates
+                            .iter()
+                            .any(|&ty| conforms(self.builder.elements[ty].ty, "Class")),
+                    };
+                    self.contextual_owners.insert(owner, certificate);
+                    certificate
+                };
+                owner_types = Some(certificate);
+            }
+        }
+        self.relations
+            .feature_requirements(
+                self.builder,
+                feature,
+                owned,
+                typings,
+                original,
+                owner_types,
+                steps,
+            )
+            .map_err(|error| match error {
+                super::super::type_relations::FeatureRequirementsFailure::Unsupported => {
+                    Incomplete::MissingRequiredFamilies
+                }
+                super::super::type_relations::FeatureRequirementsFailure::InvalidRelationship => {
+                    Incomplete::InvalidRelationship
+                }
+            })
+    }
+}
+impl Evidence for RepositoryTyping<'_> {
+    fn inputs(&mut self, feature: usize, steps: &mut usize) -> Result<Inputs, Incomplete> {
+        charge(steps, 1)?;
+        if !self.current()
+            || (!self.builder.dynamic_evidence_current(feature)
+                || !self.builder.result_redefinition_evidence_current(feature))
+        {
+            return Err(Incomplete::UnsupportedProjection);
+        }
+        if !conforms(
+            self.builder
+                .elements
+                .get(feature)
+                .ok_or(Incomplete::InvalidElement)?
+                .ty,
+            "Feature",
+        ) {
+            return Err(Incomplete::InvalidElement);
+        }
+        let owned = self.owned_relationships(feature, steps)?;
+        // Existing checked conjugation helper validates owned cardinality,
+        // identity and scalar/generic aliases. No private normalization graph.
+        let original = self
+            .relations
+            .owned_conjugation(self.builder, feature, steps)
+            .ok_or(Incomplete::InvalidRelationship)?;
+        let inverse = self
+            .typing
+            .relationships
+            .get(&feature)
+            .map_or(&[][..], Vec::as_slice);
+        charge(steps, inverse.len())?;
+        let inverse = inverse.to_vec();
+        let mut typings = Vec::new();
+        let mut features = Vec::new();
+        let mut graph_issue = self
+            .typing
+            .sources_incomplete
+            .then_some(Incomplete::InvalidRelationship);
+        for relationship in inverse {
+            let kind = self.builder.elements[relationship].ty;
+            if conforms(kind, "FeatureTyping") {
+                typings.push(self.endpoint(feature, relationship, "Type", steps)?);
+            } else if original.is_none()
+                && conforms(kind, "Subsetting")
+                && !conforms(kind, "CrossSubsetting")
+            {
+                features.push(self.endpoint(feature, relationship, "Feature", steps)?);
+            }
+        }
+        if let Some(original) = original {
+            if conforms(self.builder.elements[original].ty, "Feature") {
+                features.push(original);
+            }
+        } else {
+            let mut last = None;
+            for &relationship in &owned {
+                if !conforms(self.builder.elements[relationship].ty, "FeatureChaining") {
+                    continue;
+                }
+                let carrier = self.carrier(relationship, steps)?;
+                // Every link is validated, not just the last surviving target.
+                last = Some(
+                    endpoint_with_carrier(
+                        self.builder,
+                        feature,
+                        carrier,
+                        relationship,
+                        &["featureChained"],
+                        &["chainingFeature"],
+                        "Feature",
+                        steps,
+                    )
+                    .ok_or(Incomplete::InvalidRelationship)?,
+                );
+            }
+            if let Some(last) = last {
+                features.push(last);
+            }
+        }
+        let retained = self.retained.get(&feature).map_or(&[][..], Vec::as_slice);
+        charge(steps, retained.len())?;
+        for &(kind, id) in retained {
+            if original.is_some() && !conforms(kind, "FeatureTyping") {
+                continue;
+            }
+            if conforms(kind, "CrossSubsetting") {
+                continue;
+            }
+            let Some(target) = self.builder.element_index_of_uuid(id) else {
+                graph_issue.get_or_insert(Incomplete::ExternalEndpoint);
+                continue;
+            };
+            let expected = if conforms(kind, "FeatureTyping") {
+                "Type"
+            } else {
+                "Feature"
+            };
+            if !conforms(self.builder.elements[target].ty, expected) {
+                graph_issue.get_or_insert(Incomplete::InvalidElement);
+                continue;
+            }
+            if expected == "Type" {
+                typings.push(target);
+            } else {
+                features.push(target);
+            }
+        }
+        if original.is_none()
+            && (self.builder.is_parameter(feature)
+                || self.builder.elements[feature]
+                    .props
+                    .get("isEnd")
+                    .and_then(|value| value.as_bool())
+                    == Some(true))
+        {
+            // Reuse stabilized positional evidence. This path never starts an
+            // unbudgeted planning pass or turns an absent table into empty.
+            let ready = self
+                .builder
+                .elem_scope
+                .get(&feature)
+                .copied()
+                .is_some_and(|scope| self.providers.scope(self.builder, scope, steps));
+            let owner = self
+                .relations
+                .owning_type(self.builder, feature, steps)
+                .ok_or(Incomplete::InvalidRelationship)?;
+            if !ready
+                || self
+                    .builder
+                    .effective_positional_redefinitions()
+                    .is_none_or(|plan| owner.is_some_and(|owner| plan.incomplete.contains(&owner)))
+            {
+                graph_issue.get_or_insert(Incomplete::UnsupportedProjection);
+            } else {
+                let targets = self
+                    .builder
+                    .effective_positional_redefinitions()
+                    .unwrap()
+                    .targets
+                    .get(&feature)
+                    .map_or(&[][..], Vec::as_slice);
+                charge(steps, targets.len())?;
+                for &target in targets {
+                    if !self
+                        .builder
+                        .elements
+                        .get(target)
+                        .is_some_and(|e| conforms(e.ty, "Feature"))
+                    {
+                        graph_issue.get_or_insert(Incomplete::InvalidElement);
+                    } else {
+                        features.push(target);
+                    }
+                }
+            }
+        }
+        let requirements = self.requirements(feature, &owned, &typings, original, steps);
+        let (required_features, required_typings, required_issue) = match requirements {
+            Ok((features, typings)) => (features, typings, None),
+            Err(Incomplete::Budget) => return Err(Incomplete::Budget),
+            Err(issue) => (Vec::new(), Vec::new(), Some(issue)),
+        };
+        charge(steps, 0)?;
+        Ok(Inputs {
+            typings,
+            features,
+            graph_issue,
+            required_issue,
+            required_features,
+            required_typings,
+        })
+    }
+    fn specializes(&mut self, specific: usize, general: usize, steps: &mut usize) -> Comparison {
+        if !self.current() {
+            return Comparison::Unknown;
+        }
+        match self
+            .relations
+            .specializes(self.builder, specific, general, steps)
+        {
+            RelationFact::Yes => Comparison::Yes,
+            RelationFact::No => Comparison::No,
+            RelationFact::Unknown => Comparison::Unknown,
+        }
+    }
+    fn is_behavior(&self, element: usize) -> bool {
+        self.builder
+            .elements
+            .get(element)
+            .is_some_and(|e| conforms(e.ty, "Behavior"))
+    }
+    fn is_function(&self, element: usize) -> bool {
+        self.builder
+            .elements
+            .get(element)
+            .is_some_and(|e| conforms(e.ty, "Function"))
+    }
+}
+#[cfg(test)]
+mod readiness_lifecycle_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn metadata_snapshot_change_refuses_old_proof_and_repair_retries_fresh() {
+        let library = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_library_source("bases.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(model.add_source("source.kerml","function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;").diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&model);
+        let feature = r.resolve_qualified("e").unwrap().0;
+        let function = r.resolve_qualified("F").unwrap().0;
+        let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            proof.project(feature, &mut 0).function(&proof),
+            Ok(Some(function))
+        );
+        // Reconstructing an equivalent retained table still revokes the old
+        // snapshot: unchanged rows/Boolean readiness are not its authority.
+        proof.builder.supported_implied = None;
+        proof.builder.retained_typing_edges(&mut 0).unwrap();
+        assert!(!proof.current());
+        assert!(proof.project(feature, &mut 0).function(&proof).is_err());
+        drop(proof);
+        let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            proof.project(feature, &mut 0).function(&proof),
+            Ok(Some(function))
+        );
+        proof.builder.metadata_associations_incomplete = true;
+        proof.builder.metadata_association_generation = Some(Arc::new(()));
+        assert!(!proof.current());
+        assert!(proof.project(feature, &mut 0).function(&proof).is_err());
+        drop(proof);
+        let mut unproved = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        let incomplete = unproved.project(feature, &mut 0);
+        assert_eq!(
+            incomplete.required_issue,
+            Some(Incomplete::MissingRequiredFamilies)
+        );
+        assert!(
+            incomplete.function(&unproved).is_err(),
+            "metadata also qualifies specialization negatives"
+        );
+        unproved.builder.metadata_associations_incomplete = false;
+        unproved.builder.metadata_association_generation = Some(Arc::new(()));
+        drop(unproved);
+        let mut repaired = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            repaired.project(feature, &mut 0).function(&repaired),
+            Ok(Some(function))
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/feature_type_projection/readiness_tests.rs b/crates/sysmlv2-model/src/json/feature_type_projection/readiness_tests.rs
new file mode 100644
index 0000000..3e32488
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/feature_type_projection/readiness_tests.rs
@@ -0,0 +1,319 @@
+//! Repository tests for the bounded namespace-owned kernel typing certificate.
+use super::{adapter::RepositoryTyping, *};
+use crate::{json::ResolvedModel, model::Model};
+const LIBRARY: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn fixture(user: &str) -> ResolvedModel {
+    let mut m = Model::new();
+    assert!(
+        m.add_library_source("typing-bases.kerml", LIBRARY)
+            .diagnostics
+            .is_empty()
+    );
+    assert!(
+        m.add_source("typing-ready.kerml", user)
+            .diagnostics
+            .is_empty()
+    );
+    ResolvedModel::build(&m)
+}
+fn replay_fixtures(user: &str) -> Vec<ResolvedModel> {
+    use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+    use std::sync::Arc;
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("typing-bases.kerml", LIBRARY)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(79).unwrap(), 79).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("typing-bases.kerml", LIBRARY);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(
+                model
+                    .add_source("typing-ready.kerml", user)
+                    .diagnostics
+                    .is_empty()
+            );
+            ResolvedModel::build(&model)
+        })
+        .collect()
+}
+#[test]
+fn exact_expression_function_is_reduced_from_complete_shared_closure() {
+    let mut expected = None;
+    for mut r in replay_fixtures(
+        "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+    ) {
+        let expression = r.resolve_qualified("e").unwrap().0;
+        let function = r.resolve_qualified("F").unwrap().0;
+        let id = r.b.elements[function].id;
+        if let Some(expected) = expected {
+            assert_eq!(id, expected);
+        } else {
+            expected = Some(id);
+        }
+        let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        let result = proof.project(expression, &mut 0);
+        assert!(result.complete(), "{result:?}");
+        assert_eq!(result.candidates, [function]);
+        assert_eq!(result.function(&proof), Ok(Some(function)));
+        assert_eq!(
+            proof.project(expression, &mut 0).function(&proof),
+            Ok(Some(function))
+        );
+        drop(proof);
+        assert_eq!(
+            before,
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>()
+        );
+    }
+}
+#[test]
+fn feature_subsetting_closure_and_step_behavior_use_the_same_complete_inputs() {
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation; feature base:F subsets Performances::evaluations; step s subsets base;",
+    );
+    let step = r.resolve_qualified("s").unwrap().0;
+    let function = r.resolve_qualified("F").unwrap().0;
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    let result = proof.project(step, &mut 0);
+    assert_eq!(result.behaviors(&proof), Ok(vec![function]));
+}
+#[test]
+fn generic_expression_base_establishes_the_required_source_path() {
+    let mut r = fixture("function F specializes Performances::Evaluation; expr e:F;");
+    let expression = r.resolve_qualified("e").unwrap().0;
+    let function = r.resolve_qualified("F").unwrap().0;
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    let result = proof.project(expression, &mut 0);
+    assert_eq!(result.function(&proof), Ok(Some(function)));
+}
+#[test]
+fn existing_required_name_without_a_source_path_is_not_completeness() {
+    // The source now receives its required evaluations base automatically.
+    // Keep the negative control by breaking an actual canonical ancestor edge:
+    // Evaluation still exists, but no longer specializes Performance.
+    let library = LIBRARY.replace(
+        "function Evaluation specializes Performance;",
+        "function Evaluation;",
+    );
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_library_source("typing-broken-base.kerml", &library)
+            .diagnostics
+            .is_empty()
+    );
+    assert!(
+        model
+            .add_source(
+                "typing-ready.kerml",
+                "function F specializes Performances::Evaluation; expr e:F;"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&model);
+    let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+    let performance = r.resolve_qualified("Performances::Performance").unwrap().0;
+    assert_eq!(
+        crate::json::type_relations::TypeRelations::default().specializes(
+            &mut r.b,
+            evaluation,
+            performance,
+            &mut 0
+        ),
+        crate::json::type_relations::RelationFact::Unknown
+    );
+    let expression = r.resolve_qualified("e").unwrap().0;
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    let result = proof.project(expression, &mut 0);
+    assert_eq!(
+        result.function(&proof),
+        Err(Incomplete::AmbiguousSpecialization)
+    );
+}
+
+#[test]
+fn metadata_valuation_owned_context_and_invocation_remain_outside_bounded_domain() {
+    for user in [
+        "function F specializes Performances::Evaluation; metaclass Mark; expr e:F subsets Performances::evaluations; @Mark about e;",
+        "function F specializes Performances::Evaluation; feature e:F subsets Performances::evaluations=1;",
+        "function F specializes Performances::Evaluation; class C {expr e:F subsets Performances::evaluations;}",
+    ] {
+        let mut r = fixture(user);
+        let feature = r
+            .resolve_qualified("e")
+            .or_else(|| r.resolve_qualified("C::e"))
+            .unwrap()
+            .0;
+        let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        assert!(proof.project(feature, &mut 0).function(&proof).is_err());
+    }
+}
+#[test]
+fn invocation_waits_for_accepted_dynamic_typing_lifecycle() {
+    let mut r = fixture("function F specializes Performances::Evaluation; feature call=F();");
+    let invocation =
+        r.b.elements
+            .iter()
+            .position(|e| e.ty == "InvocationExpression")
+            .unwrap();
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    assert_eq!(
+        proof.project(invocation, &mut 0).function(&proof),
+        Err(Incomplete::MissingRequiredFamilies)
+    );
+}
+#[test]
+fn actual_standard_library_supports_explicit_function_identity() {
+    let library = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("../../spec-refs/SysML-v2-Release/sysml.library");
+    if !library.exists() {
+        eprintln!("skipping: standard library not present");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).unwrap();
+    assert!(model.add_source("typing-actual.kerml","function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;").diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&model);
+    let feature = r.resolve_qualified("e").unwrap().0;
+    let function = r.resolve_qualified("F").unwrap().0;
+    // Exercise actual library identities without legacy resolver/positional warming.
+    r.b.positional_redefinitions = None;
+    r.b.base_cache.fill(None);
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    let projection = proof.project(feature, &mut 0);
+    assert_eq!(
+        projection.function(&proof),
+        Ok(Some(function)),
+        "{projection:?}"
+    );
+}
+
+#[test]
+fn exhausted_valid_report_always_reports_work_limit_with_warm_indexes() {
+    use crate::json::{ElementRef, FeatureTypeIssue};
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+    );
+    let e = r.resolve_qualified("e").unwrap();
+    assert!(r.feature_type_report(e).types.is_ok());
+    // Exercise cutoffs inside carrier, conjugation, owner and provider proofs,
+    // after index startup is already paid. Every exhaustion has one public cause.
+    for remaining in 0..180 {
+        let report =
+            r.feature_type_report_with_budget(ElementRef(e.0), crate::eval::MAX_STEPS - remaining);
+        if report.steps > crate::eval::MAX_STEPS {
+            assert_eq!(
+                report.types,
+                Err(FeatureTypeIssue::WorkLimit),
+                "remaining={remaining}"
+            );
+            assert_eq!(
+                report.function,
+                Err(FeatureTypeIssue::WorkLimit),
+                "remaining={remaining}"
+            );
+        }
+    }
+}
+
+#[test]
+fn cold_report_budget_never_publishes_partial_positional_evidence() {
+    use crate::json::FeatureTypeIssue;
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+    );
+    let e = r.resolve_qualified("e").unwrap();
+    // Warm only the immutable row and typing indexes, not positional planning.
+    drop(RepositoryTyping::new(&mut r.b, &mut 0).unwrap());
+    r.b.positional_redefinitions = None;
+    let report = r.feature_type_report_with_budget(e, crate::eval::MAX_STEPS - 100);
+    assert_eq!(report.types, Err(FeatureTypeIssue::WorkLimit));
+    assert!(r.b.positional_redefinitions.is_none());
+    assert!(!r.b.positional_planning);
+    let report = r.feature_type_report(e);
+    assert!(report.types.is_ok(), "{report:?}");
+    assert!(r.b.positional_redefinitions.is_some());
+}
+
+#[test]
+fn external_name_configuration_keeps_one_retained_authority_during_cold_report() {
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+    );
+    let e = r.resolve_qualified("e").unwrap();
+    let function = r.resolve_qualified("F").unwrap();
+    r.set_library_names(&std::collections::HashMap::from([(
+        uuid::Uuid::new_v4().to_string(),
+        vec!["Unrelated".into(), "external".into()],
+    )]));
+    let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+    assert_eq!(
+        proof.project(e.0, &mut 0).function(&proof),
+        Ok(Some(function.0))
+    );
+    assert_eq!(
+        proof.project(e.0, &mut 0).function(&proof),
+        Ok(Some(function.0))
+    );
+}
+
+#[test]
+fn accepted_dynamic_reports_reuse_one_authority_without_cold_static_preparation() {
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation {return result;} expr e:F; feature call=F();",
+    );
+    let expression = r.resolve_qualified("e").unwrap().0;
+    let function = r.resolve_qualified("F").unwrap().0;
+    let invocation = r
+        .user_elements()
+        .find(|&e| r.element_type(e) == "InvocationExpression")
+        .unwrap();
+    r.implied_relationships(invocation);
+    assert!(r.b.effective_dynamic_plan().is_some());
+    r.b.supported_implied = None;
+    r.b.positional_redefinitions = None;
+    r.b.base_cache.fill(None);
+    let accepted = r.b.dynamic_graph.clone().unwrap();
+    let count = r.b.elements.len();
+    for _ in 0..2 {
+        let mut proof = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        let report = proof.project(expression, &mut 0);
+        assert!(report.complete(), "{report:?}");
+        assert_eq!(report.function(&proof), Ok(Some(function)));
+        assert_eq!(
+            proof.project(expression, &mut 0).function(&proof),
+            Ok(Some(function))
+        );
+        drop(proof);
+        assert!(r.b.supported_implied.is_none());
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(std::sync::Arc::ptr_eq(
+            &accepted,
+            r.b.dynamic_graph.as_ref().unwrap()
+        ));
+        assert_eq!(r.b.elements.len(), count);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/feature_type_projection/report.rs b/crates/sysmlv2-model/src/json/feature_type_projection/report.rs
new file mode 100644
index 0000000..7f3ddbe
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/feature_type_projection/report.rs
@@ -0,0 +1,196 @@
+//! Qualified public views of the one checked Feature.type projection.
+use super::{Incomplete, adapter::RepositoryTyping};
+use crate::{
+    json::{ElementRef, ResolvedModel},
+    metaclass::conforms,
+};
+
+/// Why a checked type-family property is unavailable. An error is not an empty
+/// collection or proof of absence. This set may grow as coverage is expanded.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum FeatureTypeIssue {
+    WorkLimit,
+    DepthLimit,
+    /// Missing element or a receiver that is not a Feature.
+    InvalidElement,
+    InvalidRelationship,
+    ExternalEndpoint,
+    MissingRequiredFamilies,
+    UnsupportedProjection,
+    AmbiguousSpecialization,
+    InvalidFunctionMultiplicity,
+    InvalidBehaviorKind,
+    /// The receiver does not conform to the property's declaring metaclass.
+    NotApplicable,
+}
+impl From<Incomplete> for FeatureTypeIssue {
+    fn from(issue: Incomplete) -> Self {
+        match issue {
+            Incomplete::Budget => Self::WorkLimit,
+            Incomplete::Depth => Self::DepthLimit,
+            Incomplete::InvalidElement => Self::InvalidElement,
+            Incomplete::InvalidRelationship => Self::InvalidRelationship,
+            Incomplete::ExternalEndpoint => Self::ExternalEndpoint,
+            Incomplete::MissingRequiredFamilies => Self::MissingRequiredFamilies,
+            Incomplete::UnsupportedProjection => Self::UnsupportedProjection,
+            Incomplete::AmbiguousSpecialization => Self::AmbiguousSpecialization,
+            Incomplete::InvalidFunctionMultiplicity => Self::InvalidFunctionMultiplicity,
+            Incomplete::InvalidBehaviorKind => Self::InvalidBehaviorKind,
+        }
+    }
+}
+
+/// Complete property values or explicit qualifications from one shared query.
+/// Intermediate candidates are intentionally not exposed as a property value.
+/// This report neither classifies model-level evaluability nor executes a call.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct FeatureTypeReport {
+    /// Feature::type. Only Ok certifies the complete reduced collection.
+    pub types: Result<Vec<ElementRef>, FeatureTypeIssue>,
+    /// Step::behavior; NotApplicable on a Feature that is not a Step.
+    pub behavior: Result<Vec<ElementRef>, FeatureTypeIssue>,
+    /// Expression::function; NotApplicable outside Expression. Ok(None) proves
+    /// no Function in the complete type collection; Err never means absence.
+    pub function: Result<Option<ElementRef>, FeatureTypeIssue>,
+    /// Bounded logical work, including cold projection construction when needed.
+    pub steps: usize,
+}
+impl FeatureTypeReport {
+    fn unavailable(issue: FeatureTypeIssue, step: bool, expression: bool, steps: usize) -> Self {
+        Self {
+            types: Err(issue),
+            behavior: Err(if step {
+                issue
+            } else {
+                FeatureTypeIssue::NotApplicable
+            }),
+            function: Err(if expression {
+                issue
+            } else {
+                FeatureTypeIssue::NotApplicable
+            }),
+            steps,
+        }
+    }
+}
+impl ResolvedModel {
+    /// Read qualified Feature::type, Step::behavior and Expression::function
+    /// from one shared identity-based projection. Legacy derived reads retain
+    /// their documented compatibility behavior.
+    ///
+    /// Supported domains include namespace-owned Feature, Step and Expression
+    /// and ordinary structural Usage/Feature members, with witnessed canonical
+    /// paths including required composition bases. Nested composite occurrence,
+    /// item and part usages require a complete projection of their ordinary
+    /// Feature or Usage owner. Other contextual families, Invocation, Constructor
+    /// and unsupported required families remain Err;
+    /// an instantiated-type membership alone never proves function. Source,
+    /// library and materialized identities use the same checked providers.
+    /// This query does not materialize semantic rows or execute expressions.
+    pub fn feature_type_report(&mut self, feature: ElementRef) -> FeatureTypeReport {
+        self.feature_type_report_with_budget(feature, 0)
+    }
+
+    /// The caller's row-local budget survives cache invalidation/recomputation.
+    pub(in crate::json) fn feature_type_report_with_budget(
+        &mut self,
+        feature: ElementRef,
+        initial_steps: usize,
+    ) -> FeatureTypeReport {
+        let Some(element) = self.b.elements.get(feature.0) else {
+            return FeatureTypeReport::unavailable(
+                FeatureTypeIssue::InvalidElement,
+                false,
+                false,
+                initial_steps,
+            );
+        };
+        if !conforms(element.ty, "Feature") {
+            return FeatureTypeReport::unavailable(
+                FeatureTypeIssue::InvalidElement,
+                false,
+                false,
+                initial_steps,
+            );
+        }
+        let step = conforms(element.ty, "Step");
+        let expression = conforms(element.ty, "Expression");
+        if initial_steps > crate::eval::MAX_STEPS {
+            return FeatureTypeReport::unavailable(
+                FeatureTypeIssue::WorkLimit,
+                step,
+                expression,
+                initial_steps,
+            );
+        }
+        let mut steps = initial_steps;
+        let mut evidence = match RepositoryTyping::new(&mut self.b, &mut steps) {
+            Ok(evidence) => evidence,
+            Err(issue) => {
+                return FeatureTypeReport::unavailable(
+                    if steps > crate::eval::MAX_STEPS {
+                        FeatureTypeIssue::WorkLimit
+                    } else {
+                        issue.into()
+                    },
+                    step,
+                    expression,
+                    steps,
+                );
+            }
+        };
+        let projection = evidence.project(feature.0, &mut steps);
+        steps = projection.steps;
+        if steps > crate::eval::MAX_STEPS {
+            return FeatureTypeReport::unavailable(
+                FeatureTypeIssue::WorkLimit,
+                step,
+                expression,
+                steps,
+            );
+        }
+        if !projection.complete() {
+            let issue = projection
+                .graph_issue
+                .or(projection.required_issue)
+                .expect("incomplete projection has a reason");
+            return FeatureTypeReport::unavailable(issue.into(), step, expression, steps);
+        }
+        // Charge the four bounded result traversals before allocation. The
+        // projection is complete; narrowing can still reject invalid function
+        // multiplicity or a Behavior that cannot redefine Function.
+        steps = steps.saturating_add(projection.candidates.len().saturating_mul(4));
+        if steps > crate::eval::MAX_STEPS {
+            return FeatureTypeReport::unavailable(
+                FeatureTypeIssue::WorkLimit,
+                step,
+                expression,
+                steps,
+            );
+        }
+        let behavior = if step {
+            projection
+                .behaviors(&evidence)
+                .map(|v| v.into_iter().map(ElementRef).collect())
+                .map_err(Into::into)
+        } else {
+            Err(FeatureTypeIssue::NotApplicable)
+        };
+        let function = if expression {
+            projection
+                .function(&evidence)
+                .map(|v| v.map(ElementRef))
+                .map_err(Into::into)
+        } else {
+            Err(FeatureTypeIssue::NotApplicable)
+        };
+        FeatureTypeReport {
+            types: Ok(projection.candidates.into_iter().map(ElementRef).collect()),
+            behavior,
+            function,
+            steps,
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/feature_type_projection/repository_tests.rs b/crates/sysmlv2-model/src/json/feature_type_projection/repository_tests.rs
new file mode 100644
index 0000000..383c2d0
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/feature_type_projection/repository_tests.rs
@@ -0,0 +1,272 @@
+//! Wire below feature_type_projection; adapter imports the pending shared seams.
+use super::adapter::RepositoryTyping;
+use super::{Evidence, Incomplete};
+use crate::{json::ResolvedModel, model::Model};
+fn model(source: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    let parsed = model.add_source("typing.kerml", source);
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    ResolvedModel::build(&model)
+}
+#[test]
+fn standalone_typing_and_subsetting_use_source_identity_not_relationship_carrier() {
+    let mut r = model("function F; feature x; typing x typed by F; feature y; subset y subsets x;");
+    let y = r.resolve_qualified("y").unwrap().0;
+    let f = r.resolve_qualified("F").unwrap().0;
+    let mut steps = 0;
+    let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+    let projection = evidence.project(y, &mut steps);
+    assert_eq!(projection.candidates, vec![f]);
+    assert_eq!(projection.graph_issue, None);
+    assert_eq!(
+        projection.function(&evidence),
+        Err(Incomplete::MissingRequiredFamilies)
+    );
+}
+#[test]
+fn callee_membership_alone_never_becomes_an_expression_function() {
+    let mut r = model("function F; feature call=F();");
+    let call = r.resolve_qualified("call").unwrap();
+    let expression = r.members_via(call, "FeatureValue")[0];
+    let mut steps = 0;
+    let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+    let projection = evidence.project(expression.0, &mut steps);
+    assert!(projection.candidates.is_empty());
+    assert_eq!(
+        projection.function(&evidence),
+        Err(Incomplete::MissingRequiredFamilies)
+    );
+}
+#[test]
+fn conjugation_preserves_own_typing_while_replacing_dependency_rules() {
+    let mut r = model("function F; function G; feature x:F; feature y:G conjugates x;");
+    let y = r.resolve_qualified("y").unwrap().0;
+    let x = r.resolve_qualified("x").unwrap().0;
+    let g = r.resolve_qualified("G").unwrap().0;
+    let mut steps = 0;
+    let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+    let input = evidence.inputs(y, &mut steps).unwrap();
+    assert_eq!(input.typings, vec![g]);
+    assert_eq!(input.features, vec![x]);
+}
+#[test]
+fn cross_subsetting_does_not_contribute_typing_dependencies() {
+    let mut r = model("function F; feature x:F; feature y subsets x;");
+    let y = r.resolve_qualified("y").unwrap().0;
+    let relation = r.b.elements[y]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&edge| r.b.elements[edge].ty == "Subsetting")
+        .unwrap();
+    r.b.elements[relation].ty = "CrossSubsetting";
+    let mut steps = 0;
+    let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+    let input = evidence.inputs(y, &mut steps).unwrap();
+    assert!(input.features.is_empty());
+}
+#[test]
+fn redundant_generic_endpoint_conflict_cannot_become_a_typing_witness() {
+    let mut r = model("function F; function G; feature x:F;");
+    let x = r.resolve_qualified("x").unwrap().0;
+    let g = r.resolve_qualified("G").unwrap();
+    let relation = r.b.elements[x]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&edge| r.b.elements[edge].ty == "FeatureTyping")
+        .unwrap();
+    let wrong_id = r.element_id(g).to_string();
+    r.b.elements[relation]
+        .props
+        .insert("target", serde_json::json!([{"@id":wrong_id}]));
+    let mut steps = 0;
+    let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+    let projection = evidence.project(x, &mut steps);
+    assert_eq!(
+        projection.graph_issue,
+        Some(Incomplete::InvalidRelationship)
+    );
+    assert!(projection.function(&evidence).is_err());
+}
+
+#[test]
+fn conflicting_source_arrays_cannot_certify_the_other_feature_has_no_typing() {
+    for key in ["source", "relatedElement"] {
+        let mut r = model("function F; feature x:F; feature y;");
+        let x = r.resolve_qualified("x").unwrap().0;
+        let y = r.resolve_qualified("y").unwrap().0;
+        let f = r.resolve_qualified("F").unwrap().0;
+        let relationship = r.b.elements[x]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&edge| r.b.elements[edge].ty == "FeatureTyping")
+            .unwrap();
+        let target = crate::json::id_ref(r.b.elements[f].id);
+        let source = crate::json::id_ref(r.b.elements[y].id);
+        let values = if key == "source" {
+            vec![source]
+        } else {
+            vec![source, target]
+        };
+        r.b.elements[relationship]
+            .props
+            .insert(key, crate::properties::Atom::Array(values));
+        let mut steps = 0;
+        let mut evidence = RepositoryTyping::new(&mut r.b, &mut steps).unwrap();
+        let projection = evidence.project(y, &mut steps);
+        assert_eq!(
+            projection.graph_issue,
+            Some(Incomplete::InvalidRelationship)
+        );
+    }
+}
+
+#[test]
+fn redundant_composite_intersections_require_current_reciprocal_witnesses() {
+    use crate::json::{ElementRef, FeatureTypeIssue};
+    use serde_json::json;
+    let mut m = Model::new();
+    let unit = m.add_library_source("composition.kerml", "standard library package Base {classifier Anything; feature things : Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything { composite feature suboccurrences : Occurrence subsets occurrences; } feature occurrences : Occurrence subsets Base::things;} standard library package Objects {struct Object specializes Occurrences::Occurrence { composite feature subobjects : Object subsets objects, Occurrences::Occurrence::suboccurrences intersects objects, Occurrences::Occurrence::suboccurrences;} feature objects : Object subsets Occurrences::occurrences;}");
+    assert!(unit.diagnostics.is_empty());
+    assert!(m.add_source("inherited.kerml", "feature external : Occurrences::Occurrence; class Container { composite feature nested subsets external; }").diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&m);
+    let inherited_only = r.resolve_qualified("Container::nested").unwrap();
+    assert!(r.feature_type_report(inherited_only).types.is_err());
+    let unrelated = r.resolve_qualified("Objects::Object").unwrap();
+    assert_eq!(
+        crate::json::type_relations::TypeRelations::default().specializes(
+            &mut r.b,
+            inherited_only.0,
+            unrelated.0,
+            &mut 0
+        ),
+        crate::json::type_relations::RelationFact::Unknown
+    );
+    let feature = r.resolve_qualified("Objects::Object::subobjects").unwrap();
+    let object = r.resolve_qualified("Objects::Object").unwrap();
+    let occurrence = r.resolve_qualified("Occurrences::Occurrence").unwrap();
+    let intersection = r.b.elements[feature.0]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&e| r.b.elements[e].ty == "Intersecting")
+        .unwrap();
+    assert_eq!(r.feature_type_report(feature).types, Ok(vec![object]));
+    let properties = r.b.elements[intersection].props.clone();
+    r.b.set(
+        intersection,
+        "intersectingType",
+        json!({"@id": r.element_id(occurrence).to_string()}),
+    );
+    assert!(r.feature_type_report(feature).types.is_err());
+    r.b.elements[intersection].props = properties.clone();
+    assert_eq!(r.feature_type_report(feature).types, Ok(vec![object]));
+    r.b.set(
+        intersection,
+        "owningRelatedElement",
+        json!({"@id": r.element_id(occurrence).to_string()}),
+    );
+    assert!(r.feature_type_report(feature).types.is_err());
+    r.b.elements[intersection].props = properties;
+    assert_eq!(r.feature_type_report(feature).types, Ok(vec![object]));
+    assert_eq!(
+        r.feature_type_report_with_budget(feature, crate::eval::MAX_STEPS)
+            .types,
+        Err(FeatureTypeIssue::WorkLimit)
+    );
+    assert_eq!(
+        r.feature_type_report(ElementRef(feature.0)).types,
+        Ok(vec![object])
+    );
+}
+
+#[test]
+fn nested_composite_owner_proof_refuses_mutations_cycles_and_budget_then_retries() {
+    use crate::{
+        json::{FeatureTypeIssue, id_ref},
+        model::GraphFormat,
+    };
+    use serde_json::json;
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut m = Model::with_graph_format(format);
+        let library = "standard library package Base {classifier Anything; feature things : Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything { composite feature suboccurrences : Occurrence subsets occurrences; } feature occurrences : Occurrence subsets Base::things;}";
+        assert!(
+            m.add_library_source("composition.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(m.add_source("nested.sysml", "occurrence def Event; occurrence outer : Event :> Occurrences::occurrences { occurrence inner : Event; } occurrence cyclic : Event :> cyclic::inner { occurrence inner : Event; }").diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&m);
+        let owner = r.resolve_qualified("outer").unwrap();
+        let child = r.resolve_qualified("outer::inner").unwrap();
+        let ty = r.resolve_qualified("Event").unwrap();
+        let cycle = r.resolve_qualified("cyclic::inner").unwrap();
+        assert!(r.feature_type_report(cycle).types.is_err());
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        assert_eq!(
+            r.feature_type_report_with_budget(child, crate::eval::MAX_STEPS)
+                .types,
+            Err(FeatureTypeIssue::WorkLimit)
+        );
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+
+        // Ordinary typed Kernel Feature owners use the same complete owner
+        // projection; the child remains a SysML OccurrenceUsage.
+        let original_properties = r.b.elements[owner.0].props.clone();
+        r.b.elements[owner.0].ty = "Feature";
+        r.b.elements[owner.0]
+            .props
+            .insert("isVariable", json!(false));
+        r.b.elements[owner.0]
+            .props
+            .insert("isComposite", json!(false));
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        r.b.elements[owner.0].ty = "OccurrenceUsage";
+        r.b.elements[owner.0].props = original_properties;
+        let properties = r.b.elements[owner.0].props.clone();
+        for (name, value) in [
+            ("isComposite", json!("invalid")),
+            ("isVariation", json!(true)),
+            ("isPortion", json!(true)),
+            ("portionKind", json!("timeslice")),
+        ] {
+            r.b.elements[owner.0].props.insert(name, value);
+            assert!(
+                r.feature_type_report(child).types.is_err(),
+                "{format:?} {name}"
+            );
+            r.b.elements[owner.0].props = properties.clone();
+            assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        }
+        r.b.metadata_of.insert(owner.0, vec![owner.0]);
+        assert!(r.feature_type_report(child).types.is_err());
+        r.b.metadata_of.insert(owner.0, Vec::new());
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        let membership = r.b.elements[child.0].owning_relationship.unwrap();
+        let properties = r.b.elements[membership].props.clone();
+        let wrong_owner = id_ref(r.b.elements[ty.0].id);
+        r.b.elements[membership]
+            .props
+            .insert("owningRelatedElement", wrong_owner);
+        assert!(r.feature_type_report(child).types.is_err());
+        r.b.elements[membership].props = properties;
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        let typing = r.b.elements[owner.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&e| r.b.elements[e].ty == "FeatureTyping")
+            .unwrap();
+        let properties = r.b.elements[typing].props.clone();
+        r.b.elements[typing]
+            .props
+            .insert("type", json!({"@ref": "Missing"}));
+        assert!(r.feature_type_report(child).types.is_err());
+        r.b.elements[typing].props = properties;
+        assert_eq!(r.feature_type_report(child).types, Ok(vec![ty]));
+        let mut evidence = RepositoryTyping::new(&mut r.b, &mut 0).unwrap();
+        assert!(evidence.project(child.0, &mut 0).complete());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/function_specialization_readiness_tests.rs b/crates/sysmlv2-model/src/json/function_specialization_readiness_tests.rs
new file mode 100644
index 0000000..61826a8
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/function_specialization_readiness_tests.rs
@@ -0,0 +1,40 @@
+//! Private TypeRelations tests; include under type_relations module.
+use super::*;
+use crate::{json::ResolvedModel, model::Model};
+fn fixture(evaluation_base: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    let library = format!(
+        "standard library package Base {{classifier Anything;}} standard library package Occurrences {{class Occurrence specializes Base::Anything;}} standard library package Performances {{behavior Performance specializes Occurrences::Occurrence; function Evaluation {evaluation_base};}}"
+    );
+    let parsed = model.add_library_source("function-bases.kerml", &library);
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let parsed=model.add_source("functions.kerml","function F specializes Performances::Evaluation; function G specializes Performances::Evaluation;");
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    ResolvedModel::build(&model)
+}
+#[test]
+fn exact_functions_have_negative_evidence_only_with_required_ancestor_paths() {
+    let mut r = fixture("specializes Performance");
+    let f = r.resolve_qualified("F").unwrap().0;
+    let g = r.resolve_qualified("G").unwrap().0;
+    let mut proof = TypeRelations::default();
+    assert_eq!(proof.specializes(&mut r.b, f, g, &mut 0), RelationFact::No);
+    let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+    assert_eq!(
+        proof.specializes(&mut r.b, f, evaluation, &mut 0),
+        RelationFact::Yes
+    );
+    let mut r = fixture("");
+    let f = r.resolve_qualified("F").unwrap().0;
+    let g = r.resolve_qualified("G").unwrap().0;
+    let mut proof = TypeRelations::default();
+    assert!(
+        proof.required_bases(&mut r.b, f, &mut 0).is_some(),
+        "canonical names are present"
+    );
+    assert_eq!(
+        proof.specializes(&mut r.b, f, g, &mut 0),
+        RelationFact::Unknown,
+        "name availability cannot manufacture a missing Evaluation→Performance path"
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/generated_defaults.rs b/crates/sysmlv2-model/src/json/generated_defaults.rs
new file mode 100644
index 0000000..5cdb9f1
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/generated_defaults.rs
@@ -0,0 +1,238 @@
+//! Owned defaults for newly generated Feature-family full-form records.
+//! This is serialization of declared defaults, not a semantic completeness
+//! certificate. Source rows and the historical generic relationship rows do
+//! not use this projection.
+use crate::{properties::Properties, semantic_catalog};
+use serde_json::{Map, Value};
+
+pub(super) fn fill_owned_defaults(ty: &str, stored: &Properties, record: &mut Map<String, Value>) {
+    let Some(properties) = semantic_catalog::properties(ty) else {
+        return;
+    };
+    for &(requested, effective) in properties {
+        let requested = &semantic_catalog::PROPERTIES[usize::from(requested)];
+        let name = requested.name;
+        let Some(spec) = semantic_catalog::PROPERTIES.get(usize::from(effective)) else {
+            continue;
+        };
+        if spec.derived
+            || record.contains_key(name)
+            || spec
+                .storage_names
+                .iter()
+                .any(|name| stored.get(name).is_some())
+        {
+            continue;
+        }
+        let Some(default) = spec.default_json else {
+            continue;
+        };
+        let Ok(value) = serde_json::from_str(default) else {
+            continue;
+        };
+        let Ok(value) = super::semantic::reshape(value, requested) else {
+            continue;
+        };
+        record.insert(name.into(), value);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn feature_defaults_match_owned_declarations_without_derived_guesses() {
+        let stored = Properties::new();
+        let mut record = Map::new();
+        fill_owned_defaults("Feature", &stored, &mut record);
+        assert_eq!(record["isUnique"], true);
+        for name in [
+            "isAbstract",
+            "isSufficient",
+            "isComposite",
+            "isOrdered",
+            "isEnd",
+            "isConstant",
+            "isDerived",
+            "isPortion",
+            "isVariable",
+        ] {
+            assert_eq!(record[name], false, "{name}");
+        }
+        for name in [
+            "isConjugated",
+            "direction",
+            "type",
+            "owningType",
+            "multiplicity",
+        ] {
+            assert!(!record.contains_key(name), "{name}");
+        }
+    }
+    #[test]
+    fn explicit_values_and_nulls_are_preserved_and_effective_defaults_win() {
+        let mut stored = Properties::new();
+        stored.insert("isUnique", serde_json::json!(false));
+        stored.insert("isAbstract", Value::Null);
+        let mut record = stored.to_json();
+        fill_owned_defaults("Feature", &stored, &mut record);
+        assert_eq!(record["isUnique"], false);
+        assert!(record["isAbstract"].is_null());
+        let stored = Properties::new();
+        let mut record = Map::new();
+        fill_owned_defaults("ConnectionDefinition", &stored, &mut record);
+        assert_eq!(
+            record["isSufficient"], true,
+            "effective ConnectionDefinition override wins over Type=false"
+        );
+    }
+}
+
+#[cfg(test)]
+mod model_tests {
+    use crate::{
+        json::{ClosurePolicy, Derived, ResolvedModel},
+        model::Model,
+    };
+    #[test]
+    fn generated_feature_full_record_matches_checked_owned_defaults_and_keeps_source_sparse() {
+        let mut model = Model::new();
+        model.add_library_source("defaults-library.kerml","standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+        assert!(
+            model
+                .add_source(
+                    "defaults-user.kerml",
+                    "class A; feature referent; feature read=referent;"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let compact = crate::json::model_to_compact_json(&model);
+        let mut r = ResolvedModel::build(&model);
+        let authored: Vec<_> = r
+            .elements()
+            .map(|e| (r.element_id(e), r.element_properties(e)))
+            .collect();
+        let expr = r
+            .elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let result = match r.derived(expr, "result") {
+            Derived::Value(v) => v.element().unwrap(),
+            v => panic!("{v:?}"),
+        };
+        let result_id = r.element_id(result).to_string();
+        let record = r.generated_node_record(result).unwrap();
+        for name in [
+            "isUnique",
+            "isAbstract",
+            "isSufficient",
+            "isComposite",
+            "isOrdered",
+            "isEnd",
+            "isConstant",
+            "isDerived",
+            "isPortion",
+            "isVariable",
+        ] {
+            assert_eq!(record[name], r.property(result, name).unwrap(), "{name}");
+            assert!(
+                !r.element_properties(result).contains_key(name),
+                "serialization must not mutate storage"
+            );
+        }
+        assert_eq!(record["direction"], "out");
+        assert!(!record.contains_key("isConjugated"));
+        let a = r.resolve_qualified("A").unwrap();
+        let generic = r
+            .implied_relationships(a)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "Subclassification")
+            .unwrap();
+        let generic_record = r.generated_node_record(generic).unwrap();
+        assert_eq!(generic_record["isImplied"], true);
+        assert!(!generic_record.contains_key("visibility"));
+        assert!(!generic_record.contains_key("isUnique"));
+        let full = crate::full::resolved_to_full_json(
+            &mut r,
+            &model,
+            crate::full::EmissionPolicy {
+                closures: ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        let full_result = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|v| v["@id"] == result_id)
+            .unwrap();
+        for name in ["isUnique", "isAbstract", "isOrdered"] {
+            assert_eq!(full_result[name], record[name]);
+        }
+        let ends: Vec<_> = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|row| row["@type"] == "Feature" && row["isEnd"] == true)
+            .collect();
+        assert_eq!(ends.len(), 2);
+        for row in ends {
+            let end = r.element_by_id(row["@id"].as_str().unwrap()).unwrap();
+            assert_eq!(r.property(end, "isVariable").unwrap(), false);
+            assert_eq!(r.property(end, "isConstant").unwrap(), false);
+            assert_eq!(row["isVariable"], false);
+            assert_eq!(row["isConstant"], false);
+            assert!(!r.element_properties(end).contains_key("isConstant"));
+        }
+        assert_eq!(crate::json::model_to_compact_json(&model), compact);
+        assert_eq!(
+            r.elements()
+                .map(|e| (r.element_id(e), r.element_properties(e)))
+                .collect::<Vec<_>>(),
+            authored
+        );
+    }
+    #[test]
+    fn nonunique_ordered_referent_does_not_fabricate_result_flag_inheritance() {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source(
+                    "collection-defaults.kerml",
+                    "feature referent[*] ordered nonunique; feature read=referent;"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let referent = r.resolve_qualified("referent").unwrap();
+        assert_eq!(r.property(referent, "isUnique").unwrap(), false);
+        assert_eq!(r.property(referent, "isOrdered").unwrap(), true);
+        let expr = r
+            .elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        let result = match r.derived(expr, "result") {
+            Derived::Value(v) => v.element().unwrap(),
+            v => panic!("{v:?}"),
+        };
+        let record = r.generated_node_record(result).unwrap();
+        assert_eq!(record["isUnique"], r.property(result, "isUnique").unwrap());
+        assert_eq!(
+            record["isOrdered"],
+            r.property(result, "isOrdered").unwrap()
+        );
+        assert_eq!(record["isUnique"], true);
+        assert_eq!(record["isOrdered"], false);
+        // This records the current graph's defaults. Correct collection-value
+        // preservation by the result/Binding family remains a separate audit;
+        // Subsetting's one-way uniqueness constraint is not flag inheritance.
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/identity_tables_tests.rs b/crates/sysmlv2-model/src/json/identity_tables_tests.rs
new file mode 100644
index 0000000..834ccce
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/identity_tables_tests.rs
@@ -0,0 +1,163 @@
+//! A build on a prepared library assigns its rows the identities a joint
+//! build assigns while tabling only its own rows: the frozen rows' ids are
+//! read through the table their freeze kept and their names on demand.
+
+use super::{ResolvedModel, id_index_tabled, library_names_built, prefix_ids_served};
+use crate::model::Model;
+use std::sync::Arc;
+use uuid::Uuid;
+
+const LIBRARY: &str = "package Lib { part def Base { attribute mass; } }";
+/// An unnamed feature redefining a library feature, and one redefining
+/// that: identity names reached through this build's rows and the frozen
+/// ones alike.
+const USER: &str = "package U { part def Car :> Lib::Base { attribute :>> mass; } part car : Car { attribute :>> mass = 1; } }";
+
+/// The model built on the library prepared, or built together with it.
+fn build(prepared: bool) -> ResolvedModel {
+    let mut model = Model::new();
+    if prepared {
+        let mut base = Model::new();
+        let parsed = base.add_library_source("lib.sysml", LIBRARY);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        base.prepare_library().unwrap().install(&mut model).unwrap();
+    } else {
+        model.add_library_source("lib.sysml", LIBRARY);
+    }
+    let parsed = model.add_source("user.sysml", USER);
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let r = ResolvedModel::build(&model);
+    assert_eq!(r.b.library_facts.is_some(), prepared);
+    r
+}
+
+/// The user rows' ids, with the metaclass each row has.
+fn user_ids(r: &ResolvedModel) -> Vec<(&'static str, Uuid)> {
+    r.b.elements
+        .iter()
+        .skip(r.b.lib_boundary)
+        .map(|e| (e.ty, e.id))
+        .collect()
+}
+
+#[test]
+fn a_build_on_a_prepared_library_assigns_the_ids_a_joint_build_assigns() {
+    let served = prefix_ids_served();
+    let mut prepared = build(true);
+    assert_eq!(prefix_ids_served(), served + 1, "the kept table served");
+    let mut joint = build(false);
+    assert_eq!(
+        prefix_ids_served(),
+        served + 1,
+        "a joint build tables every row"
+    );
+    assert_eq!(prepared.b.lib_boundary, joint.b.lib_boundary);
+    assert_eq!(user_ids(&prepared), user_ids(&joint));
+
+    // The identities are named through the library feature, not positional:
+    // each redefining feature chains past its membership under its owner as
+    // `::mass`, the name read from the frozen row.
+    for r in [&mut prepared, &mut joint] {
+        let car = r.resolve_qualified("U::car").unwrap().0;
+        let mass = r.resolve_qualified("U::car::mass").unwrap().0;
+        let def = r.resolve_qualified("U::Car").unwrap().0;
+        let def_mass = r.resolve_qualified("U::Car::mass").unwrap().0;
+        assert!(def_mass >= r.b.lib_boundary && mass >= r.b.lib_boundary);
+        assert_eq!(
+            r.b.elements[def_mass].id,
+            Uuid::new_v5(&r.b.elements[def].id, b"::mass")
+        );
+        assert_eq!(
+            r.b.elements[mass].id,
+            Uuid::new_v5(&r.b.elements[car].id, b"::mass")
+        );
+    }
+}
+
+/// The element index tables only the build's own rows on a prepared
+/// library, reading the frozen rows through the table their freeze kept,
+/// and is kept across the lookup-cache resets between resolution passes.
+#[test]
+fn the_id_index_tables_only_a_prepared_builds_own_rows_once() {
+    let mut r = build(true);
+    let own = r.b.elements.len() - r.b.lib_boundary;
+    let car = r.resolve_qualified("U::car").unwrap().0;
+    let base = r.resolve_qualified("Lib::Base").unwrap().0;
+    let (car_id, base_id) = (r.b.elements[car].id, r.b.elements[base].id);
+    r.b.id_index = None;
+    let tabled = id_index_tabled();
+    assert_eq!(r.b.element_index_of_uuid(car_id), Some(car));
+    assert_eq!(
+        id_index_tabled() - tabled,
+        own,
+        "the build's own rows, once"
+    );
+    assert_eq!(
+        r.b.element_index_of_uuid(base_id),
+        Some(base),
+        "a frozen row, through the kept table"
+    );
+    r.b.reset_lookup_caches();
+    assert_eq!(r.b.element_index_of_uuid(car_id), Some(car));
+    assert_eq!(
+        id_index_tabled() - tabled,
+        own,
+        "kept across the lookup-cache reset"
+    );
+
+    // joint: every row, as before
+    let mut r = build(false);
+    let car = r.resolve_qualified("U::car").unwrap().0;
+    let car_id = r.b.elements[car].id;
+    r.b.id_index = None;
+    let tabled = id_index_tabled();
+    assert_eq!(r.b.element_index_of_uuid(car_id), Some(car));
+    assert_eq!(id_index_tabled() - tabled, r.b.elements.len());
+}
+
+/// The library name tables by id are made once per prepared library and
+/// shared by every build on it; a joint build makes its own.
+#[test]
+fn library_name_tables_are_made_once_per_prepared_library() {
+    let mut base = Model::new();
+    base.add_library_source("lib.sysml", LIBRARY);
+    let library = base.prepare_library().unwrap();
+    let before = library_names_built();
+    for _ in 0..3 {
+        let mut model = Model::new();
+        Arc::clone(&library).install(&mut model).unwrap();
+        model.add_source("user.sysml", USER);
+        let r = ResolvedModel::build(&model);
+        // read the shared cell as the identity assignment would
+        let mut tables = r.b.identity_tables_for_test();
+        assert!(tables.table_name(&r.b, Uuid::nil()).is_none());
+    }
+    assert_eq!(library_names_built() - before, 1, "made once, shared");
+}
+
+/// An identity override of a library row writes a frozen row in place:
+/// the kept frozen table no longer serves, and the index tables every
+/// row again, the new id found and the old one gone.
+#[test]
+fn an_overridden_library_id_retires_the_kept_table() {
+    let mut r = build(true);
+    let mass = r.resolve_qualified("Lib::Base::mass").unwrap();
+    assert!(mass.0 < r.b.lib_boundary);
+    let old = r.element_id(mass);
+    let fresh = Uuid::from_u128(0x0f0f_0f0f_0f0f_4f0f_8f0f_0f0f_0f0f_0f0f);
+    assert_eq!(
+        r.override_ids(&std::collections::HashMap::from([(old, fresh)]))
+            .len(),
+        1
+    );
+    assert!(!r.b.elements.base_untouched(), "a frozen row written");
+    let tabled = id_index_tabled();
+    r.b.id_index = None;
+    assert_eq!(r.b.element_index_of_uuid(fresh), Some(mass.0));
+    assert_eq!(r.b.element_index_of_uuid(old), None);
+    assert_eq!(
+        id_index_tabled() - tabled,
+        r.b.elements.len(),
+        "every row tabled"
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/implied.rs b/crates/sysmlv2-model/src/json/implied.rs
index bccb0e7..c18cab9 100644
--- a/crates/sysmlv2-model/src/json/implied.rs
+++ b/crates/sysmlv2-model/src/json/implied.rs
@@ -2,8 +2,7 @@
 //!
 //! SysML 8.4.2 Tables 31/32 give every definition and usage kind a library
 //! base it implicitly specializes (`part def` → `Parts::Part`, `part` →
-//! `Parts::parts`, …) unless an explicit specialization of the covering
-//! kind is written, and a variant usage implicitly specializes the
+//! `Parts::parts`, …), and a variant usage implicitly specializes the
 //! variation it is a variant of (SysML `checkUsageVariationDefinition-
 //! Specialization` / `-UsageSpecialization`: a FeatureTyping to the
 //! owning variation definition — an enumeration literal's typing — or a
@@ -15,13 +14,13 @@
 //! implied heritage instead ([`super::implicit_def_bases`]).
 //!
 //! The derivation layer materializes them on first demand for the whole
-//! model — when the library bases are known, from a loaded library or a
-//! name table ([`ResolvedModel::set_library_names`]); a model with
-//! neither gets none at all, the variant specializations included, so
-//! that `isImpliedIncluded` (false without a library) never contradicts
-//! a listed implied relationship (KerML: `ownedRelationship->exists(isImplied)
-//! implies isImpliedIncluded`). One relationship element per implied
-//! specialization, appended
+//! model. Library/variation bases are planned when library names are known,
+//! from a loaded library or a name table ([`ResolvedModel::set_library_names`]).
+//! Supported positional redefinitions between local elements are also
+//! materialized, including for models without a library. Library declarations
+//! participate because their own kind-required bases and positional
+//! redefinitions need not be written explicitly. One relationship element per
+//! implied specialization is appended
 //! to the element list past every explicit element (`Builder::implied_from`
 //! marks the boundary, so the checks, lints and iteration over the model
 //! keep to the explicit elements), owned by its specific side through a
@@ -32,14 +31,20 @@
 //! emitter takes its implied relationships from here.
 //!
 //! Ids are the emitter's: `uuid5(OID, "{owner id}/implied{n}")` with `n`
-//! the relationship's position among its owner's implied ones — the
-//! library bases in table order, then the variant specialization.
+//! the relationship's former position among its owner's implied ones. New
+//! edges use `uuid5(OID, "{owner id}/implied/{metaclass}/{target id}")`.
+//! An edge is omitted only when another specialization path reaches its
+//! required target; cycle-safe elimination keeps each requirement reachable.
+//! The unconditional inherited Feature requirement independently contributes
+//! Base::things when its loaded canonical Feature identity is established;
+//! variable, end and portion constraints add separate obligations.
 
-use super::{Elem, ElementRef, ResolvedModel, implicit_def_bases, implicit_usage_bases};
+use super::{Builder, Elem, ElementRef, ResolvedModel, implicit_def_bases, implicit_usage_bases};
 use crate::lift::{def_kind_of, usage_kind_of};
 use crate::metaclass::conforms;
 use serde_json::json;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, OnceLock};
 use sysmlv2_syntax::ast::Dialect;
 use uuid::Uuid;
 
@@ -54,98 +59,4406 @@ type ImpliedBases = (
     &'static [&'static str],
 );
 
+type SpecializationGraph = HashMap<Uuid, Vec<Uuid>>;
+type StaticPlannerBases = (HashMap<usize, Vec<usize>>, HashSet<usize>);
+
+type PlannedEdge = (&'static str, &'static str, &'static str, Uuid);
+
+pub(super) type RetainedTypings = HashMap<usize, Vec<(&'static str, Uuid)>>;
+
+/// The immutable supported library/variation plan. The positional graph and
+/// materialized relationship graph share this calculation, but own any later
+/// positional edges independently.
+pub(super) struct SupportedImpliedSpecializations {
+    candidates: Vec<(usize, PlannedEdge)>,
+    retained: Vec<bool>,
+    graph: SpecializationGraph,
+    by_owner: HashMap<usize, Vec<Uuid>>,
+    typing_by_owner: OnceLock<Arc<RetainedTypings>>,
+    library_configuration: bool,
+    expression_targets: HashMap<&'static str, Uuid>,
+    chain_bases: Arc<super::type_relations::FeatureChainBases>,
+    // Validation memo only: the graph stays immutable and the token is the
+    // existing row revision, never a separate semantic generation.
+    source_rows: std::sync::Mutex<crate::layered::Revision>,
+    source_names: crate::layered::Revision,
+}
+
 /// The materialized implied relationships: their owners, and each
 /// owner's list in order.
+#[derive(Clone)]
 pub(super) struct ImpliedTable {
     /// Index of the first implied relationship in the element list.
     pub from: usize,
-    /// Owner of the implied relationship at `from + k`.
-    pub owner_of: Vec<usize>,
-    /// Owner → its implied relationships, in order.
-    pub by_owner: HashMap<usize, Vec<usize>>,
+    /// New owned-result nodes start after the stable old implied families.
+    pub(super) owned_results_from: usize,
+    pub(super) owned_results_state: OwnedResultState,
+    /// Known explicit and retained implied specialization targets.
+    specializations: SpecializationGraph,
+    static_authority: Arc<SupportedImpliedSpecializations>,
+    static_rows: crate::layered::Revision,
+    static_owners: HashSet<usize>,
 }
 
-impl ResolvedModel {
-    /// Materialize the implied relationships on first demand.
-    pub(super) fn ensure_implied(&mut self) {
-        if self.implied.is_some() {
-            return;
+pub(super) fn specialization_target(relation: &Elem) -> Option<Uuid> {
+    [
+        "general",
+        "superclassifier",
+        "type",
+        "subsettedFeature",
+        "redefinedFeature",
+        "referencedFeature",
+        "crossedFeature",
+    ]
+    .iter()
+    .find_map(|key| relation.props.get(key))
+    .and_then(|value| value.as_reference())
+}
+
+/// Required most-specific Kernel Semantic Library base of supported leaf expressions.
+/// The base supplies evaluation heritage and an inherited return parameter;
+/// no result is synthesized as an owned member of these expressions.
+pub(super) fn literal_implied_base(ty: &str) -> Option<&'static str> {
+    Some(match ty {
+        "LiteralBoolean" => "Performances::literalBooleanEvaluations",
+        "LiteralInteger" | "LiteralInfinity" => "Performances::literalIntegerEvaluations",
+        "LiteralRational" => "Performances::literalRationalEvaluations",
+        "LiteralString" => "Performances::literalStringEvaluations",
+        "NullExpression" => "Performances::nullEvaluations",
+        "MetadataAccessExpression" => "Performances::metadataAccessEvaluations",
+        _ => return None,
+    })
+}
+
+/// Most-specific supported expression base in the shared static plan.
+/// Every Expression specializes evaluations (checkExpressionSpecialization).
+/// Keep this primary role first for stable planning order. The generic
+/// Expression obligation and inherited Boolean/Literal obligations are also
+/// accumulated independently below; a missing narrower role must not erase
+/// an available broader requirement.
+/// Dynamic callee/result requirements remain separate.
+fn expression_implied_base(ty: &str) -> Option<&'static str> {
+    literal_implied_base(ty).or_else(|| {
+        if ty == "ConstructorExpression" {
+            Some("Performances::constructorEvaluations")
+        } else {
+            conforms(ty, "Expression").then_some("Performances::evaluations")
+        }
+    })
+}
+
+/// Inherited obligations apply to leaf expressions as well as their abstract
+/// bases. The exact-leaf result-provider policy remains separate: broader
+/// LiteralExpression ancestry cannot certify a missing leaf role or value.
+fn additional_expression_base(ty: &str) -> Option<&'static str> {
+    if conforms(ty, "BooleanExpression") {
+        Some("Performances::booleanEvaluations")
+    } else if conforms(ty, "LiteralExpression") {
+        Some("Performances::literalEvaluations")
+    } else {
+        None
+    }
+}
+
+fn invariant_implied_base(negated: bool) -> &'static str {
+    if negated {
+        "Performances::falseEvaluations"
+    } else {
+        "Performances::trueEvaluations"
+    }
+}
+
+/// isNegated is a required Boolean with default false. Only absence uses
+/// that default; an explicitly malformed value cannot select either branch.
+fn invariant_negation(element: &Elem) -> Option<bool> {
+    match element.props.get("isNegated") {
+        None => Some(false),
+        Some(value) => value.as_bool(),
+    }
+}
+
+/// SysML assert/satisfy obligations accumulate independently of inherited
+/// Invariant requirements. A missing narrower role never removes another one.
+fn assertion_implied_base(negated: bool) -> &'static str {
+    if negated {
+        "Constraints::negatedConstraintChecks"
+    } else {
+        "Constraints::assertedConstraintChecks"
+    }
+}
+
+fn satisfaction_implied_base(negated: bool) -> &'static str {
+    if negated {
+        "Requirements::notSatisfiedRequirementChecks"
+    } else {
+        "Requirements::satisfiedRequirementChecks"
+    }
+}
+
+/// FeatureChainExpression fixes its operator to the canonical dot Function.
+/// This typing is independent of its still-incomplete owned expression graph.
+const CHAIN_FUNCTION: &str = "ControlFunctions::.";
+
+/// checkFeatureSpecialization is unconditional for every Feature descendant,
+/// including variable, end and portion features. Other families remain separate.
+const FEATURE_BASE: &str = "Base::things";
+const STEP_BASE: &str = "Performances::performances";
+const TYPED_FEATURE_BASES: [(&str, &str); 3] = [
+    ("Structure", "Objects::objects"),
+    ("Class", "Occurrences::occurrences"),
+    ("DataType", "Base::dataValues"),
+];
+
+const BINARY_ROLES: [(&str, &str); 4] = [
+    ("Connections::BinaryConnection", "ConnectionDefinition"),
+    ("Interfaces::BinaryInterface", "InterfaceDefinition"),
+    ("Connections::binaryConnections", "ConnectionUsage"),
+    ("Interfaces::binaryInterfaces", "InterfaceUsage"),
+];
+
+pub(super) fn binary_role_name(package: &str, member: &str) -> Option<&'static str> {
+    match (package, member) {
+        ("Connections", "BinaryConnection") => Some(BINARY_ROLES[0].0),
+        ("Interfaces", "BinaryInterface") => Some(BINARY_ROLES[1].0),
+        ("Connections", "binaryConnections") => Some(BINARY_ROLES[2].0),
+        ("Interfaces", "binaryInterfaces") => Some(BINARY_ROLES[3].0),
+        _ => None,
+    }
+}
+
+fn expression_role_kind(name: &str) -> &'static str {
+    if let Some((_, kind)) = BINARY_ROLES.iter().find(|(role, _)| *role == name) {
+        return kind;
+    }
+    match name {
+        CHAIN_FUNCTION => "Function",
+        STEP_BASE => "Step",
+        "Items::Item::subitems" => "ItemUsage",
+        "Items::Item::subparts" => "PartUsage",
+        "Objects::Object::subobjects"
+        | "Occurrences::Occurrence::suboccurrences"
+        | FEATURE_BASE
+        | "Objects::objects"
+        | "Occurrences::occurrences"
+        | "Base::dataValues" => "Feature",
+        "Constraints::assertedConstraintChecks" | "Constraints::negatedConstraintChecks" => {
+            "ConstraintUsage"
+        }
+        "Requirements::satisfiedRequirementChecks"
+        | "Requirements::notSatisfiedRequirementChecks" => "RequirementUsage",
+        // Every supported Performances evaluation role is declared as an expr
+        // in the pinned Kernel Semantic Library. Feature/Step siblings do not
+        // establish that role, even with its canonical name and loaded UUID.
+        _ => "Expression",
+    }
+}
+
+fn planning_charge(steps: &mut Option<&mut usize>, amount: usize) -> Option<()> {
+    if let Some(steps) = steps {
+        **steps = steps.saturating_add(amount);
+        if **steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+    }
+    Some(())
+}
+
+/// Stable descending order of dense DFS ranks. Candidate order within a rank
+/// must survive: it decides which cycle anchor is retained by reduction.
+fn reverse_rank_order(
+    indices: std::ops::Range<usize>,
+    rank_count: usize,
+    rank_at: impl Fn(usize) -> usize,
+    steps: &mut Option<&mut usize>,
+) -> Option<Vec<usize>> {
+    planning_charge(steps, rank_count)?;
+    let mut buckets = vec![Vec::new(); rank_count];
+    let count = indices.len();
+    for index in indices {
+        planning_charge(steps, 1)?;
+        buckets[rank_at(index)].push(index);
+    }
+    planning_charge(steps, rank_count.saturating_add(count))?;
+    Some(buckets.into_iter().rev().flatten().collect())
+}
+
+impl Builder {
+    /// Every retained-plan consumer refreshes these common source facts before
+    /// reusing the graph. Refusal never advances the memo or poisons a retry.
+    pub(super) fn refresh_supported_chain_evidence(
+        &mut self,
+        mut steps: Option<&mut usize>,
+    ) -> Option<()> {
+        planning_charge(&mut steps, 1)?;
+        let Some(plan) = self.supported_implied.clone() else {
+            // A positional cache cannot outlive its required-base authority.
+            planning_charge(
+                &mut steps,
+                self.positional_redefinitions.as_ref().map_or(0, |p| {
+                    p.targets.capacity().saturating_add(p.incomplete.capacity())
+                }),
+            )?;
+            self.positional_redefinitions = None;
+            return Some(());
+        };
+        if self.supported_chain_evidence_current() {
+            return Some(());
+        }
+        // Arbitrary row edits can also change positional ownership/order or
+        // the authored graph used to minimize requirements. Chain-only equality
+        // cannot certify those dependencies. Known append transactions advance
+        // source_rows themselves; every other edit requires a new common plan.
+        // Hash maps containing Vec values scan buckets on final drop. Their
+        // flat Copy payloads do not require element-by-element destruction.
+        let retirement = plan
+            .graph
+            .capacity()
+            .saturating_add(plan.by_owner.capacity())
+            .saturating_add(plan.typing_by_owner.get().map_or(0, |m| m.capacity()))
+            .saturating_add(self.positional_redefinitions.as_ref().map_or(0, |p| {
+                p.targets.capacity().saturating_add(p.incomplete.capacity())
+            }));
+        planning_charge(&mut steps, retirement)?;
+        self.supported_implied = None;
+        self.positional_redefinitions = None;
+        Some(())
+    }
+
+    fn static_source_facts_current(&self, plan: &SupportedImpliedSpecializations) -> bool {
+        self.elements
+            .revision()
+            .is_some_and(|now| plan.source_rows.lock().unwrap().same_as(now))
+            && self
+                .lib_qnames
+                .revision()
+                .is_some_and(|now| plan.source_names.same_as(now))
+            && plan.library_configuration == self.external_implied_names.is_empty()
+    }
+    pub(super) fn supported_chain_evidence_current(&self) -> bool {
+        self.supported_implied
+            .as_ref()
+            .is_some_and(|plan| self.static_source_facts_current(plan))
+    }
+    pub(super) fn physical_static_authority_current(&self) -> bool {
+        self.implied.as_ref().is_none_or(|table| {
+            // Clearing optional lookup caches is not semantic invalidation. The
+            // table still retains the exact recipe authority and its source facts.
+            self.static_source_facts_current(&table.static_authority)
+                && self
+                    .supported_implied
+                    .as_ref()
+                    .is_none_or(|plan| Arc::ptr_eq(plan, &table.static_authority))
+                && self
+                    .elements
+                    .revision()
+                    .is_some_and(|rows| table.static_rows.same_as(rows))
+        })
+    }
+    /// Revalidate the complete existing prefix after arbitrary edits/remaps.
+    /// Failed physical recipes stay addressable but cannot prove semantics.
+    pub(super) fn certify_materialized_static_prefix(&mut self, steps: &mut usize) -> Option<bool> {
+        planning_charge(&mut Some(&mut *steps), 1)?;
+        if self.physical_static_authority_current() {
+            return Some(true);
+        }
+        if self.positional_planning {
+            return Some(false);
+        }
+        let boundary = self.implied.as_ref()?.owned_results_from;
+        planning_charge(
+            &mut Some(&mut *steps),
+            self.lib_qnames
+                .len()
+                .saturating_add(self.external_implied_names.len()),
+        )?;
+        for (_, parts) in &self.lib_qnames {
+            planning_charge(&mut Some(&mut *steps), parts.len())?;
+            for part in parts {
+                planning_charge(&mut Some(&mut *steps), part.len())?;
+            }
+        }
+        for name in self.external_implied_names.keys() {
+            planning_charge(&mut Some(&mut *steps), name.len())?;
+        }
+        let names = self
+            .lib_qnames
+            .iter()
+            .map(|(id, parts)| (parts.join("::"), *id))
+            .chain(
+                self.external_implied_names
+                    .iter()
+                    .map(|(name, id)| (name.clone(), *id)),
+            )
+            .collect();
+        let prefix = self.static_specialization_prefix(
+            &names,
+            self.external_implied_names.is_empty(),
+            Some(&mut *steps),
+        )?;
+        let captured =
+            super::dynamic_invocations::capture_static_prefix(self, prefix, Some(boundary), steps);
+        planning_charge(&mut Some(&mut *steps), 0)?;
+        Some(captured.is_ok())
+    }
+    pub(super) fn static_chain_row_current(&self, relationship: usize) -> bool {
+        self.implied.as_ref().is_none_or(|table| {
+            !(table.from..table.owned_results_from).contains(&relationship)
+                || self.physical_static_authority_current()
+        })
+    }
+    fn static_chain_owner_current(&self, owner: usize) -> bool {
+        self.implied.as_ref().is_none_or(|table| {
+            !table.static_owners.contains(&owner) || self.physical_static_authority_current()
+        })
+    }
+    // Called only after capture_static_prefix validates every physical recipe.
+    // A new current plan alone is never sufficient to bless old physical rows.
+    pub(super) fn recertify_physical_static_authority(&mut self, steps: &mut usize) -> Option<()> {
+        if self.physical_static_authority_current() {
+            return Some(());
+        }
+        let plan = self.supported_implied.clone()?;
+        planning_charge(&mut Some(&mut *steps), self.elements.len())?;
+        for element in &self.elements {
+            planning_charge(&mut Some(&mut *steps), element.owned_relationships.len())?;
+        }
+        let owners = self.semantic_relationship_owners();
+        let (_, graph) = self.required_specialization_edges_with_chain_bases(
+            &[],
+            0,
+            self.elements.len(),
+            &owners,
+            &plan.chain_bases,
+            Some(&mut *steps),
+        )?;
+        // Retire the old compatibility graph only after charged reconstruction.
+        planning_charge(
+            &mut Some(&mut *steps),
+            self.implied.as_ref()?.specializations.capacity(),
+        )?;
+        let rows = self.elements.observe_revision();
+        if let Some(table) = &mut self.implied {
+            table.static_authority = plan;
+            table.static_rows = rows;
+            table.specializations = graph;
+        }
+        Some(())
+    }
+
+    /// Structural owners, including memberships without a name or body scope.
+    fn specialization_relation_owners(&self) -> Vec<Option<usize>> {
+        let mut owners = vec![None; self.elements.len()];
+        for (owner, element) in self.elements.iter().enumerate() {
+            for &relationship in &element.owned_relationships {
+                owners[relationship] = Some(owner);
+            }
+        }
+        owners
+    }
+
+    /// The supported direct implied requirements, shared by positional rules
+    /// and lazy relationship materialization. Library-owned requirements matter:
+    /// library declarations can themselves omit a kind-required generalization.
+    fn supported_implied_specializations(
+        &mut self,
+        names: &HashMap<String, Uuid>,
+        use_library_cache: bool,
+    ) -> Arc<SupportedImpliedSpecializations> {
+        self.supported_implied_specializations_with_budget(names, use_library_cache, None)
+            .expect("unbounded implied planning cannot exhaust its budget")
+    }
+
+    fn supported_implied_specializations_with_budget(
+        &mut self,
+        names: &HashMap<String, Uuid>,
+        use_library_cache: bool,
+        mut steps: Option<&mut usize>,
+    ) -> Option<Arc<SupportedImpliedSpecializations>> {
+        self.refresh_supported_chain_evidence(steps.as_deref_mut())?;
+        if use_library_cache {
+            if let Some(plan) = &self.supported_implied {
+                if plan.library_configuration {
+                    return Some(Arc::clone(plan));
+                }
+            }
+        }
+        planning_charge(&mut steps, self.elements.len())?;
+        let mut requirement_candidates = Vec::new();
+        for (i, element) in self.elements.iter().enumerate() {
+            planning_charge(&mut steps, element.owned_relationships.len())?;
+            // All kind-based requirements belong to Types. Variant ownership
+            // is an independent recipe, so retain even a non-Type variant row.
+            // Collect during the already charged complete ownership scan.
+            if i < self.explicit_len()
+                && (conforms(element.ty, "Type")
+                    || element.owning_relationship.is_some_and(|membership| {
+                        self.elements
+                            .get(membership)
+                            .is_some_and(|row| row.ty == "VariantMembership")
+                    }))
+            {
+                requirement_candidates.push(i);
+            }
+        }
+        let owners = self.specialization_relation_owners();
+        let expression_targets = self.expression_target_names(names, &mut steps)?;
+        let mut candidates = Vec::new();
+        planning_charge(&mut steps, super::type_relations::COMPOSITE_ROLES.len())?;
+        let typing_structure = if self.graph_format == crate::model::GraphFormat::CanonicalV3
+            || super::type_relations::COMPOSITE_ROLES
+                .iter()
+                .any(|role| expression_targets.contains_key(role))
+        {
+            let mut local = 0;
+            let evidence = (|| {
+                let steps = steps.as_deref_mut().unwrap_or(&mut local);
+                let raw = super::structural_index::StoredStructure::for_query(self, steps)?;
+                let typing = raw.typing(self, steps)?;
+                Some((raw, typing))
+            })();
+            if evidence.is_none() && steps.is_some() {
+                return None;
+            }
+            evidence
+        } else {
+            None
+        };
+        if !names.is_empty() {
+            for i in requirement_candidates {
+                planning_charge(&mut steps, 1 + self.elements[i].owned_relationships.len())?;
+                let mut required =
+                    self.required_implied_plan(i, names, &expression_targets, &owners);
+                if let Some((raw, typing)) = &typing_structure {
+                    if conforms(self.elements[i].ty, "Feature")
+                        && (self.graph_format == crate::model::GraphFormat::CanonicalV3
+                            || self.elements[i]
+                                .props
+                                .get("isComposite")
+                                .and_then(|v| v.as_bool())
+                                == Some(true))
+                    {
+                        let typed = self.owned_typing_requirements(
+                            i,
+                            &expression_targets,
+                            raw,
+                            typing,
+                            &mut steps,
+                        )?;
+                        // The sequential minimizer always removes an earlier
+                        // exact duplicate while its later copy remains live.
+                        // Keep that last copy to preserve DFS visitation and
+                        // the order of surviving recipes, including cycles.
+                        if !typed.is_empty() {
+                            planning_charge(
+                                &mut steps,
+                                required.len().saturating_mul(typed.len()),
+                            )?;
+                            required.retain(|edge| !typed.contains(edge));
+                            required.extend(typed);
+                        }
+                    }
+                }
+                candidates.extend(required.into_iter().map(|edge| (i, edge)));
+            }
+        }
+        // This optional family uses a bounded certificate even on a legacy
+        // unbounded call. Failure publishes no partial endpoints.
+        let endpoints = if let Some(steps) = steps.as_deref_mut() {
+            super::succession_endpoints::endpoints(self, steps)?
+        } else {
+            super::succession_endpoints::endpoints(self, &mut 0).unwrap_or_default()
+        };
+        for (source, target) in endpoints {
+            candidates.push((
+                source,
+                (
+                    "ReferenceSubsetting",
+                    "subsettingFeature",
+                    "referencedFeature",
+                    self.elements[target].id,
+                ),
+            ));
+        }
+        let chain_bases = self.checked_chain_bases(self.explicit_len(), steps.as_deref_mut())?;
+        let (retained, graph) = self.required_specialization_edges_with_chain_bases(
+            &candidates,
+            0,
+            self.explicit_len(),
+            &owners,
+            &chain_bases,
+            steps.as_deref_mut(),
+        )?;
+        let mut by_owner: HashMap<usize, Vec<Uuid>> = HashMap::new();
+        for (i, &(owner, edge)) in candidates.iter().enumerate() {
+            planning_charge(&mut steps, 1)?;
+            if retained[i] {
+                by_owner.entry(owner).or_default().push(edge.3);
+            }
+        }
+        let plan = Arc::new(SupportedImpliedSpecializations {
+            candidates,
+            retained,
+            graph,
+            by_owner,
+            typing_by_owner: OnceLock::new(),
+            library_configuration: use_library_cache,
+            expression_targets,
+            chain_bases,
+            source_rows: std::sync::Mutex::new(self.elements.observe_revision()),
+            source_names: self.lib_qnames.observe_revision(),
+        });
+        // Name setters, ID changes, binding replay and model append invalidate
+        // this cache. External plans may be reused by read-only value proofs;
+        // other callers retain their explicit external-plan rebuild policy.
+        self.supported_implied = Some(Arc::clone(&plan));
+        Some(plan)
+    }
+
+    /// Typed metadata from the SAME retained plan used by inheritance and
+    /// materialization. This accessor neither adds nor independently eliminates
+    /// edges. Per-query adapters resolve and validate each relevant identity.
+    pub(super) fn retained_typing_edges(
+        &mut self,
+        steps: &mut usize,
+    ) -> Option<Arc<RetainedTypings>> {
+        if self.effective_dynamic_plan().is_some() {
+            return self.dynamic_typing_edges(steps);
+        }
+        // The existing cache-hit charge below covers these constant predicates.
+        // Only stale authority needs the charged shared revalidation path.
+        if !self.supported_chain_evidence_current() || !self.physical_static_authority_current() {
+            self.refresh_supported_chain_evidence(Some(&mut *steps))?;
+            self.certify_materialized_static_prefix(steps)?;
+        }
+        let library_configuration = self.external_implied_names.is_empty();
+        let plan = match self
+            .supported_implied
+            .as_ref()
+            .filter(|plan| plan.library_configuration == library_configuration)
+        {
+            Some(plan) => Arc::clone(plan),
+            None => {
+                planning_charge(
+                    &mut Some(&mut *steps),
+                    self.lib_qnames.len() + self.external_implied_names.len(),
+                )?;
+                let names = self
+                    .lib_qnames
+                    .iter()
+                    .map(|(id, segments)| (segments.join("::"), *id))
+                    .chain(
+                        self.external_implied_names
+                            .iter()
+                            .map(|(name, id)| (name.clone(), *id)),
+                    )
+                    .collect();
+                self.supported_implied_specializations_with_budget(
+                    &names,
+                    library_configuration,
+                    Some(&mut *steps),
+                )?
+            }
+        };
+        planning_charge(&mut Some(&mut *steps), 1)?;
+        if let Some(typing) = plan.typing_by_owner.get() {
+            return Some(Arc::clone(typing));
+        }
+        planning_charge(&mut Some(&mut *steps), plan.candidates.len())?;
+        let mut typing = RetainedTypings::new();
+        for (i, &(owner, edge)) in plan.candidates.iter().enumerate() {
+            if plan.retained[i]
+                && (conforms(edge.0, "FeatureTyping") || conforms(edge.0, "Subsetting"))
+            {
+                typing.entry(owner).or_default().push((edge.0, edge.3));
+            }
+        }
+        let _ = plan.typing_by_owner.set(Arc::new(typing));
+        Some(Arc::clone(plan.typing_by_owner.get().unwrap()))
+    }
+
+    /// Complete direct bases in the implemented semantic graph, independent
+    /// of lookup spelling and source scope. Conjugation replaces specialization
+    /// inheritance (KerML Type::supertypes); otherwise include exact owned
+    /// specializations, retained library/variation requirements and supported
+    /// positional redefinitions. Resolver-only bases are excluded.
+    /// Positional planning must already be stabilized by the caller's provider
+    /// proof; this reader never starts an unbudgeted global positional walk.
+    pub(super) fn value_context_bases(
+        &mut self,
+        element: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        self.semantic_inheritance_bases(element, true, steps)
+    }
+
+    /// Stored Type identities, including Types without a textual body scope.
+    pub(super) fn semantic_inheritance_bases(
+        &mut self,
+        element: usize,
+        include_implied: bool,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if include_implied
+            && (!self.dynamic_evidence_current(element)
+                || !self.result_redefinition_evidence_current(element))
+        {
+            return None;
+        }
+        let mut budget = Some(steps);
+        planning_charge(&mut budget, 1)?;
+        if include_implied {
+            self.refresh_supported_chain_evidence(budget.as_deref_mut())?;
+            self.certify_materialized_static_prefix(budget.as_deref_mut().unwrap())?;
+            if !self.static_chain_owner_current(element) {
+                return None;
+            }
+        }
+        let owner = self.elements.get(element)?;
+        if !conforms(owner.ty, "Type") {
+            return None;
+        }
+        planning_charge(&mut budget, owner.owned_relationships.len())?;
+        let relationships = owner.owned_relationships.clone();
+        let conjugations: Vec<_> = relationships
+            .iter()
+            .copied()
+            .filter(|&r| {
+                self.elements
+                    .get(r)
+                    .is_some_and(|e| conforms(e.ty, "Conjugation"))
+            })
+            .collect();
+        if self.id_index.is_none() || self.id_index_built_for != self.elements.len() {
+            planning_charge(&mut budget, self.elements.len())?;
+        }
+        if !conjugations.is_empty() {
+            if conjugations.len() != 1 {
+                return None;
+            }
+            let relation = self.elements.get(conjugations[0])?;
+            if let Some(source) = relation.props.get("conjugatedType") {
+                if source.as_reference()? != self.elements[element].id {
+                    return None;
+                }
+            }
+            let target = relation.props.get("originalType")?.as_reference()?;
+            let target = self.element_index_of_uuid(target)?;
+            return conforms(self.elements.get(target)?.ty, "Type").then_some(vec![target]);
+        }
+        let mut targets = Vec::new();
+        for relationship in relationships {
+            let relation = self.elements.get(relationship)?;
+            if !conforms(relation.ty, "Specialization")
+                || (!include_implied
+                    && relation.props.get("isImplied").and_then(|v| v.as_bool()) == Some(true))
+            {
+                continue;
+            }
+            for key in [
+                "specific",
+                "subclassifier",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ] {
+                if let Some(source) = relation.props.get(key) {
+                    if source.as_reference()? != self.elements[element].id {
+                        return None;
+                    }
+                }
+            }
+            let target = specialization_target(relation)?;
+            let target = self.element_index_of_uuid(target)?;
+            if !conforms(self.elements.get(target)?.ty, "Type") {
+                return None;
+            }
+            planning_charge(&mut budget, 1 + targets.len())?;
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        if !include_implied {
+            return Some(targets);
+        }
+        if let Some(plan) = self.effective_dynamic_plan() {
+            if plan.incomplete_bases.contains(&element) {
+                return None;
+            }
+            for &target in plan.direct_bases.get(&element).into_iter().flatten() {
+                planning_charge(&mut budget, 1 + targets.len())?;
+                if !conforms(self.elements.get(target)?.ty, "Type") {
+                    return None;
+                }
+                if !targets.contains(&target) {
+                    targets.push(target);
+                }
+            }
+            // Retain the existing parameter/end owner-completeness guard;
+            // an accepted unrelated Invocation does not certify every sequence.
+            self.completed_positional_targets(element)?;
+            return Some(targets);
+        }
+        self.refresh_supported_chain_evidence(budget.as_deref_mut())?;
+        let library_configuration = self.external_implied_names.is_empty();
+        let plan = match self
+            .supported_implied
+            .as_ref()
+            .filter(|plan| plan.library_configuration == library_configuration)
+        {
+            Some(plan) => Arc::clone(plan),
+            None => {
+                planning_charge(
+                    &mut budget,
+                    self.lib_qnames.len() + self.external_implied_names.len(),
+                )?;
+                let names = self
+                    .lib_qnames
+                    .iter()
+                    .map(|(id, segments)| (segments.join("::"), *id))
+                    .chain(
+                        self.external_implied_names
+                            .iter()
+                            .map(|(name, id)| (name.clone(), *id)),
+                    )
+                    .collect();
+                self.supported_implied_specializations_with_budget(
+                    &names,
+                    library_configuration,
+                    budget.as_deref_mut(),
+                )?
+            }
+        };
+        for &id in plan.by_owner.get(&element).into_iter().flatten() {
+            planning_charge(&mut budget, 1 + targets.len())?;
+            let target = self.element_index_of_uuid(id)?;
+            if !conforms(self.elements.get(target)?.ty, "Type") {
+                return None;
+            }
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        if plan.chain_bases.incomplete.contains(&element) {
+            return None;
+        }
+        if let Some(&target) = plan.chain_bases.targets.get(&element) {
+            planning_charge(&mut budget, 1 + targets.len())?;
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        let positional = self.is_parameter(element)
+            || self.elements[element]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true);
+        if positional && self.positional_redefinitions.is_none() {
+            return None;
+        }
+        for &target in self.completed_positional_targets(element)? {
+            planning_charge(&mut budget, 1 + targets.len())?;
+            if !conforms(self.elements.get(target)?.ty, "Type") {
+                return None;
+            }
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        Some(targets)
+    }
+
+    fn expression_target_names(
+        &mut self,
+        names: &HashMap<String, Uuid>,
+        budget: &mut Option<&mut usize>,
+    ) -> Option<HashMap<&'static str, Uuid>> {
+        // A canonical name does not disambiguate two loaded rows sharing one
+        // UUID. Refuse these roles rather than selecting a last-wins endpoint.
+        if !self.literal_identities_unique(budget.as_deref_mut())? {
+            return Some(HashMap::new());
+        }
+        // The general names map is an inversion. Preserve ambiguity before that
+        // inversion loses distinct declared identities for a required name.
+        planning_charge(budget, self.lib_qnames.len())?;
+        let mut loaded: HashMap<&'static str, Option<Uuid>> = HashMap::new();
+        for (id, segments) in &self.lib_qnames {
+            let composite = match segments.as_slice() {
+                [p, t, n] if p == "Occurrences" && t == "Occurrence" && n == "suboccurrences" => {
+                    Some("Occurrences::Occurrence::suboccurrences")
+                }
+                [p, t, n] if p == "Objects" && t == "Object" && n == "subobjects" => {
+                    Some("Objects::Object::subobjects")
+                }
+                [p, t, n] if p == "Items" && t == "Item" && n == "subitems" => {
+                    Some("Items::Item::subitems")
+                }
+                [p, t, n] if p == "Items" && t == "Item" && n == "subparts" => {
+                    Some("Items::Item::subparts")
+                }
+                _ => None,
+            };
+            let name = if let Some(name) = composite {
+                Some(name)
+            } else if let [package, member] = segments.as_slice() {
+                match (package.as_str(), member.as_str()) {
+                    ("Base", "things") => Some(FEATURE_BASE),
+                    ("Performances", "performances") => Some(STEP_BASE),
+                    (package, member) if binary_role_name(package, member).is_some() => {
+                        binary_role_name(package, member)
+                    }
+                    ("Base", "dataValues") => Some("Base::dataValues"),
+                    ("Objects", "objects") => Some("Objects::objects"),
+                    ("Occurrences", "occurrences") => Some("Occurrences::occurrences"),
+                    ("ControlFunctions", ".") => Some(CHAIN_FUNCTION),
+                    ("Constraints", "assertedConstraintChecks") => {
+                        Some(assertion_implied_base(false))
+                    }
+                    ("Constraints", "negatedConstraintChecks") => {
+                        Some(assertion_implied_base(true))
+                    }
+                    ("Requirements", "satisfiedRequirementChecks") => {
+                        Some(satisfaction_implied_base(false))
+                    }
+                    ("Requirements", "notSatisfiedRequirementChecks") => {
+                        Some(satisfaction_implied_base(true))
+                    }
+                    ("Performances", "literalBooleanEvaluations") => {
+                        literal_implied_base("LiteralBoolean")
+                    }
+                    ("Performances", "literalIntegerEvaluations") => {
+                        literal_implied_base("LiteralInteger")
+                    }
+                    ("Performances", "literalRationalEvaluations") => {
+                        literal_implied_base("LiteralRational")
+                    }
+                    ("Performances", "literalStringEvaluations") => {
+                        literal_implied_base("LiteralString")
+                    }
+                    ("Performances", "nullEvaluations") => literal_implied_base("NullExpression"),
+                    ("Performances", "metadataAccessEvaluations") => {
+                        literal_implied_base("MetadataAccessExpression")
+                    }
+                    ("Performances", "evaluations") => {
+                        expression_implied_base("InvocationExpression")
+                    }
+                    ("Performances", "constructorEvaluations") => {
+                        expression_implied_base("ConstructorExpression")
+                    }
+                    ("Performances", "booleanEvaluations") => {
+                        additional_expression_base("BooleanExpression")
+                    }
+                    ("Performances", "literalEvaluations") => {
+                        additional_expression_base("LiteralExpression")
+                    }
+                    ("Performances", "trueEvaluations") => Some(invariant_implied_base(false)),
+                    ("Performances", "falseEvaluations") => Some(invariant_implied_base(true)),
+                    _ => None,
+                }
+            } else {
+                None
+            };
+            if let Some(name) = name {
+                loaded
+                    .entry(name)
+                    .and_modify(|prior| {
+                        if *prior != Some(*id) {
+                            *prior = None;
+                        }
+                    })
+                    .or_insert(Some(*id));
+            }
+        }
+        if self.id_index.is_none() || self.id_index_built_for != self.elements.len() {
+            planning_charge(budget, self.elements.len())?;
+        }
+        let mut out = HashMap::new();
+        let fixed_names = [
+            "LiteralBoolean",
+            "LiteralInteger",
+            "LiteralRational",
+            "LiteralString",
+            "NullExpression",
+            "MetadataAccessExpression",
+            "InvocationExpression",
+            "ConstructorExpression",
+        ]
+        .into_iter()
+        .map(|ty| expression_implied_base(ty).expect("supported fixed-base expression kind"));
+        for name in fixed_names
+            .chain([
+                CHAIN_FUNCTION,
+                FEATURE_BASE,
+                STEP_BASE,
+                additional_expression_base("BooleanExpression").unwrap(),
+                additional_expression_base("LiteralExpression").unwrap(),
+                invariant_implied_base(false),
+                invariant_implied_base(true),
+                assertion_implied_base(false),
+                assertion_implied_base(true),
+                satisfaction_implied_base(false),
+                satisfaction_implied_base(true),
+                "Base::dataValues",
+                "Objects::objects",
+                "Occurrences::occurrences",
+            ])
+            .chain(super::type_relations::COMPOSITE_ROLES)
+            .chain(BINARY_ROLES.map(|(role, _)| role))
+        {
+            if loaded.get(name) == Some(&None) {
+                continue;
+            }
+            let Some(&id) = names.get(name) else {
+                continue;
+            };
+            let element = self.element_index_of_uuid(id);
+            // Operator, Feature and Step roles need a unique loaded kind witness;
+            // external names alone cannot certify their required heritage.
+            if (matches!(name, CHAIN_FUNCTION | FEATURE_BASE | STEP_BASE)
+                || BINARY_ROLES.iter().any(|(role, _)| *role == name)
+                || TYPED_FEATURE_BASES.iter().any(|(_, role)| *role == name)
+                || super::type_relations::COMPOSITE_ROLES.contains(&name))
+                && element.is_none()
+            {
+                continue;
+            }
+            if let Some(element) = element {
+                // Supplied external names cannot promote an arbitrary loaded
+                // user/library element into a canonical semantic library role.
+                if element >= self.lib_boundary
+                    || loaded.get(name) != Some(&Some(id))
+                    || !conforms(self.elements[element].ty, expression_role_kind(name))
+                {
+                    continue;
+                }
+            }
+            out.insert(name, id);
+        }
+        Some(out)
+    }
+
+    /// Check the existing UUID projection, including any materialized suffix.
+    /// Public identity changes clear that index; appended rows invalidate its
+    /// length. No semantic proof is retained here or in a separate cache.
+    pub(super) fn literal_identities_unique(
+        &mut self,
+        mut steps: Option<&mut usize>,
+    ) -> Option<bool> {
+        planning_charge(&mut steps, 1)?;
+        let Some(first) = self.elements.get(0).map(|element| element.id) else {
+            return Some(true);
+        };
+        if self.id_index.is_none() || self.id_index_built_for != self.elements.len() {
+            planning_charge(&mut steps, self.elements.len())?;
+        }
+        self.element_index_of_uuid(first);
+        Some(self.id_index.as_ref()?.len() == self.elements.len())
+    }
+
+    /// Required target identity from the same retained-plan configuration used
+    /// by semantic inheritance. Call after semantic_inheritance_bases has
+    /// ensured that plan; no name resolution or model-wide scan occurs here.
+    pub(super) fn planned_literal_target(&self, ty: &str) -> Option<Uuid> {
+        let name = literal_implied_base(ty)?;
+        self.supported_implied
+            .as_ref()?
+            .expression_targets
+            .get(name)
+            .copied()
+    }
+
+    /// Direct owned specialization targets for positional obligations. This
+    /// deliberately excludes name-lookup convenience heritage and standalone
+    /// specializations owned elsewhere. Retained implied requirements come from
+    /// exactly the same plan used by the materialized relationship view.
+    pub(super) fn positional_direct_bases(
+        &mut self,
+    ) -> (HashMap<usize, Vec<usize>>, HashSet<usize>) {
+        self.positional_direct_bases_with_budget(None)
+            .expect("unbounded base planning cannot exhaust")
+    }
+
+    pub(super) fn positional_direct_bases_with_budget(
+        &mut self,
+        mut steps: Option<&mut usize>,
+    ) -> Option<StaticPlannerBases> {
+        // Bounded proof preparation reuses the same retained authority already
+        // admitted by the report. Name setters invalidate it before reuse.
+        self.refresh_supported_chain_evidence(steps.as_deref_mut())?;
+        if steps.is_some() {
+            planning_charge(&mut steps, 1)?;
+            if let Some(plan) = self
+                .supported_implied
+                .as_ref()
+                .filter(|plan| plan.library_configuration == self.external_implied_names.is_empty())
+                .cloned()
+            {
+                return self.positional_direct_bases_from_static_plan(&plan, steps);
+            }
+        }
+        planning_charge(
+            &mut steps,
+            self.lib_qnames
+                .len()
+                .saturating_add(self.external_implied_names.capacity()),
+        )?;
+        for (_, segments) in &self.lib_qnames {
+            planning_charge(&mut steps, segments.len())?;
+            for segment in segments {
+                planning_charge(&mut steps, segment.len())?;
+            }
+        }
+        for name in self.external_implied_names.keys() {
+            planning_charge(&mut steps, name.len())?;
+        }
+        let names = self
+            .lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .chain(
+                self.external_implied_names
+                    .iter()
+                    .map(|(name, id)| (name.clone(), *id)),
+            )
+            .collect();
+        let plan = self.supported_implied_specializations_with_budget(
+            &names,
+            self.external_implied_names.is_empty(),
+            steps.as_deref_mut(),
+        )?;
+        self.positional_direct_bases_from_static_plan(&plan, steps)
+    }
+
+    fn positional_direct_bases_from_static_plan(
+        &self,
+        plan: &SupportedImpliedSpecializations,
+        mut steps: Option<&mut usize>,
+    ) -> Option<StaticPlannerBases> {
+        planning_charge(&mut steps, self.explicit_len())?;
+        let by_id: HashMap<_, _> = self
+            .elements
+            .iter()
+            .take(self.explicit_len())
+            .enumerate()
+            .map(|(i, element)| (element.id, i))
+            .collect();
+        let mut incomplete = HashSet::new();
+        let mut bases: HashMap<usize, Vec<usize>> = HashMap::new();
+        for (owner, element) in self.elements.iter().take(self.explicit_len()).enumerate() {
+            planning_charge(&mut steps, element.owned_relationships.len())?;
+            for &relationship in &element.owned_relationships {
+                let relation = &self.elements[relationship];
+                if conforms(relation.ty, "Specialization") {
+                    if let Some(target) =
+                        specialization_target(relation).and_then(|id| by_id.get(&id).copied())
+                    {
+                        let targets = bases.entry(owner).or_default();
+                        planning_charge(&mut steps, targets.len().saturating_add(1))?;
+                        if !targets.contains(&target) {
+                            targets.push(target);
+                        }
+                    }
+                }
+            }
+        }
+        for (index, &(owner, edge)) in plan.candidates.iter().enumerate() {
+            planning_charge(&mut steps, 1)?;
+            if plan.retained[index] {
+                if let Some(&target) = by_id.get(&edge.3) {
+                    let targets = bases.entry(owner).or_default();
+                    planning_charge(&mut steps, targets.len().saturating_add(1))?;
+                    if !targets.contains(&target) {
+                        targets.push(target);
+                    }
+                } else {
+                    // The required base exists only by external identity.
+                    // Its unknown member order cannot justify local pairing.
+                    incomplete.insert(owner);
+                }
+            }
+        }
+        planning_charge(&mut steps, plan.chain_bases.incomplete.len())?;
+        incomplete.extend(plan.chain_bases.incomplete.iter().copied());
+        for (&source, &target) in &plan.chain_bases.targets {
+            planning_charge(&mut steps, 1)?;
+            let targets = bases.entry(source).or_default();
+            planning_charge(&mut steps, targets.len().saturating_add(1))?;
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        Some((bases, incomplete))
+    }
+
+    /// Owned typing has three independent KerML specialization obligations.
+    /// The existential witnesses are exact owned FeatureTyping endpoints, not
+    /// inferred type projections. The same candidate minimizer and publisher
+    /// retain the required paths. Conditional composition requirements use the
+    /// same checked ownership in both graph formats; the unconditional owned
+    /// typing requirements remain specific to canonical graphs.
+    fn owned_typing_requirements(
+        &mut self,
+        feature: usize,
+        targets: &HashMap<&'static str, Uuid>,
+        raw: &super::structural_index::StoredStructure,
+        typing: &super::structural_index::StoredTyping,
+        budget: &mut Option<&mut usize>,
+    ) -> Option<Vec<PlannedEdge>> {
+        let Some(required) = self.owned_typing_kinds(feature, raw, typing, budget) else {
+            planning_charge(budget, 0)?;
+            return Some(Vec::new());
+        };
+        planning_charge(budget, 1)?;
+        let mut requirements = Vec::new();
+        if self.elements[feature]
+            .props
+            .get("isComposite")
+            .and_then(|v| v.as_bool())
+            == Some(true)
+        {
+            let mut local = 0;
+            let steps = budget.as_deref_mut().unwrap_or(&mut local);
+            // Reciprocal ordinary FeatureMemberships supply the owner. Feature
+            // owner conditions require positive owned typing witnesses here;
+            // checked reads separately certify the complete owner projection.
+            if let Some(membership) = self.elements[feature].owning_relationship {
+                if self.elements[membership].ty == "FeatureMembership" {
+                    if let Some(Some(owner)) =
+                        super::semantic_ownership::checked_relationship_carrier(
+                            self, raw, membership, steps,
+                        )
+                    {
+                        if super::membership_evidence::member(self, raw, owner, membership, steps)
+                            == Some(feature)
+                            && matches!(
+                                self.elements[owner].ty,
+                                "Type"
+                                    | "Classifier"
+                                    | "Class"
+                                    | "Structure"
+                                    | "DataType"
+                                    | "Definition"
+                                    | "AttributeDefinition"
+                                    | "OccurrenceDefinition"
+                                    | "ItemDefinition"
+                                    | "PartDefinition"
+                                    | "Feature"
+                                    | "OccurrenceUsage"
+                                    | "ItemUsage"
+                                    | "PartUsage"
+                            )
+                        {
+                            let owner_types = if conforms(self.elements[owner].ty, "Feature") {
+                                // A missing witness contributes no guessed owner
+                                // type. Metaclass-specific conditions remain
+                                // independent of these existential witnesses.
+                                let kinds = self
+                                    .owned_typing_kinds(owner, raw, typing, budget)
+                                    .unwrap_or([false; 3]);
+                                planning_charge(budget, 0)?;
+                                super::type_relations::CompositionOwner {
+                                    object: kinds[0],
+                                    occurrence: kinds[1],
+                                }
+                            } else {
+                                super::type_relations::CompositionOwner::default()
+                            };
+                            for role in super::type_relations::composite_roles(
+                                self.elements[feature].ty,
+                                self.elements[owner].ty,
+                                required[0],
+                                required[1],
+                                owner_types,
+                            ) {
+                                if let Some(&target) = targets.get(role) {
+                                    requirements.push((
+                                        "Subsetting",
+                                        "subsettingFeature",
+                                        "subsettedFeature",
+                                        target,
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            planning_charge(budget, 0)?;
+        }
+        if self.graph_format != crate::model::GraphFormat::CanonicalV3 {
+            return Some(requirements);
+        }
+        planning_charge(budget, TYPED_FEATURE_BASES.len())?;
+        for (needed, (_, role)) in required.into_iter().zip(TYPED_FEATURE_BASES) {
+            if needed {
+                if let Some(&target) = targets.get(role) {
+                    requirements.push((
+                        "Subsetting",
+                        "subsettingFeature",
+                        "subsettedFeature",
+                        target,
+                    ));
+                }
+            }
+        }
+        Some(requirements)
+    }
+
+    /// Positive owned-typing witnesses only. Inherited typing requires the
+    /// checked reader's complete projection and cannot invent a static edge.
+    fn owned_typing_kinds(
+        &mut self,
+        feature: usize,
+        raw: &super::structural_index::StoredStructure,
+        typing: &super::structural_index::StoredTyping,
+        budget: &mut Option<&mut usize>,
+    ) -> Option<[bool; 3]> {
+        planning_charge(budget, 1)?;
+        if raw.incomplete() || typing.sources_incomplete || raw.bad_bases.contains(&feature) {
+            return None;
+        }
+        let relationships = typing
+            .relationships
+            .get(&feature)
+            .map_or(&[][..], Vec::as_slice);
+        let mut required = [false; 3];
+        let mut local = 0;
+        for &relationship in relationships {
+            planning_charge(budget, 1)?;
+            // A dynamic suffix cannot become a new input to its immutable
+            // static prefix. Generated typings need their own producer proof.
+            if relationship >= self.explicit_len()
+                || !conforms(self.elements.get(relationship)?.ty, "FeatureTyping")
+            {
+                continue;
+            }
+            let steps = budget.as_deref_mut().unwrap_or(&mut local);
+            let carrier = super::semantic_ownership::checked_relationship_carrier(
+                self,
+                raw,
+                relationship,
+                steps,
+            );
+            let Some(carrier) = carrier else {
+                planning_charge(budget, 0)?;
+                return None;
+            };
+            if carrier != Some(feature) {
+                continue;
+            }
+            let target = super::type_relations::endpoint(
+                self,
+                feature,
+                relationship,
+                &["typedFeature", "specific"],
+                &["type", "general"],
+                "Type",
+                steps,
+            );
+            planning_charge(budget, 0)?;
+            let target = target?;
+            planning_charge(budget, TYPED_FEATURE_BASES.len())?;
+            for (needed, (kind, _)) in required.iter_mut().zip(TYPED_FEATURE_BASES) {
+                *needed |= conforms(self.elements[target].ty, kind);
+            }
+        }
+        Some(required)
+    }
+
+    pub(super) fn binary_owned_base(&self, owner: usize) -> Option<(&'static str, bool)> {
+        let ty = self.elements[owner].ty;
+        let role = if conforms(ty, "InterfaceDefinition") {
+            ("Interfaces::BinaryInterface", true)
+        } else if conforms(ty, "ConnectionDefinition") {
+            ("Connections::BinaryConnection", true)
+        } else if conforms(ty, "InterfaceUsage") {
+            ("Interfaces::binaryInterfaces", false)
+        } else if conforms(ty, "ConnectionUsage") {
+            ("Connections::binaryConnections", false)
+        } else {
+            return None;
+        };
+        (self
+            .owned_member_elems(owner, true)
+            .into_iter()
+            .filter(|&feature| {
+                self.elements[feature]
+                    .props
+                    .get("isEnd")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+            })
+            .count()
+            == 2)
+            .then_some(role)
+    }
+
+    /// Lookup must use the same canonical loaded binary role as the
+    /// specialization planner, never a user declaration or an inverted alias.
+    pub(super) fn binary_lookup_target(&mut self, target: usize, role: &str) -> bool {
+        if target >= self.lib_boundary
+            || !conforms(self.elements[target].ty, expression_role_kind(role))
+            || self.literal_identities_unique(None) != Some(true)
+        {
+            return false;
+        }
+        let id = self.elements[target].id;
+        let mut found = false;
+        for (candidate, parts) in &self.lib_qnames {
+            if let [package, member] = parts.as_slice() {
+                if binary_role_name(package, member) == Some(role) {
+                    if *candidate != id {
+                        return false;
+                    }
+                    found = true;
+                }
+            }
+        }
+        found
+    }
+
+    /// Plan the semantic requirements before minimizing edges. Considering
+    /// all requirements together lets an explicit path through another user
+    /// element reach that element's required base, independent of source order.
+    fn required_implied_plan(
+        &self,
+        i: usize,
+        names: &HashMap<String, Uuid>,
+        expression_targets: &HashMap<&'static str, Uuid>,
+        rel_owner: &[Option<usize>],
+    ) -> Vec<PlannedEdge> {
+        let ty = self.elements[i].ty;
+        let mut out = Vec::new();
+        if let Some(kind) = def_kind_of(ty) {
+            for name in implicit_def_bases(kind) {
+                if let Some(&id) = names.get(*name) {
+                    out.push(("Subclassification", "subclassifier", "superclassifier", id));
+                }
+            }
+        } else if let Some(kind) =
+            usage_kind_of(ty, Dialect::Sysml).filter(|_| !matches!(ty, "Flow" | "SuccessionFlow"))
+        {
+            for name in implicit_usage_bases(kind) {
+                if let Some(&id) = names.get(*name) {
+                    out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+                }
+            }
+        }
+        // Kernel Flow and Succession are not SysML usages. Their syntax
+        // kinds overlap in the lifting API, but their semantic bases do not.
+        // Flow's more specific base is conditional on owning ends; assigning
+        // it to every flow also makes the library's own hierarchy cyclic.
+        let owns_end = conforms(ty, "Flow")
+            && self.owned_member_elems(i, true).into_iter().any(|feature| {
+                self.elements[feature]
+                    .props
+                    .get("isEnd")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+            });
+        let mut feature_bases = Vec::new();
+        if conforms(ty, "Step") {
+            if let Some(&id) = expression_targets.get(STEP_BASE) {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        if conforms(ty, "Flow") {
+            feature_bases.push("Transfers::transfers");
+            if owns_end {
+                feature_bases.push("Transfers::flowTransfers");
+            }
+        }
+        if conforms(ty, "FlowUsage") && owns_end {
+            feature_bases.push("Flows::flows");
+        }
+        if conforms(ty, "SuccessionFlow") {
+            feature_bases.push("Transfers::flowTransfersBefore");
+        }
+        if conforms(ty, "Succession") {
+            feature_bases.push("Occurrences::happensBeforeLinks");
+        }
+        for base in feature_bases {
+            if let Some(&id) = names.get(base) {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        if ty == "FeatureChainExpression"
+            && self.elements[i]
+                .props
+                .get("operator")
+                .is_none_or(|v| v.as_str() == Some("."))
+        {
+            if let Some(&id) = expression_targets.get(CHAIN_FUNCTION) {
+                out.push(("FeatureTyping", "typedFeature", "type", id));
+            }
+        }
+        if let Some(name) = expression_implied_base(ty) {
+            if let Some(&id) = expression_targets.get(name) {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        if let Some(name) = additional_expression_base(ty) {
+            if let Some(&id) = expression_targets.get(name) {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        // A narrower canonical role may be unavailable in a partial library.
+        // Accumulate the independent Expression requirement before minimizing;
+        // an available leaf/Constructor role is not evidence of its ancestry.
+        if conforms(ty, "Expression")
+            && expression_implied_base(ty) != Some("Performances::evaluations")
+        {
+            if let Some(&id) = expression_targets.get("Performances::evaluations") {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        if conforms(ty, "Invariant") {
+            if let Some(negated) = invariant_negation(&self.elements[i]) {
+                if let Some(&id) = expression_targets.get(invariant_implied_base(negated)) {
+                    out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+                }
+                for (kind, name) in [
+                    ("AssertConstraintUsage", assertion_implied_base(negated)),
+                    (
+                        "SatisfyRequirementUsage",
+                        satisfaction_implied_base(negated),
+                    ),
+                ] {
+                    if conforms(ty, kind) {
+                        if let Some(&id) = expression_targets.get(name) {
+                            out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+                        }
+                    }
+                }
+            }
+        }
+        // These SysML rules explicitly count owned ends. The corresponding
+        // KerML binary rules count effective ends and need a separate analysis;
+        // an owned-end count must not stand in for that inherited cardinality.
+        if let Some((base, definition)) = self.binary_owned_base(i) {
+            if let Some(&target) = expression_targets.get(base) {
+                out.push(if definition {
+                    (
+                        "Subclassification",
+                        "subclassifier",
+                        "superclassifier",
+                        target,
+                    )
+                } else {
+                    (
+                        "Subsetting",
+                        "subsettingFeature",
+                        "subsettedFeature",
+                        target,
+                    )
+                });
+            }
+        }
+        if let Some(rel) = self.elements[i].owning_relationship {
+            if self.elements[rel].ty == "VariantMembership" {
+                if let Some(variation) = rel_owner[rel] {
+                    let vty = self.elements[variation].ty;
+                    let id = self.elements[variation].id;
+                    if conforms(vty, "Definition") {
+                        out.push(("FeatureTyping", "typedFeature", "type", id));
+                    } else if conforms(vty, "Usage") {
+                        out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+                    }
+                }
+            }
+        }
+        // Append the inherited generic obligation independently of narrower
+        // roles, then let the shared minimizer preserve only necessary edges.
+        if conforms(ty, "Feature") {
+            if let Some(&id) = expression_targets.get(FEATURE_BASE) {
+                out.push(("Subsetting", "subsettingFeature", "subsettedFeature", id));
+            }
+        }
+        out
+    }
+
+    /// Remove a candidate only while another specialization path still
+    /// satisfies it. Starting with all candidates and removing sequentially
+    /// preserves reachability even in explicit cycles: the last necessary
+    /// anchor cannot disappear. Testing every candidate against an independent
+    /// hypothetical graph could incorrectly remove every anchor in a cycle.
+    fn required_specialization_edges(
+        &mut self,
+        candidates: &[(usize, PlannedEdge)],
+        explicit_len: usize,
+        rel_owner: &[Option<usize>],
+    ) -> (Vec<bool>, SpecializationGraph) {
+        self.required_specialization_edges_with_budget(candidates, explicit_len, rel_owner, None)
+            .expect("unbounded implied planning cannot exhaust its budget")
+    }
+
+    fn required_specialization_edges_with_budget(
+        &mut self,
+        candidates: &[(usize, PlannedEdge)],
+        explicit_len: usize,
+        rel_owner: &[Option<usize>],
+        steps: Option<&mut usize>,
+    ) -> Option<(Vec<bool>, SpecializationGraph)> {
+        self.required_specialization_edges_with_fixed_prefix(
+            candidates,
+            0,
+            explicit_len,
+            rel_owner,
+            steps,
+        )
+    }
+}
+
+impl ResolvedModel {
+    /// Materialize the implied relationships on first demand.
+    pub(super) fn ensure_implied(&mut self) {
+        let status = self.b.ensure_semantic_graph();
+        assert_eq!(
+            status,
+            super::publication::Status::Ready,
+            "materialization demand requires a resolved query model"
+        );
+        self.sync_semantic_publication();
+        self.ensure_by_id();
+        self.ensure_rel_owner();
+    }
+
+    /// References and IDs can be patched after lazy materialization. Rebuild
+    /// only the reachability index; existing implied elements and IDs stay put.
+    pub(super) fn refresh_implied_specializations(&mut self) {
+        self.b.refresh_materialized_specializations();
+    }
+
+    /// Whether `e` reaches `ancestor` through known explicit specializations,
+    /// materialized implied library/variation specializations, or semantic
+    /// metadata bases. Unlike [`Self::conforms`], this includes library heritage
+    /// and lazily materializes the supported implied relationship families.
+    /// This is a graph reachability query, not a complete implementation of
+    /// KerML Type::specializes: other implied relationship families remain
+    /// incomplete, so a negative answer does not establish non-conformance.
+    pub fn conforms_with_implied(&mut self, e: ElementRef, ancestor: ElementRef) -> bool {
+        self.ensure_implied();
+        self.ensure_by_id();
+        let mut steps = 0;
+        if self
+            .b
+            .refresh_supported_chain_evidence(Some(&mut steps))
+            .is_none()
+            || self.b.certify_materialized_static_prefix(&mut steps) != Some(true)
+        {
+            return false;
+        }
+        let target = self.b.elements[ancestor.0].id;
+        let mut stack = vec![self.b.elements[e.0].id];
+        let mut seen = HashSet::new();
+        while let Some(at) = stack.pop() {
+            if at == target {
+                return true;
+            }
+            if !seen.insert(at) {
+                continue;
+            }
+            stack.extend(
+                self.b
+                    .implied
+                    .as_ref()
+                    .unwrap()
+                    .specializations
+                    .get(&at)
+                    .into_iter()
+                    .flatten()
+                    .copied(),
+            );
+            if let Some(&element) = self.by_id.get(&at) {
+                stack.extend(
+                    self.b
+                        .semantic_base_targets(element, 0)
+                        .into_iter()
+                        .map(|e| self.b.elements[e].id),
+                );
+            }
+        }
+        false
+    }
+
+    /// The implied relationships `e` owns — the library specializations
+    /// of its kind (SysML Tables 31/32), a variant's specialization of
+    /// its variation, and supported positional redefinitions — as relationship
+    /// elements of the model, in emission order. Materialized for the whole
+    /// model on first call (see the module documentation). Positional
+    /// redefinitions between local elements do not require a loaded library.
+    pub fn implied_relationships(&mut self, e: ElementRef) -> Vec<ElementRef> {
+        self.ensure_implied();
+        self.projected_owned_relationships(e)
+            .into_iter()
+            .filter(|&relationship| self.is_implied(relationship))
+            .collect()
+    }
+
+    /// `Element::ownedRelationship` with the implied relationships
+    /// included, as the specification lists them: the explicit ones in
+    /// declaration order, then the implied ones.
+    pub(super) fn d_owned_relationships(&mut self, e: ElementRef) -> Vec<ElementRef> {
+        self.ensure_implied();
+        self.projected_owned_relationships(e)
+    }
+
+    /// Whether `e` is a materialized implied relationship.
+    pub fn is_implied(&self, e: ElementRef) -> bool {
+        self.b
+            .semantic_ownership
+            .as_ref()
+            .is_some_and(|view| view.contains(e.0))
+            && conforms(self.b.elements[e.0].ty, "Relationship")
+    }
+}
+
+#[cfg(test)]
+mod value_context_tests {
+    use super::*;
+    use crate::model::Model;
+
+    fn model() -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_library_source(
+            "parts.sysml",
+            "standard library package Parts { part def Part; part def Alternate; part parts; }",
+        );
+        model.add_source(
+            "user.sysml",
+            "part def Base; part def Child :> Base; part def Missing :> absent;",
+        );
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn owned_and_retained_implied_targets_use_one_configuration() {
+        let mut r = model();
+        let base = r.resolve_qualified("Base").unwrap().0;
+        let child = r.resolve_qualified("Child").unwrap().0;
+        let standard = r.resolve_qualified("Parts::Part").unwrap().0;
+        assert_eq!(r.b.value_context_bases(base, &mut 0), Some(vec![standard]));
+        assert_eq!(r.b.value_context_bases(child, &mut 0), Some(vec![base]));
+        let plan = Arc::clone(r.b.supported_implied.as_ref().unwrap());
+        let mut steps = 0;
+        assert_eq!(
+            r.b.value_context_bases(base, &mut steps),
+            Some(vec![standard])
+        );
+        assert!(
+            steps < 20,
+            "warm proof should inspect only this owner: {steps}"
+        );
+        assert!(Arc::ptr_eq(&plan, r.b.supported_implied.as_ref().unwrap()));
+        let alternate = r.resolve_qualified("Parts::Alternate").unwrap();
+        r.set_library_names(&HashMap::from([(
+            r.element_id(alternate).to_string(),
+            vec!["Parts".into(), "Part".into()],
+        )]));
+        assert_eq!(
+            r.b.value_context_bases(base, &mut 0),
+            Some(vec![alternate.0])
+        );
+        let external_plan = Arc::clone(r.b.supported_implied.as_ref().unwrap());
+        assert_eq!(
+            r.b.value_context_bases(base, &mut 0),
+            Some(vec![alternate.0])
+        );
+        assert!(Arc::ptr_eq(
+            &external_plan,
+            r.b.supported_implied.as_ref().unwrap()
+        ));
+        r.set_library_names(&HashMap::from([(
+            "12340000-0000-4000-8000-000000000004".into(),
+            vec!["Parts".into(), "Part".into()],
+        )]));
+        assert_eq!(r.b.value_context_bases(base, &mut 0), None);
+    }
+
+    #[test]
+    fn unresolved_targets_and_exhausted_plans_are_not_empty_bases() {
+        let mut r = model();
+        let missing = r.resolve_qualified("Missing").unwrap().0;
+        assert_eq!(r.b.value_context_bases(missing, &mut 0), None);
+        let base = r.resolve_qualified("Base").unwrap().0;
+        r.b.supported_implied = None;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(r.b.value_context_bases(base, &mut exhausted), None);
+        assert!(r.b.supported_implied.is_none());
+        let names =
+            r.b.lib_qnames
+                .iter()
+                .map(|(id, name)| (name.join("::"), *id))
+                .collect();
+        let mut budget = crate::eval::MAX_STEPS - 2;
+        assert!(
+            r.b.supported_implied_specializations_with_budget(&names, true, Some(&mut budget))
+                .is_none()
+        );
+        assert!(
+            r.b.supported_implied.is_none(),
+            "never cache an interrupted plan"
+        );
+        assert!(r.b.value_context_bases(base, &mut 0).is_some());
+    }
+
+    #[test]
+    fn same_name_lookup_convenience_is_not_a_semantic_base() {
+        // A parameter's own name is no implied base of its scope (it used
+        // to be, reaching a same-named feature); the semantic bases of a
+        // parameter nothing redefines by position are none either way when
+        // the unconditional Kernel library base is not loaded.
+        let mut model = Model::new();
+        model.add_source("names.kerml", "feature p; function F { in p; }");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let p = r.resolve_qualified("F::p").unwrap().0;
+        let scope = *r.b.elem_scope.get(&p).unwrap();
+        assert_eq!(
+            r.b.scopes[scope].implied_bases,
+            [crate::json::lib_qn("Base::things")]
+        );
+        r.b.ensure_positional_redefinitions();
+        assert_eq!(r.b.value_context_bases(p, &mut 0), Some(vec![]));
+    }
+
+    #[test]
+    fn conjugation_replaces_specializations_and_must_be_unique() {
+        let mut model = Model::new();
+        model.add_source(
+            "conjugation.kerml",
+            "classifier A; classifier B; classifier X conjugates A; classifier Y specializes B;",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("X").unwrap().0;
+        let a = r.resolve_qualified("A").unwrap().0;
+        // Exercise Type::supertypes' conjugated branch even when a malformed
+        // graph also records a specialization (forbidden by
+        // validateSpecificationSpecificNotConjugated).
+        let y = r.resolve_qualified("Y").unwrap().0;
+        let specialization = *r.b.elements[y]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| conforms(r.b.elements[rel].ty, "Specialization"))
+            .unwrap();
+        r.b.elements[x].owned_relationships.push(specialization);
+        assert_eq!(r.b.value_context_bases(x, &mut 0), Some(vec![a]));
+        let relation = *r.b.elements[x]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| conforms(r.b.elements[rel].ty, "Conjugation"))
+            .unwrap();
+        r.b.elements[x].owned_relationships.push(relation);
+        assert_eq!(r.b.value_context_bases(x, &mut 0), None);
+        r.b.elements[x].owned_relationships.make_mut().pop();
+        r.b.elements[relation]
+            .props
+            .insert("originalType", serde_json::Value::Null);
+        assert_eq!(r.b.value_context_bases(x, &mut 0), None);
+    }
+}
+
+#[cfg(test)]
+mod invocation_static_tests {
+    use super::*;
+    use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; expr other:Evaluation subsets performances;}";
+    const USER: &str = "function F {return r;} feature decoy:F; feature call=F(); class C;";
+    fn models() -> Vec<ResolvedModel> {
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("evaluation-bases.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(73).unwrap(), 73).unwrap());
+        (0..4)
+            .map(|mode| {
+                let mut m = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                    _ => {
+                        m.add_library_source("evaluation-bases.kerml", LIB);
+                        if mode == 1 {
+                            m.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                assert!(
+                    m.add_source("invocation-static.kerml", USER)
+                        .diagnostics
+                        .is_empty()
+                );
+                ResolvedModel::build(&m)
+            })
+            .collect()
+    }
+    fn invocation(r: &ResolvedModel) -> usize {
+        r.b.elements
+            .iter()
+            .position(|e| e.ty == "InvocationExpression")
+            .unwrap()
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .collect()
+    }
+    #[test]
+    fn static_evaluation_requirement_replays_and_preserves_legacy_ids() {
+        let mut expected = None;
+        for mut r in models() {
+            let expression = invocation(&r);
+            let target = r.resolve_qualified("Performances::evaluations").unwrap();
+            let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            let library = names(&r);
+            let class = r.resolve_qualified("C").unwrap();
+            let legacy = r.b.legacy_implied_plan_with_owners(
+                class.0,
+                &library,
+                &r.b.semantic_relationship_owners(),
+            );
+            assert!(
+                !legacy.is_empty(),
+                "legacy Class requirement control must be active"
+            );
+            let rows = r.implied_relationships(ElementRef(expression));
+            let evaluations: Vec<_> = rows
+                .iter()
+                .filter(|rel| {
+                    r.b.elements[rel.0].ty == "Subsetting"
+                        && specialization_target(&r.b.elements[rel.0]) == Some(r.element_id(target))
+                })
+                .copied()
+                .collect();
+            assert_eq!(evaluations.len(), 1);
+            let callee = r.resolve_qualified("F").unwrap();
+            let callee_typings: Vec<_> = rows
+                .iter()
+                .filter(|rel| r.b.elements[rel.0].ty == "FeatureTyping")
+                .map(|rel| specialization_target(&r.b.elements[rel.0]))
+                .collect();
+            assert_eq!(callee_typings, vec![Some(r.element_id(callee))]);
+            assert!(
+                r.b.planned_literal_target("InvocationExpression").is_none(),
+                "generic base must not activate the literal result provider"
+            );
+            let id = r.element_id(evaluations[0]);
+            if let Some(expected) = expected {
+                assert_eq!(id, expected);
+            } else {
+                expected = Some(id);
+            }
+            let mut checked_legacy = 0;
+            for rel in r.implied_relationships(class) {
+                let row = &r.b.elements[rel.0];
+                if let Some(slot) = legacy
+                    .iter()
+                    .position(|edge| edge.0 == row.ty && Some(edge.3) == specialization_target(row))
+                {
+                    checked_legacy += 1;
+                    let key = format!("{}/implied{slot}", r.element_id(class));
+                    assert_eq!(row.id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+                }
+            }
+            assert!(checked_legacy > 0);
+            assert_eq!(
+                before,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+    #[test]
+    fn unavailable_library_does_not_invent_evaluation_identity() {
+        let mut m = Model::new();
+        assert!(
+            m.add_source("invocation-static.kerml", USER)
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&m);
+        let expression = invocation(&r);
+        let callee = r.resolve_qualified("F").unwrap();
+        let rows = r.implied_relationships(ElementRef(expression));
+        assert_eq!(rows.len(), 1);
+        assert_eq!(r.b.elements[rows[0].0].ty, "FeatureTyping");
+        assert_eq!(
+            specialization_target(&r.b.elements[rows[0].0]),
+            Some(r.element_id(callee))
+        );
+        assert!(r.b.planned_literal_target("InvocationExpression").is_none());
+    }
+    #[test]
+    fn loaded_user_feature_cannot_be_relabelled_as_evaluations() {
+        for mut r in models() {
+            let expression = invocation(&r);
+            let decoy = r.resolve_qualified("decoy").unwrap();
+            let fake =
+                HashMap::from([("Performances::evaluations".to_owned(), r.element_id(decoy))]);
+            let plan = r.b.supported_implied_specializations(&fake, false);
+            assert!(
+                !plan
+                    .candidates
+                    .iter()
+                    .any(|(owner, _)| *owner == expression)
+            );
+        }
+    }
+    #[test]
+    fn ambiguous_loaded_role_and_duplicate_uuid_cannot_supply_evaluation_base() {
+        for duplicate_uuid in [false, true] {
+            let mut r = models().remove(0);
+            let expression = invocation(&r);
+            let target = r.resolve_qualified("Performances::evaluations").unwrap();
+            let other = r.resolve_qualified("Performances::other").unwrap();
+            if duplicate_uuid {
+                r.b.elements[other.0].id = r.element_id(target);
+            } else {
+                let other_id = r.element_id(other);
+                r.b.lib_qnames
+                    .push((other_id, vec!["Performances".into(), "evaluations".into()]));
+            }
+            r.b.id_index = None;
+            r.b.supported_implied = None;
+            let configuration = names(&r);
+            let plan = r.b.supported_implied_specializations(&configuration, true);
+            let actual: Vec<_> = plan
+                .candidates
+                .iter()
+                .filter_map(|(owner, edge)| (*owner == expression).then_some(edge.3))
+                .collect();
+            // Losing the Expression role does not remove the independent
+            // Step and Feature requirements. Duplicate identity still makes
+            // every specialization candidate unusable.
+            assert_eq!(
+                actual,
+                if duplicate_uuid {
+                    vec![]
+                } else {
+                    vec![
+                        configuration["Performances::performances"],
+                        configuration["Base::things"],
+                    ]
+                }
+            );
+        }
+    }
+}
+
+// Result-family state retained independently of legacy static rows.
+
+/// Lazy state for the new family, separate from legacy implied rows.
+/// A work-limited attempt retries only after binding invalidates this state.
+/// Attempted is NOT a conformance claim: only view.result(e) proves an admitted
+/// subtree. Unknown/malformed/colliding expressions have no positive entry.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum OwnedResultState {
+    Pending,
+    Attempted,
+    WorkLimited,
+}
+
+impl ResolvedModel {
+    /// Invalidate only new generated-result handles before binding replay.
+    /// Called before the binder captures n or iterates properties. Source and
+    /// old generic implied indices remain stable. An empty previous tail is
+    /// also reset so newly resolved referents can gain a result.
+    pub(super) fn discard_owned_result_tail(&mut self) {
+        self.b.discard_semantic_result_tail();
+        self.sync_semantic_publication();
+    }
+    /// A result ownership change can affect semantic readers even when source
+    /// rows are untouched. Discard completed proofs rather than reusing an
+    /// earlier empty projection. Catalog-only plans are unaffected.
+    /// Observation only: never introduces a materialization demand. Current
+    /// callers publish outside memo computations; future demand expansion must
+    /// also guard in-flight computation results against generation changes.
+    pub(crate) fn sync_semantic_publication(&mut self) {
+        let current = self.b.publication.revision();
+        if self.semantic_publication_seen.same_as(&current) {
+            return;
+        }
+        self.semantic_publication_seen = current;
+        self.rel_owner.clear();
+        self.rel_member.clear();
+        self.by_id.clear();
+        self.by_id_built_for = usize::MAX;
+        self.quantity_index = None;
+        self.name_memo.clear();
+        self.redefiner_index = None;
+        self.import_truncated.clear();
+    }
+
+    /// Positive evidence only. Missing, malformed, colliding and work-limited
+    /// cases are all incomplete for checked owned-result composition reads.
+    pub(super) fn owned_result_projection_ready(&mut self, e: ElementRef) -> bool {
+        self.ensure_implied();
+        let locally_reciprocal = self.b.semantic_ownership.as_ref().is_some_and(|view| {
+            view.matches_suffix(&self.b)
+                && view.result(e.0).is_some_and(|result| {
+                    view.generated_relationship_owner(result.membership) == Some(e.0)
+                        && self
+                            .b
+                            .elements
+                            .get(result.membership)
+                            .is_some_and(|membership| {
+                                conforms(membership.ty, "ReturnParameterMembership")
+                                    && *membership.children == [result.feature]
+                            })
+                        && self.b.elements.get(result.feature).is_some_and(|feature| {
+                            conforms(feature.ty, "Feature")
+                                && feature.owning_relationship == Some(result.membership)
+                        })
+                })
+        });
+        locally_reciprocal && self.b.literal_identities_unique(None) == Some(true)
+    }
+}
+#[cfg(test)]
+mod retained_typing_cache_tests {
+    use super::*;
+    use crate::model::Model;
+    #[test]
+    fn retained_typing_metadata_is_lazy_and_failed_attempt_can_retry() {
+        let mut model = Model::new();
+        assert!(model.add_library_source("typing-lib.kerml", "standard library package Occurrences {class Occurrence;} standard library package Performances {expr evaluations;}").diagnostics.is_empty());
+        assert!(
+            model
+                .add_source("typing-user.kerml", "class C; function F; feature x=F();")
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let names =
+            r.b.lib_qnames
+                .iter()
+                .map(|(id, parts)| (parts.join("::"), *id))
+                .collect();
+        let plan = r.b.supported_implied_specializations(&names, true);
+        assert!(!plan.candidates.is_empty());
+        assert!(plan.typing_by_owner.get().is_none());
+        let mut exhausted = crate::eval::MAX_STEPS - 1;
+        assert!(r.b.retained_typing_edges(&mut exhausted).is_none());
+        assert!(plan.typing_by_owner.get().is_none());
+        let mut cold = 0;
+        let typing = r.b.retained_typing_edges(&mut cold).unwrap();
+        assert!(cold > 1);
+        let mut warm = 0;
+        let again = r.b.retained_typing_edges(&mut warm).unwrap();
+        assert!(Arc::ptr_eq(&typing, &again));
+        assert_eq!(warm, 1);
+        assert!(Arc::ptr_eq(&plan, r.b.supported_implied.as_ref().unwrap()));
+    }
+}
+
+#[cfg(test)]
+mod constructor_static_tests {
+    use super::*;
+    use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; expr constructorEvaluations subsets evaluations { return result [1]; } expr other:Evaluation subsets performances;}";
+    const USER: &str = "class F {feature item;} feature decoy:F; feature call=new F(); feature nonempty=new F(item=1); class C;";
+    fn models() -> Vec<ResolvedModel> {
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("evaluation-bases.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(73).unwrap(), 73).unwrap());
+        (0..4)
+            .map(|mode| {
+                let mut m = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                    _ => {
+                        m.add_library_source("evaluation-bases.kerml", LIB);
+                        if mode == 1 {
+                            m.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                assert!(
+                    m.add_source("constructor-static.kerml", USER)
+                        .diagnostics
+                        .is_empty()
+                );
+                ResolvedModel::build(&m)
+            })
+            .collect()
+    }
+    fn constructor(r: &ResolvedModel) -> usize {
+        r.b.elements
+            .iter()
+            .position(|e| e.ty == "ConstructorExpression")
+            .unwrap()
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .collect()
+    }
+    #[test]
+    fn static_evaluation_requirement_replays_and_preserves_legacy_ids() {
+        let mut expected = None;
+        for mut r in models() {
+            let expression = constructor(&r);
+            let target = r
+                .resolve_qualified("Performances::constructorEvaluations")
+                .unwrap();
+            let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            let library = names(&r);
+            let class = r.resolve_qualified("C").unwrap();
+            let legacy = r.b.legacy_implied_plan_with_owners(
+                class.0,
+                &library,
+                &r.b.semantic_relationship_owners(),
+            );
+            assert!(
+                !legacy.is_empty(),
+                "legacy Class requirement control must be active"
+            );
+            let rows = r.implied_relationships(ElementRef(expression));
+            let evaluations: Vec<_> = rows
+                .iter()
+                .filter(|rel| {
+                    r.b.elements[rel.0].ty == "Subsetting"
+                        && specialization_target(&r.b.elements[rel.0]) == Some(r.element_id(target))
+                })
+                .copied()
+                .collect();
+            assert_eq!(evaluations.len(), 1);
+            assert!(
+                !rows
+                    .iter()
+                    .any(|rel| r.b.elements[rel.0].ty == "FeatureTyping"),
+                "no dynamic callee typing is introduced"
+            );
+            assert!(
+                r.b.planned_literal_target("ConstructorExpression")
+                    .is_none(),
+                "generic base must not activate the literal result provider"
+            );
+            assert!(
+                r.b.semantic_ownership
+                    .as_ref()
+                    .unwrap()
+                    .result(expression)
+                    .is_none()
+            );
+            assert!(matches!(
+                r.model_level_evaluability(ElementRef(expression))
+                    .classification,
+                crate::json::ModelLevelEvaluability::Unknown(_)
+            ));
+            let id = r.element_id(evaluations[0]);
+            let key = format!(
+                "{}/implied/Subsetting/{}",
+                r.element_id(ElementRef(expression)),
+                r.element_id(target)
+            );
+            assert_eq!(id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+            if let Some(expected) = expected {
+                assert_eq!(id, expected);
+            } else {
+                expected = Some(id);
+            }
+            let mut checked_legacy = 0;
+            for rel in r.implied_relationships(class) {
+                let row = &r.b.elements[rel.0];
+                if let Some(slot) = legacy
+                    .iter()
+                    .position(|edge| edge.0 == row.ty && Some(edge.3) == specialization_target(row))
+                {
+                    checked_legacy += 1;
+                    let key = format!("{}/implied{slot}", r.element_id(class));
+                    assert_eq!(row.id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+                }
+            }
+            assert!(checked_legacy > 0);
+            assert_eq!(
+                before,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+    #[test]
+    fn unavailable_library_does_not_invent_evaluation_identity() {
+        let mut m = Model::new();
+        assert!(
+            m.add_source("constructor-static.kerml", USER)
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&m);
+        let expression = constructor(&r);
+        assert!(r.implied_relationships(ElementRef(expression)).is_empty());
+    }
+    #[test]
+    fn loaded_user_feature_cannot_be_relabelled_as_evaluations() {
+        for mut r in models() {
+            let expression = constructor(&r);
+            let decoy = r.resolve_qualified("decoy").unwrap();
+            let fake = HashMap::from([(
+                "Performances::constructorEvaluations".to_owned(),
+                r.element_id(decoy),
+            )]);
+            let plan = r.b.supported_implied_specializations(&fake, false);
+            assert!(
+                !plan
+                    .candidates
+                    .iter()
+                    .any(|(owner, _)| *owner == expression)
+            );
+        }
+    }
+    #[test]
+    fn ambiguous_loaded_role_and_duplicate_uuid_cannot_supply_evaluation_base() {
+        for duplicate_uuid in [false, true] {
+            let mut r = models().remove(0);
+            let expression = constructor(&r);
+            let target = r
+                .resolve_qualified("Performances::constructorEvaluations")
+                .unwrap();
+            let other = r.resolve_qualified("Performances::other").unwrap();
+            if duplicate_uuid {
+                r.b.elements[other.0].id = r.element_id(target);
+            } else {
+                let other_id = r.element_id(other);
+                r.b.lib_qnames.push((
+                    other_id,
+                    vec!["Performances".into(), "constructorEvaluations".into()],
+                ));
+            }
+            r.b.id_index = None;
+            r.b.supported_implied = None;
+            let configuration = names(&r);
+            let plan = r.b.supported_implied_specializations(&configuration, true);
+            let actual: Vec<_> = plan
+                .candidates
+                .iter()
+                .filter_map(|(owner, edge)| (*owner == expression).then_some(edge.3))
+                .collect();
+            let expected = if duplicate_uuid {
+                vec![]
+            } else {
+                vec![
+                    configuration["Performances::performances"],
+                    configuration["Performances::evaluations"],
+                    configuration["Base::things"],
+                ]
+            };
+            assert_eq!(
+                actual, expected,
+                "ambiguous narrow role preserves generic ancestry; duplicate UUID refuses all roles"
+            );
+        }
+    }
+    #[test]
+    fn every_authored_constructor_gets_only_its_static_required_edge() {
+        for mut r in models() {
+            let constructors: Vec<_> =
+                r.b.elements
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, e)| (e.ty == "ConstructorExpression").then_some(i))
+                    .collect();
+            assert_eq!(constructors.len(), 2);
+            let target = r
+                .resolve_qualified("Performances::constructorEvaluations")
+                .unwrap();
+            for expression in constructors {
+                let original_owned = r.b.elements[expression].owned_relationships.clone();
+                let rows = r.implied_relationships(ElementRef(expression));
+                assert_eq!(rows.len(), 1, "only the fixed ancestry edge is introduced");
+                assert!(matches!(
+                    r.model_level_evaluability(ElementRef(expression))
+                        .classification,
+                    crate::json::ModelLevelEvaluability::Unknown(_)
+                ));
+                assert!(rows.iter().any(|rel| r.b.elements[rel.0].ty == "Subsetting"
+                    && specialization_target(&r.b.elements[rel.0]) == Some(r.element_id(target))));
+                assert_eq!(r.b.elements[expression].owned_relationships, original_owned);
+                assert!(
+                    r.b.semantic_ownership
+                        .as_ref()
+                        .unwrap()
+                        .result(expression)
+                        .is_none()
+                );
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod expression_static_tests {
+    use super::*;
+    use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; expr literalEvaluations subsets evaluations; expr literalIntegerEvaluations subsets literalEvaluations; expr literalBooleanEvaluations subsets literalEvaluations; expr constructorEvaluations subsets evaluations; expr other:Evaluation subsets performances;}";
+    const USER: &str = "class C {feature slot;} feature receiver:C; feature referenced=receiver; feature chained=receiver.slot; feature body={1}; feature plus=1+2; feature indexed=receiver#(1); feature selected=receiver.?{in p; true}; feature collected=receiver.{in p; p}; expr declared; expr already subsets Performances::evaluations; expr indirectly subsets already; expr cycleA subsets cycleB; expr cycleB subsets cycleA; bool boolean; inv true invariant {true} function F {return result;} feature invoked=F(); feature constructed=new C(); feature decoy;";
+    const GENERIC: &[&str] = &[
+        "Expression",
+        "FeatureReferenceExpression",
+        "FeatureChainExpression",
+        "OperatorExpression",
+        "IndexExpression",
+        "SelectExpression",
+        "CollectExpression",
+        "BooleanExpression",
+        "Invariant",
+        "InvocationExpression",
+    ];
+
+    fn models() -> Vec<ResolvedModel> {
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("evaluation-bases.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(73).unwrap(), 73).unwrap());
+        (0..4)
+            .map(|mode| {
+                let mut model = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.add_library_source("evaluation-bases.kerml", LIB);
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                assert!(
+                    model
+                        .add_source("expression-static.kerml", USER)
+                        .diagnostics
+                        .is_empty()
+                );
+                ResolvedModel::build(&model)
+            })
+            .collect()
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .collect()
+    }
+
+    #[test]
+    fn every_parsed_expression_reaches_evaluations_across_replay_and_policy() {
+        let mut expected = None;
+        for mut r in models() {
+            let target = r.resolve_qualified("Performances::evaluations").unwrap();
+            let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            let expressions: Vec<_> = r
+                .user_elements()
+                .filter(|e| conforms(r.element_type(*e), "Expression"))
+                .collect();
+            for ty in GENERIC {
+                assert!(
+                    expressions.iter().any(|e| r.element_type(*e) == *ty),
+                    "missing fixture {ty}"
+                );
+                assert!(
+                    r.b.planned_literal_target(ty).is_none(),
+                    "generic ancestry must not widen leaf result provider: {ty}"
+                );
+            }
+            let configuration = names(&r);
+            let class = r.resolve_qualified("C").unwrap();
+            let legacy = r.b.legacy_implied_plan_with_owners(
+                class.0,
+                &configuration,
+                &r.b.semantic_relationship_owners(),
+            );
+            assert!(!legacy.is_empty());
+            for policy in [
+                super::super::ClosurePolicy::Passthrough,
+                super::super::ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+                super::super::ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                let mut ids = Vec::new();
+                for &expression in &expressions {
+                    assert!(
+                        r.conforms_with_implied(expression, target),
+                        "{}",
+                        r.element_type(expression)
+                    );
+                    for rel in r.implied_relationships(expression) {
+                        let row = &r.b.elements[rel.0];
+                        if row.ty == "Subsetting"
+                            && specialization_target(row) == Some(r.element_id(target))
+                        {
+                            let key = format!(
+                                "{}/implied/Subsetting/{}",
+                                r.element_id(expression),
+                                r.element_id(target)
+                            );
+                            assert_eq!(row.id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+                            ids.push(row.id);
+                        }
+                    }
+                }
+                assert!(!ids.is_empty());
+                if let Some(expected) = &expected {
+                    assert_eq!(&ids, expected);
+                } else {
+                    expected = Some(ids);
+                }
+                for rel in r.implied_relationships(class) {
+                    let row = &r.b.elements[rel.0];
+                    if let Some(slot) = legacy.iter().position(|edge| {
+                        edge.0 == row.ty && Some(edge.3) == specialization_target(row)
+                    }) {
+                        let key = format!("{}/implied{slot}", r.element_id(class));
+                        assert_eq!(row.id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+                    }
+                }
+            }
+            assert_eq!(
+                source_ids,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+
+    #[test]
+    fn existing_paths_and_specific_expression_bases_avoid_redundant_generic_edges() {
+        for mut r in models() {
+            let target = r.resolve_qualified("Performances::evaluations").unwrap();
+            for name in ["already", "indirectly", "Performances::evaluations"] {
+                let e = r.resolve_qualified(name).unwrap();
+                assert!(r.conforms_with_implied(e, target));
+                assert!(
+                    !r.implied_relationships(e)
+                        .into_iter()
+                        .any(|rel| specialization_target(&r.b.elements[rel.0])
+                            == Some(r.element_id(target)))
+                );
+            }
+            let cycle_a = r.resolve_qualified("cycleA").unwrap();
+            let cycle_b = r.resolve_qualified("cycleB").unwrap();
+            assert!(r.conforms_with_implied(cycle_a, target));
+            assert!(r.conforms_with_implied(cycle_b, target));
+            let cycle_edges = r
+                .implied_relationships(cycle_a)
+                .into_iter()
+                .chain(r.implied_relationships(cycle_b));
+            assert_eq!(
+                cycle_edges
+                    .filter(|rel| specialization_target(&r.b.elements[rel.0])
+                        == Some(r.element_id(target)))
+                    .count(),
+                1,
+                "a cycle must retain exactly one generic anchor"
+            );
+            let specific: Vec<_> = r
+                .user_elements()
+                .filter(|e| {
+                    matches!(
+                        r.element_type(*e),
+                        "LiteralInteger" | "LiteralBoolean" | "ConstructorExpression"
+                    )
+                })
+                .collect();
+            assert!(!specific.is_empty());
+            for e in specific {
+                let role = match r.element_type(e) {
+                    "LiteralInteger" => "Performances::literalIntegerEvaluations",
+                    "LiteralBoolean" => "Performances::literalBooleanEvaluations",
+                    "ConstructorExpression" => "Performances::constructorEvaluations",
+                    _ => unreachable!(),
+                };
+                let expected = r.resolve_qualified(role).unwrap();
+                let edges = r.implied_relationships(e);
+                assert_eq!(
+                    edges
+                        .iter()
+                        .filter(|rel| specialization_target(&r.b.elements[rel.0])
+                            == Some(r.element_id(expected)))
+                        .count(),
+                    1
+                );
+                assert!(
+                    !edges
+                        .iter()
+                        .any(|rel| specialization_target(&r.b.elements[rel.0])
+                            == Some(r.element_id(target)))
+                );
+                assert!(r.conforms_with_implied(e, target));
+            }
+        }
+    }
+
+    #[test]
+    fn generic_requirement_refuses_missing_relabelled_ambiguous_or_duplicate_identity_roles() {
+        for mode in 0..4 {
+            let mut r = models().remove(0);
+            let expression = r.resolve_qualified("declared").unwrap();
+            let target = r.resolve_qualified("Performances::evaluations").unwrap();
+            let other = r.resolve_qualified("Performances::other").unwrap();
+            let mut configuration = names(&r);
+            match mode {
+                0 => {
+                    configuration.remove("Performances::evaluations");
+                }
+                1 => {
+                    let decoy = r.resolve_qualified("decoy").unwrap();
+                    configuration.insert("Performances::evaluations".into(), r.element_id(decoy));
+                }
+                2 => {
+                    r.b.lib_qnames.push((
+                        r.element_id(other),
+                        vec!["Performances".into(), "evaluations".into()],
+                    ));
+                }
+                3 => {
+                    r.b.elements[other.0].id = r.element_id(target);
+                }
+                _ => unreachable!(),
+            }
+            r.b.id_index = None;
+            r.b.supported_implied = None;
+            let plan = r.b.supported_implied_specializations(&configuration, false);
+            let actual: Vec<_> = plan
+                .candidates
+                .iter()
+                .filter_map(|(owner, edge)| (*owner == expression.0).then_some(edge.3))
+                .collect();
+            assert_eq!(
+                actual,
+                if mode == 3 {
+                    vec![]
+                } else {
+                    vec![
+                        configuration["Performances::performances"],
+                        configuration["Base::things"],
+                    ]
+                },
+                "bad expression role retains independent Step and Feature ancestry; duplicate UUID refuses all roles: mode {mode}"
+            );
+        }
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source(
+                    "unavailable.kerml",
+                    "expr declared; feature f; feature x=f;"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let declared = r.resolve_qualified("declared").unwrap();
+        assert!(r.implied_relationships(declared).is_empty());
+    }
+
+    #[test]
+    fn step_requirement_checks_its_own_canonical_identity_and_kind() {
+        for mode in 0..6 {
+            let mut r = models().remove(0);
+            let expression = r.resolve_qualified("declared").unwrap();
+            let target = r.resolve_qualified(STEP_BASE).unwrap();
+            let other = r.resolve_qualified("Performances::other").unwrap();
+            let mut configuration = names(&r);
+            match mode {
+                0 => {
+                    configuration.remove(STEP_BASE);
+                }
+                1 => {
+                    let decoy = r.resolve_qualified("decoy").unwrap();
+                    configuration.insert(STEP_BASE.into(), r.element_id(decoy));
+                }
+                2 => {
+                    r.b.lib_qnames.push((
+                        r.element_id(other),
+                        vec!["Performances".into(), "performances".into()],
+                    ));
+                }
+                3 => {
+                    r.b.elements[other.0].id = r.element_id(target);
+                }
+                4 => {
+                    r.b.elements[target.0].ty = "Feature";
+                }
+                5 => {
+                    configuration.insert(
+                        STEP_BASE.into(),
+                        Uuid::new_v5(&Uuid::NAMESPACE_OID, b"unloaded step role"),
+                    );
+                }
+                _ => unreachable!(),
+            }
+            r.b.id_index = None;
+            r.b.supported_implied = None;
+            let plan = r.b.supported_implied_specializations(&configuration, false);
+            assert!(
+                !plan.expression_targets.contains_key(STEP_BASE),
+                "mode {mode}"
+            );
+            let actual: Vec<_> = plan
+                .candidates
+                .iter()
+                .filter_map(|(owner, edge)| (*owner == expression.0).then_some(edge.3))
+                .collect();
+            assert_eq!(
+                actual,
+                if mode == 3 {
+                    vec![]
+                } else {
+                    vec![
+                        configuration["Performances::evaluations"],
+                        configuration[FEATURE_BASE],
+                    ]
+                },
+                "invalid Step role cannot suppress independent Expression and Feature roles: mode {mode}"
+            );
+        }
+    }
+
+    #[test]
+    fn expression_inheritance_is_metaclass_based_and_does_not_widen_leaf_results() {
+        for ty in [
+            "Expression",
+            "FeatureReferenceExpression",
+            "FeatureChainExpression",
+            "OperatorExpression",
+            "IndexExpression",
+            "SelectExpression",
+            "CollectExpression",
+            "BooleanExpression",
+            "Invariant",
+            "InstantiationExpression",
+            "LiteralExpression",
+            "CalculationUsage",
+            "ConstraintUsage",
+            "AssertConstraintUsage",
+        ] {
+            assert!(conforms(ty, "Expression"), "test metaclass {ty}");
+            assert_eq!(
+                expression_implied_base(ty),
+                Some("Performances::evaluations"),
+                "{ty}"
+            );
+            assert_eq!(literal_implied_base(ty), None, "{ty}");
+        }
+        for ty in [
+            "Feature",
+            "Function",
+            "Behavior",
+            "Step",
+            "Class",
+            "FakeExpression",
+        ] {
+            assert_eq!(expression_implied_base(ty), None, "{ty}");
+        }
+    }
+}
+
+#[cfg(test)]
+mod expression_fixed_role_tests {
+    use super::*;
+    use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+
+    const LIB: &str = "standard library package Performances { function Evaluation {return result;} expr evaluations:Evaluation; expr booleanEvaluations subsets evaluations; expr trueEvaluations subsets booleanEvaluations; expr falseEvaluations subsets booleanEvaluations; expr literalEvaluations subsets evaluations; expr literalIntegerEvaluations subsets literalEvaluations; expr other subsets evaluations; }";
+    const USER: &str = "bool condition; inv true positive; inv false negative; feature generic=1; bool direct subsets Performances::booleanEvaluations; bool indirect subsets direct; inv true directPositive subsets Performances::trueEvaluations; inv false directNegative subsets Performances::falseEvaluations; feature decoy;";
+
+    fn models() -> Vec<ResolvedModel> {
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("fixed-roles.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(79).unwrap(), 79).unwrap());
+        (0..4)
+            .map(|mode| {
+                let mut model = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.add_library_source("fixed-roles.kerml", LIB);
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let parsed = model.add_source("fixed-roles-user.kerml", USER);
+                assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+                ResolvedModel::build(&model)
+            })
+            .collect()
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .collect()
+    }
+    fn retained_targets(plan: &SupportedImpliedSpecializations, owner: usize) -> Vec<Uuid> {
+        plan.candidates
+            .iter()
+            .enumerate()
+            .filter_map(|(i, (at, edge))| (*at == owner && plan.retained[i]).then_some(edge.3))
+            .collect()
+    }
+    fn generic_literal(r: &mut ResolvedModel) -> ElementRef {
+        let i =
+            r.b.elements
+                .iter()
+                .enumerate()
+                .skip(r.b.lib_boundary)
+                .find(|(_, e)| e.ty == "LiteralInteger")
+                .unwrap()
+                .0;
+        // Generic LiteralExpression has no dedicated textual production. Use
+        // a model-level fixture to exercise its inherited static obligation.
+        r.b.elements[i].ty = "LiteralExpression";
+        let kept = r.b.elements[i].props.to_json();
+        r.b.elements[i].props = crate::properties::Properties::new();
+        for (key, value) in kept {
+            if key != "value" {
+                r.b.elements[i].props.insert(&key, value);
+            }
+        }
+        r.b.supported_implied = None;
+        ElementRef(i)
+    }
+
+    #[test]
+    fn inherited_fixed_roles_replay_minimize_and_preserve_source_identities() {
+        let mut expected = None;
+        for mut r in models() {
+            let literal = generic_literal(&mut r);
+            let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            let generic = r.resolve_qualified("Performances::evaluations").unwrap();
+            let boolean = r
+                .resolve_qualified("Performances::booleanEvaluations")
+                .unwrap();
+            let mut cases = Vec::new();
+            for (name, role) in [
+                ("condition", "Performances::booleanEvaluations"),
+                ("positive", "Performances::trueEvaluations"),
+                ("negative", "Performances::falseEvaluations"),
+            ] {
+                cases.push((
+                    r.resolve_qualified(name).unwrap(),
+                    r.resolve_qualified(role).unwrap(),
+                ));
+            }
+            cases.push((
+                literal,
+                r.resolve_qualified("Performances::literalEvaluations")
+                    .unwrap(),
+            ));
+            for policy in [
+                super::super::ClosurePolicy::Passthrough,
+                super::super::ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+                super::super::ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                let mut ids = Vec::new();
+                for &(owner, role) in &cases {
+                    assert!(r.conforms_with_implied(owner, role));
+                    assert!(r.conforms_with_implied(owner, generic));
+                    if owner != literal {
+                        assert!(r.conforms_with_implied(owner, boolean));
+                    }
+                    let rows = r.implied_relationships(owner);
+                    assert_eq!(rows.len(), 1, "{}", r.element_type(owner));
+                    assert_eq!(
+                        specialization_target(&r.b.elements[rows[0].0]),
+                        Some(r.element_id(role))
+                    );
+                    let key = format!(
+                        "{}/implied/Subsetting/{}",
+                        r.element_id(owner),
+                        r.element_id(role)
+                    );
+                    assert_eq!(
+                        r.element_id(rows[0]),
+                        Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes())
+                    );
+                    assert!(r.b.planned_literal_target(r.element_type(owner)).is_none());
+                    ids.push(r.element_id(rows[0]));
+                }
+                for name in ["direct", "indirect", "directPositive", "directNegative"] {
+                    let owner = r.resolve_qualified(name).unwrap();
+                    assert!(r.conforms_with_implied(owner, generic));
+                    assert!(
+                        r.implied_relationships(owner).is_empty(),
+                        "redundant edge on {name}"
+                    );
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(&ids, expected);
+                } else {
+                    expected = Some(ids);
+                }
+            }
+            assert_eq!(
+                before,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+
+    #[test]
+    fn invariant_default_is_only_for_absence_and_invalid_flags_do_not_choose_a_branch() {
+        for ty in [
+            "Invariant",
+            "AssertConstraintUsage",
+            "SatisfyRequirementUsage",
+        ] {
+            let (_, effective) = crate::semantic_catalog::property(ty, "isNegated").unwrap();
+            let spec = effective.unwrap();
+            assert_eq!(spec.default_json, Some("false"));
+            assert_eq!(
+                (spec.target, spec.lower, spec.upper, spec.derived),
+                ("Boolean", 1, Some(1), false)
+            );
+        }
+        let variants = [
+            None,
+            Some(json!(false)),
+            Some(json!(true)),
+            Some(json!(null)),
+            Some(json!("false")),
+            Some(json!(0)),
+            Some(json!([])),
+            Some(json!({})),
+        ];
+        for (i, value) in variants.into_iter().enumerate() {
+            let mut r = models().remove(0);
+            let owner = r.resolve_qualified("positive").unwrap();
+            let boolean = r
+                .resolve_qualified("Performances::booleanEvaluations")
+                .unwrap();
+            let yes = r
+                .resolve_qualified("Performances::trueEvaluations")
+                .unwrap();
+            let no = r
+                .resolve_qualified("Performances::falseEvaluations")
+                .unwrap();
+            let kept = r.b.elements[owner.0].props.to_json();
+            r.b.elements[owner.0].props = crate::properties::Properties::new();
+            for (key, value) in kept {
+                if key != "isNegated" {
+                    r.b.elements[owner.0].props.insert(&key, value);
+                }
+            }
+            if let Some(value) = value {
+                r.b.elements[owner.0].props.insert("isNegated", value);
+            }
+            r.b.supported_implied = None;
+            let plan = r.b.supported_implied_specializations(&names(&r), true);
+            let wanted = match i {
+                0 | 1 => r.element_id(yes),
+                2 => r.element_id(no),
+                _ => r.element_id(boolean),
+            };
+            assert_eq!(
+                retained_targets(&plan, owner.0),
+                vec![wanted],
+                "flag case {i}"
+            );
+            if i >= 3 {
+                assert!(!plan.candidates.iter().any(|(at, edge)| *at == owner.0
+                    && [r.element_id(yes), r.element_id(no)].contains(&edge.3)));
+            }
+        }
+        // A similarly named flag on a BooleanExpression is not an Invariant.
+        let mut r = models().remove(0);
+        let owner = r.resolve_qualified("condition").unwrap();
+        let boolean = r
+            .resolve_qualified("Performances::booleanEvaluations")
+            .unwrap();
+        r.b.elements[owner.0].props.insert("isNegated", json!(true));
+        r.b.supported_implied = None;
+        let plan = r.b.supported_implied_specializations(&names(&r), true);
+        assert_eq!(
+            retained_targets(&plan, owner.0),
+            vec![r.element_id(boolean)]
+        );
+    }
+
+    #[test]
+    fn unavailable_narrower_roles_keep_independently_proven_general_obligations() {
+        for (owner_name, role, parent) in [
+            (
+                "condition",
+                "Performances::booleanEvaluations",
+                "Performances::evaluations",
+            ),
+            (
+                "positive",
+                "Performances::trueEvaluations",
+                "Performances::booleanEvaluations",
+            ),
+            (
+                "negative",
+                "Performances::falseEvaluations",
+                "Performances::booleanEvaluations",
+            ),
+            (
+                "literal",
+                "Performances::literalEvaluations",
+                "Performances::evaluations",
+            ),
+        ] {
+            for problem in 0..6 {
+                let mut r = models().remove(0);
+                let owner = if owner_name == "literal" {
+                    generic_literal(&mut r)
+                } else {
+                    r.resolve_qualified(owner_name).unwrap()
+                };
+                let target = r.resolve_qualified(role).unwrap();
+                let parent = r.resolve_qualified(parent).unwrap();
+                let mut configuration = names(&r);
+                match problem {
+                    0 => {
+                        configuration.remove(role);
+                    }
+                    1 => {
+                        let decoy = r.resolve_qualified("decoy").unwrap();
+                        configuration.insert(role.into(), r.element_id(decoy));
+                    }
+                    2 => {
+                        let other = r.resolve_qualified("Performances::other").unwrap();
+                        r.b.lib_qnames.push((
+                            r.element_id(other),
+                            role.split("::").map(str::to_owned).collect(),
+                        ));
+                    }
+                    3 => {
+                        r.b.elements[target.0].ty = "Class";
+                    }
+                    4 => r.b.elements[target.0].ty = "Feature",
+                    5 => r.b.elements[target.0].ty = "Step",
+                    _ => unreachable!(),
+                }
+                r.b.id_index = None;
+                r.b.supported_implied = None;
+                let plan = r.b.supported_implied_specializations(&configuration, false);
+                assert_eq!(
+                    retained_targets(&plan, owner.0),
+                    vec![r.element_id(parent)],
+                    "{role}, bad role {problem}"
+                );
+                assert!(
+                    !plan
+                        .candidates
+                        .iter()
+                        .any(|(at, edge)| *at == owner.0 && edge.3 == r.element_id(target)),
+                    "untrusted narrower role survived"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_loaded_uuid_refuses_roles_and_exact_leaf_policy_is_unchanged() {
+        let mut r = models().remove(0);
+        let owner = r.resolve_qualified("condition").unwrap();
+        let target = r
+            .resolve_qualified("Performances::booleanEvaluations")
+            .unwrap();
+        let other = r.resolve_qualified("Performances::other").unwrap();
+        r.b.elements[other.0].id = r.element_id(target);
+        r.b.id_index = None;
+        r.b.supported_implied = None;
+        let plan = r.b.supported_implied_specializations(&names(&r), true);
+        assert!(!plan.candidates.iter().any(|(at, _)| *at == owner.0));
+        for ty in [
+            "LiteralBoolean",
+            "LiteralInteger",
+            "LiteralInfinity",
+            "LiteralRational",
+            "LiteralString",
+            "NullExpression",
+            "MetadataAccessExpression",
+            "ConstructorExpression",
+        ] {
+            assert_eq!(
+                additional_expression_base(ty),
+                conforms(ty, "LiteralExpression").then_some("Performances::literalEvaluations"),
+                "inherited literal role: {ty}"
+            );
+            assert_eq!(
+                literal_implied_base(ty).is_some(),
+                ty != "ConstructorExpression",
+                "exact leaf result-provider boundary: {ty}"
+            );
+        }
+        for ty in [
+            "BooleanExpression",
+            "Invariant",
+            "ConstraintUsage",
+            "AssertConstraintUsage",
+            "RequirementUsage",
+            "SatisfyRequirementUsage",
+        ] {
+            assert_eq!(
+                additional_expression_base(ty),
+                Some("Performances::booleanEvaluations")
+            );
+            assert!(literal_implied_base(ty).is_none());
+        }
+    }
+}
+
+#[cfg(test)]
+mod sysml_assertion_role_tests {
+    use super::*;
+    use crate::model::Model;
+    const KERNEL: &str = "standard library package Performances { expr evaluations; expr booleanEvaluations subsets evaluations; expr trueEvaluations subsets booleanEvaluations; expr falseEvaluations subsets booleanEvaluations; }";
+    const SYSTEMS: &str = "standard library package Constraints { constraint constraintChecks :> Performances::booleanEvaluations; constraint assertedConstraintChecks :> constraintChecks, Performances::trueEvaluations; constraint negatedConstraintChecks :> constraintChecks, Performances::falseEvaluations; constraint other; } standard library package Requirements { requirement requirementChecks :> Constraints::constraintChecks; requirement satisfiedRequirementChecks :> requirementChecks, Constraints::assertedConstraintChecks; requirement notSatisfiedRequirementChecks :> requirementChecks, Constraints::negatedConstraintChecks; requirement other; }";
+    const USER: &str = "constraint plain; requirement ordinary; assert constraint yes; assert not constraint no; satisfy requirement sat; not satisfy requirement unsat; assert constraint direct :> Constraints::assertedConstraintChecks; assert constraint indirect :> direct; satisfy requirement directSat :> Requirements::satisfiedRequirementChecks; satisfy requirement indirectSat :> directSat; attribute decoy;";
+    fn model() -> ResolvedModel {
+        let mut m = Model::new();
+        for (path, source, library) in [
+            ("assert-kernel.kerml", KERNEL, true),
+            ("assert-systems.sysml", SYSTEMS, true),
+            ("assert-user.sysml", USER, false),
+        ] {
+            let p = if library {
+                m.add_library_source(path, source)
+            } else {
+                m.add_source(path, source)
+            };
+            assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+        }
+        ResolvedModel::build(&m)
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, segs)| (segs.join("::"), *id))
+            .collect()
+    }
+    fn candidates(plan: &SupportedImpliedSpecializations, owner: usize) -> Vec<Uuid> {
+        plan.candidates
+            .iter()
+            .filter_map(|(at, edge)| (*at == owner).then_some(edge.3))
+            .collect()
+    }
+    fn retained(plan: &SupportedImpliedSpecializations, owner: usize) -> Vec<Uuid> {
+        plan.candidates
+            .iter()
+            .enumerate()
+            .filter_map(|(i, (at, edge))| (*at == owner && plan.retained[i]).then_some(edge.3))
+            .collect()
+    }
+    #[test]
+    fn assertions_and_satisfaction_accumulate_then_minimize_and_keep_legacy_ids() {
+        let mut r = model();
+        let config = names(&r);
+        let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let mut cases = Vec::new();
+        for (owner, role, assert_role) in [
+            ("yes", assertion_implied_base(false), None),
+            ("no", assertion_implied_base(true), None),
+            (
+                "sat",
+                satisfaction_implied_base(false),
+                Some(assertion_implied_base(false)),
+            ),
+            (
+                "unsat",
+                satisfaction_implied_base(true),
+                Some(assertion_implied_base(true)),
+            ),
+        ] {
+            let owner = r.resolve_qualified(owner).unwrap();
+            let role = r.resolve_qualified(role).unwrap();
+            let legacy = r.b.legacy_implied_plan_with_owners(
+                owner.0,
+                &config,
+                &r.b.semantic_relationship_owners(),
+            );
+            cases.push((owner, role, assert_role, legacy));
+        }
+        let plan = r.b.supported_implied_specializations(&config, true);
+        for (owner, role, inherited, _) in &cases {
+            assert_eq!(retained(&plan, owner.0), vec![r.element_id(*role)]);
+            if let Some(inherited) = inherited {
+                let parent = r.resolve_qualified(inherited).unwrap();
+                assert!(
+                    candidates(&plan, owner.0).contains(&r.element_id(parent)),
+                    "Satisfy must independently inherit Assert"
+                );
+            }
+        }
+        let plain = r.resolve_qualified("plain").unwrap();
+        let old = r.b.legacy_implied_plan_with_owners(
+            plain.0,
+            &config,
+            &r.b.semantic_relationship_owners(),
+        );
+        assert!(!old.is_empty());
+        let mut expected = None;
+        for policy in [
+            super::super::ClosurePolicy::Passthrough,
+            super::super::ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            super::super::ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            let mut edges = Vec::new();
+            for (owner, role, _, _) in &cases {
+                assert!(r.conforms_with_implied(*owner, *role));
+                for base in [
+                    "Constraints::constraintChecks",
+                    "Performances::booleanEvaluations",
+                    "Performances::evaluations",
+                ] {
+                    let base = r.resolve_qualified(base).unwrap();
+                    assert!(r.conforms_with_implied(*owner, base));
+                }
+                let rows = r.implied_relationships(*owner);
+                assert_eq!(rows.len(), 1);
+                let key = format!(
+                    "{}/implied/Subsetting/{}",
+                    r.element_id(*owner),
+                    r.element_id(*role)
+                );
+                assert_eq!(
+                    r.element_id(rows[0]),
+                    Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes())
+                );
+                assert!(r.b.planned_literal_target(r.element_type(*owner)).is_none());
+                edges.push(r.element_id(rows[0]));
+            }
+            for row in r.implied_relationships(plain) {
+                let target = specialization_target(&r.b.elements[row.0]).unwrap();
+                let slot = old
+                    .iter()
+                    .position(|edge| edge.3 == target)
+                    .expect("surviving legacy role");
+                let key = format!("{}/implied{slot}", r.element_id(plain));
+                assert_eq!(
+                    r.element_id(row),
+                    Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes())
+                );
+                edges.push(r.element_id(row));
+            }
+            for name in ["direct", "indirect", "directSat", "indirectSat"] {
+                let owner = r.resolve_qualified(name).unwrap();
+                assert!(
+                    r.implied_relationships(owner).is_empty(),
+                    "redundant {name}"
+                );
+            }
+            if let Some(expected) = &expected {
+                assert_eq!(&edges, expected)
+            } else {
+                expected = Some(edges)
+            }
+        }
+        assert_eq!(
+            ids,
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>()
+        );
+    }
+    #[test]
+    fn missing_or_untrusted_narrow_roles_do_not_erase_broader_candidates() {
+        for (owner_name, narrow, broader) in [
+            (
+                "yes",
+                assertion_implied_base(false),
+                invariant_implied_base(false),
+            ),
+            (
+                "no",
+                assertion_implied_base(true),
+                invariant_implied_base(true),
+            ),
+            (
+                "sat",
+                satisfaction_implied_base(false),
+                assertion_implied_base(false),
+            ),
+            (
+                "unsat",
+                satisfaction_implied_base(true),
+                assertion_implied_base(true),
+            ),
+            (
+                "sat",
+                assertion_implied_base(false),
+                satisfaction_implied_base(false),
+            ),
+            (
+                "unsat",
+                assertion_implied_base(true),
+                satisfaction_implied_base(true),
+            ),
+        ] {
+            for problem in 0..5 {
+                let mut r = model();
+                let owner = r.resolve_qualified(owner_name).unwrap();
+                let target = r.resolve_qualified(narrow).unwrap();
+                let broader = r.resolve_qualified(broader).unwrap();
+                let mut config = names(&r);
+                match problem {
+                    0 => {
+                        config.remove(narrow);
+                    }
+                    1 => {
+                        let decoy = r.resolve_qualified("decoy").unwrap();
+                        config.insert(narrow.into(), r.element_id(decoy));
+                    }
+                    2 => {
+                        let decoy = r.resolve_qualified("Constraints::other").unwrap();
+                        r.b.lib_qnames.push((
+                            r.element_id(decoy),
+                            narrow.split("::").map(str::to_owned).collect(),
+                        ));
+                    }
+                    3 => {
+                        r.b.elements[target.0].ty = "Feature";
+                    }
+                    4 => {
+                        r.b.elements[target.0].ty = "Class";
+                    }
+                    _ => unreachable!(),
+                }
+                r.b.id_index = None;
+                r.b.supported_implied = None;
+                let plan = r.b.supported_implied_specializations(&config, false);
+                let candidates = candidates(&plan, owner.0);
+                assert!(
+                    !candidates.contains(&r.element_id(target)),
+                    "{narrow}, {problem}"
+                );
+                assert!(
+                    candidates.contains(&r.element_id(broader)),
+                    "broader role lost: {owner_name}, {problem}"
+                );
+                assert!(!retained(&plan, owner.0).is_empty());
+            }
+        }
+    }
+    #[test]
+    fn negation_default_requires_absence_and_malformed_retained_values_select_no_conditional_role()
+    {
+        for owner_name in ["yes", "sat"] {
+            for value in [
+                None,
+                Some(json!(false)),
+                Some(json!(true)),
+                Some(json!(null)),
+                Some(json!("false")),
+                Some(json!(0)),
+                Some(json!([])),
+                Some(json!({})),
+            ] {
+                let mut r = model();
+                let owner = r.resolve_qualified(owner_name).unwrap();
+                let kept = r.b.elements[owner.0].props.to_json();
+                r.b.elements[owner.0].props = crate::properties::Properties::new();
+                for (key, value) in kept {
+                    if key != "isNegated" {
+                        r.b.elements[owner.0].props.insert(&key, value);
+                    }
+                }
+                if let Some(value) = &value {
+                    r.b.elements[owner.0]
+                        .props
+                        .insert("isNegated", value.clone());
+                }
+                r.b.supported_implied = None;
+                let plan = r.b.supported_implied_specializations(&names(&r), true);
+                let candidates = candidates(&plan, owner.0);
+                let expected = match &value {
+                    None => Some(false),
+                    Some(value) => value.as_bool(),
+                };
+                for flag in [false, true] {
+                    for role in [
+                        invariant_implied_base(flag),
+                        assertion_implied_base(flag),
+                        satisfaction_implied_base(flag),
+                    ] {
+                        let role = r.resolve_qualified(role).unwrap();
+                        let applicable = expected == Some(flag)
+                            && (owner_name == "sat"
+                                || !r.element_type(role).eq("RequirementUsage"));
+                        assert_eq!(
+                            candidates.contains(&r.element_id(role)),
+                            applicable,
+                            "{owner_name} {value:?} {}",
+                            r.element_qualified_name(role).unwrap_or_default()
+                        );
+                    }
+                }
+                let boolean = r
+                    .resolve_qualified("Performances::booleanEvaluations")
+                    .unwrap();
+                assert!(candidates.contains(&r.element_id(boolean)));
+            }
+        }
+        let mut r = model();
+        let owner = r.resolve_qualified("plain").unwrap();
+        r.b.elements[owner.0].props.insert("isNegated", json!(true));
+        r.b.supported_implied = None;
+        let plan = r.b.supported_implied_specializations(&names(&r), true);
+        let c = candidates(&plan, owner.0);
+        for role in [
+            assertion_implied_base(true),
+            satisfaction_implied_base(true),
+        ] {
+            let role = r.resolve_qualified(role).unwrap();
+            assert!(!c.contains(&r.element_id(role)));
+        }
+    }
+    #[test]
+    fn duplicate_loaded_identity_refuses_new_conditional_roles() {
+        let mut r = model();
+        let owner = r.resolve_qualified("sat").unwrap();
+        let target = r
+            .resolve_qualified(satisfaction_implied_base(false))
+            .unwrap();
+        let other = r.resolve_qualified("Requirements::other").unwrap();
+        r.b.elements[other.0].id = r.element_id(target);
+        r.b.id_index = None;
+        r.b.supported_implied = None;
+        let plan = r.b.supported_implied_specializations(&names(&r), true);
+        for role in [
+            assertion_implied_base(false),
+            satisfaction_implied_base(false),
+        ] {
+            assert!(!plan.expression_targets.contains_key(role));
+        }
+        assert!(!candidates(&plan, owner.0).contains(&r.element_id(target)));
+    }
+}
+
+#[cfg(test)]
+mod performances_role_kind_tests {
+    use super::*;
+    use crate::model::Model;
+
+    const ROLES: &[&str] = &[
+        "evaluations",
+        "constructorEvaluations",
+        "booleanEvaluations",
+        "trueEvaluations",
+        "falseEvaluations",
+        "metadataAccessEvaluations",
+        "literalEvaluations",
+        "literalBooleanEvaluations",
+        "literalIntegerEvaluations",
+        "literalRationalEvaluations",
+        "literalStringEvaluations",
+        "nullEvaluations",
+    ];
+
+    #[test]
+    fn each_loaded_performances_role_requires_expression_ancestry_independently() {
+        for declaration in ["expr", "bool", "feature", "step"] {
+            for &changed in ROLES {
+                let declarations = ROLES
+                    .iter()
+                    .map(|&role| {
+                        format!(
+                            "{} {role};",
+                            if role == changed { declaration } else { "expr" }
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(" ");
+                let mut model = Model::new();
+                let source = format!("standard library package Performances {{{declarations}}}");
+                assert!(
+                    model
+                        .add_library_source("role-kinds.kerml", &source)
+                        .diagnostics
+                        .is_empty()
+                );
+                let mut r = ResolvedModel::build(&model);
+                let names: HashMap<_, _> =
+                    r.b.lib_qnames
+                        .iter()
+                        .map(|(id, path)| (path.join("::"), *id))
+                        .collect();
+                let admitted = r.b.expression_target_names(&names, &mut None).unwrap();
+                for &role in ROLES {
+                    let name = format!("Performances::{role}");
+                    let expected = role != changed || matches!(declaration, "expr" | "bool");
+                    assert_eq!(
+                        admitted.contains_key(name.as_str()),
+                        expected,
+                        "{declaration} {changed}: {role}"
+                    );
+                    if expected {
+                        assert_eq!(admitted[name.as_str()], names[&name]);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// Sole publisher. Existing ResolvedModel demand sites delegate here; ordinary
+// Builder retained-evidence queries do not become publication demands.
+impl Builder {
+    pub(super) fn ensure_semantic_graph(&mut self) -> super::publication::Status {
+        let _guard = match self.publication.begin(self.semantic_ready) {
+            Ok(guard) => guard,
+            Err(status) => return status,
+        };
+        self.materialize_semantic_graph();
+        super::publication::Status::Ready
+    }
+
+    fn semantic_relationship_owners(&self) -> Vec<Option<usize>> {
+        let mut owners = self.specialization_relation_owners();
+        if let Some(view) = &self.semantic_ownership {
+            for (relationship, owner) in view.relationship_owners() {
+                owners[relationship] = Some(owner);
+            }
+        }
+        owners
+    }
+    fn invalidate_semantic_indexes(&mut self) {
+        self.reset_lookup_caches();
+        self.recorded_lookup_prefix = None;
+        self.parameter_sites = None;
+        self.semantic_memo = Default::default();
+        self.stored_structure = None;
+    }
+    fn materialize_semantic_graph(&mut self) {
+        if self.implied.is_some() {
+            self.materialize_owned_results(None);
+            return;
+        }
+        let owners = self.semantic_relationship_owners();
+        let from = self.elements.len();
+        let lib_by_name: HashMap<String, Uuid> = self
+            .lib_qnames
+            .iter()
+            .map(|(id, segments)| (segments.join("::"), *id))
+            .chain(
+                self.external_implied_names
+                    .iter()
+                    .map(|(name, id)| (name.clone(), *id)),
+            )
+            .collect();
+        let mut ownership = super::semantic_ownership::SemanticOwnership::new(from);
+        // Capture a newly computed positional authority together with the
+        // recipes below, rather than certifying an older compatibility cache.
+        self.positional_redefinitions = None;
+        self.ensure_positional_redefinitions();
+        let plan = self.supported_implied_specializations(
+            &lib_by_name,
+            self.external_implied_names.is_empty(),
+        );
+        let mut specializations = plan.graph.clone();
+        let mut planned = Vec::new();
+        for (index, &(owner, edge)) in plan.candidates.iter().enumerate() {
+            if plan.retained[index] {
+                let legacy_slot = (owner >= self.lib_boundary)
+                    .then(|| {
+                        self.legacy_implied_plan_with_owners(owner, &lib_by_name, &owners)
+                            .iter()
+                            .position(|old| *old == edge)
+                    })
+                    .flatten();
+                planned.push((owner, edge, legacy_slot));
+            }
+        }
+        let mut positional: Vec<_> = self
+            .positional_redefinitions
+            .as_ref()
+            .unwrap()
+            .targets
+            .iter()
+            .map(|(&source, targets)| (source, targets.clone()))
+            .collect();
+        positional.sort_by_key(|(source, _)| *source);
+        for (source, targets) in positional {
+            for target in targets {
+                let target_id = self.elements[target].id;
+                planned.push((
+                    source,
+                    (
+                        "Redefinition",
+                        "redefiningFeature",
+                        "redefinedFeature",
+                        target_id,
+                    ),
+                    None,
+                ));
+                let targets = specializations.entry(self.elements[source].id).or_default();
+                if !targets.contains(&target_id) {
+                    targets.push(target_id);
+                }
+            }
+        }
+        // Retain this producer's exact recipes for the immediately following
+        // tail transaction. Its positional table was computed from this same
+        // current static authority; no second whole-model positional run is
+        // needed before checking the rows we are about to append.
+        let (planner_bases, planner_incomplete) = self
+            .positional_direct_bases_from_static_plan(&plan, None)
+            .expect("unbounded static base capture");
+        let static_prefix = Arc::new(super::semantic_batch::StaticPrefix {
+            authored_end: from,
+            rows: planned
+                .iter()
+                .map(|&(owner, edge, legacy_slot)| {
+                    static_recipe(self.elements[owner].id, owner, edge, legacy_slot)
+                })
+                .collect(),
+            positional: Arc::new(self.positional_redefinitions.as_ref().unwrap().clone()),
+            chain_bases: Arc::clone(&plan.chain_bases),
+            planner_bases,
+            planner_incomplete,
+            specializations: specializations.clone(),
+        });
+        let mut static_owners = HashSet::new();
+        for row in &static_prefix.rows {
+            let i = row.owner;
+            static_owners.insert(i);
+            let mut props = crate::properties::Properties::new();
+            props.insert("isImplied", json!(true));
+            props.insert(row.source_key, json!({ "@id": row.owner_id.to_string() }));
+            props.insert(row.target_key, json!({ "@id": row.target.to_string() }));
+            self.elements.push(Elem {
+                ty: row.kind,
+                id: row.id,
+                path: String::new(),
+                path_parent: None,
+                props,
+                owned_relationships: Default::default(),
+                children: Default::default(),
+                owning_relationship: None,
+            });
+            let idx = self.elements.len() - 1;
+            ownership
+                .register_generic(idx, i)
+                .expect("the implied materializer appends ordered relationship nodes");
+        }
+        self.implied_from = Some(from);
+        // This synchronous append cannot mutate an authored chain fact. Keep
+        // the exact validated authority across the known static publication.
+        *plan.source_rows.lock().unwrap() = self.elements.observe_revision();
+        self.semantic_ownership = Some(Arc::new(ownership));
+        self.implied = Some(ImpliedTable {
+            from,
+            owned_results_from: self.elements.len(),
+            owned_results_state: OwnedResultState::Pending,
+            specializations,
+            static_authority: plan,
+            static_rows: self.elements.observe_revision(),
+            static_owners,
+        });
+        let before = self.publication.revision();
+        self.materialize_owned_results(Some(static_prefix));
+        if before.same_as(&self.publication.revision()) {
+            self.publication.published();
+        }
+    }
+    /// Complete planning before append, and publish one ownership view. A work
+    /// limit discards all plans rather than freezing an order-dependent prefix.
+    fn materialize_owned_results(
+        &mut self,
+        static_prefix: Option<Arc<super::semantic_batch::StaticPrefix>>,
+    ) {
+        let Some(table) = self.implied.as_ref() else {
+            return;
+        };
+        if table.owned_results_state != OwnedResultState::Pending {
+            return;
+        }
+        debug_assert_eq!(table.owned_results_from, self.elements.len());
+        // Result admission retains its independent full allowance. Dynamic
+        // refusal cannot erase a valid result or BindingConnector subtree.
+        let before = self.elements.observe_revision();
+        let before_epoch = self.publication.revision();
+        let mut result_steps = 0;
+        let plans = super::owned_results::plan_reference_results(self, &mut result_steps);
+        let result_state = if plans.is_some() {
+            OwnedResultState::Attempted
+        } else {
+            OwnedResultState::WorkLimited
+        };
+        let plans = plans.unwrap_or_default();
+        let mut dynamic_steps = plans.len().saturating_mul(11);
+        let mut reserved: HashSet<_> = if dynamic_steps <= crate::eval::MAX_STEPS {
+            plans.iter().flat_map(|plan| plan.ids()).collect()
+        } else {
+            HashSet::new()
+        };
+        let mut default_steps = 0;
+        let default_plans =
+            super::owned_results::plan_constructor_defaults(self, &reserved, &mut default_steps)
+                .unwrap_or_default();
+        dynamic_steps = dynamic_steps.saturating_add(default_plans.len().saturating_mul(8));
+        reserved.extend(default_plans.iter().flat_map(|plan| plan.ids()));
+        let original_view = Arc::clone(self.semantic_ownership.as_ref().unwrap());
+        let mut ownership = (!plans.is_empty() || !default_plans.is_empty())
+            .then(|| original_view.as_ref().clone());
+        let mut rows = Vec::new();
+        let mut result_edges = Vec::new();
+        let mut result_redefinition_steps = plans.len();
+        let mut result_roles = Vec::new();
+        let mut local_steps = plans.len().saturating_mul(3);
+        let mut local_roles = Vec::new();
+        for plan in plans {
+            let start = self.elements.len() + rows.len();
+            let staged = super::owned_results::stage_owned_result(
+                self,
+                ownership.as_mut().unwrap(),
+                plan,
+                start,
+                &mut rows,
+            );
+            result_edges.extend(staged.specializations);
+            if result_redefinition_steps <= crate::eval::MAX_STEPS {
+                result_roles.push(staged.featuring[0]);
+            }
+            if local_steps <= crate::eval::MAX_STEPS {
+                local_roles.extend(staged.featuring);
+            }
+        }
+        for plan in default_plans {
+            let start = self.elements.len() + rows.len();
+            let (edges, roles) = super::owned_results::stage_constructor_default(
+                self,
+                ownership.as_mut().unwrap(),
+                plan,
+                start,
+                &mut rows,
+            );
+            result_edges.extend(edges);
+            local_steps = local_steps.saturating_add(roles.len());
+            if local_steps <= crate::eval::MAX_STEPS {
+                local_roles.extend(roles);
+            }
+        }
+        let mut dynamic = if dynamic_steps > crate::eval::MAX_STEPS {
+            Err(super::dynamic_invocations::Refusal::WorkLimit)
+        } else {
+            self.prepare_dynamic_graph(&reserved, &mut dynamic_steps, static_prefix)
+        };
+        let mut graph = None;
+        if let Ok(Some(plan)) = &dynamic {
+            if !plan.tail.is_empty() {
+                let staged = (|| {
+                    let mut next = ownership
+                        .as_ref()
+                        .unwrap_or(original_view.as_ref())
+                        .clone_with_budget(&mut dynamic_steps)
+                        .ok_or(super::dynamic_invocations::Refusal::WorkLimit)?;
+                    let graph =
+                        super::dynamic_graph::stage_dynamic_adjacency(plan, &mut dynamic_steps)?;
+                    let tail = super::dynamic_graph::stage_dynamic_rows(
+                        self,
+                        plan,
+                        self.elements.len() + rows.len(),
+                        &mut next,
+                        &mut dynamic_steps,
+                    )?;
+                    Ok::<_, super::dynamic_invocations::Refusal>((tail, next, graph))
+                })();
+                match staged {
+                    Ok((tail, next, edges)) => {
+                        rows.extend(tail);
+                        ownership = Some(next);
+                        graph = Some(edges);
+                    }
+                    Err(reason) => dynamic = Err(reason),
+                }
+            }
+        }
+        if !result_edges.is_empty() {
+            let graph =
+                graph.get_or_insert_with(|| self.implied.as_ref().unwrap().specializations.clone());
+            for (specific, general) in result_edges {
+                graph.entry(specific).or_default().push(general);
+            }
+        }
+        let local = if local_steps > crate::eval::MAX_STEPS {
+            Err(super::dynamic_invocations::Refusal::WorkLimit)
+        } else if local_roles.is_empty() {
+            Ok(HashSet::new())
+        } else {
+            super::local_featuring::prepare(self, &rows, &local_roles, &mut local_steps).map(
+                |plan| {
+                    plan.append(
+                        &mut rows,
+                        ownership.as_mut().expect("generated local owners"),
+                    )
+                },
+            )
+        };
+        let result_redefinition = if result_redefinition_steps > crate::eval::MAX_STEPS {
+            Err(super::dynamic_invocations::Refusal::WorkLimit)
+        } else if result_roles.is_empty() {
+            Ok(super::result_redefinition::Evidence::default())
+        } else {
+            super::result_redefinition::prepare(
+                self,
+                &rows,
+                &result_roles,
+                &mut result_redefinition_steps,
+            )
+            .map(|plan| {
+                plan.append(
+                    &mut rows,
+                    ownership.as_mut().expect("generated result owners"),
+                    graph.as_mut().expect("result specialization graph"),
+                )
+            })
+        };
+        // Allocate the accepted snapshot and its exact next epoch before the
+        // first physical append. Installation performs no semantic reads.
+        let epoch = super::publication::Revision::next();
+        let after_rows = if rows.is_empty() {
+            before.clone()
+        } else {
+            crate::layered::Revision::default()
+        };
+        let accepted = Arc::new(
+            super::dynamic_graph::Snapshot::new(self, epoch.clone(), after_rows.clone(), dynamic)
+                .with_local(local)
+                .with_result_redefinition(result_redefinition),
+        );
+        let ownership = ownership.map(Arc::new);
+        assert!(
+            self.elements
+                .revision()
+                .is_some_and(|now| now.same_as(&before))
+        );
+        assert!(before_epoch.same_as(&self.publication.revision()));
+        let semantic_change = !rows.is_empty() || accepted.plan.is_some();
+        let static_plan = self
+            .supported_implied
+            .clone()
+            .filter(|_| self.supported_chain_evidence_current());
+        let physical_was_current = self.physical_static_authority_current();
+        self.elements
+            .append_staged(rows, &before, after_rows.clone());
+        if physical_was_current {
+            let table = self.implied.as_mut().unwrap();
+            table.static_rows = after_rows.clone();
+            *table.static_authority.source_rows.lock().unwrap() = after_rows.clone();
+        }
+        // Staged tail rows cannot alter the already checked authored chain facts.
+        // Retain the same static authority across this known semantic append.
+        if let Some(plan) = &static_plan {
+            *plan.source_rows.lock().unwrap() = after_rows;
+        }
+        if let Some(ownership) = ownership {
+            self.semantic_ownership = Some(ownership);
+        }
+        let table = self.implied.as_mut().unwrap();
+        table.owned_results_state = result_state;
+        if let Some(graph) = graph {
+            table.specializations = graph;
+        }
+        if semantic_change {
+            self.invalidate_semantic_indexes();
+            self.supported_implied = static_plan;
+        }
+        self.dynamic_graph = Some(accepted);
+        self.publication.install(epoch);
+    }
+
+    fn discard_semantic_result_tail(&mut self) {
+        self.dynamic_graph = None;
+        let Some(table) = self.implied.as_ref() else {
+            self.publication.published();
+            return;
+        };
+        let boundary = table.owned_results_from;
+        let ownership = self
+            .semantic_ownership
+            .as_ref()
+            .unwrap()
+            .without_result_tail(boundary)
+            .expect("certified result tail");
+        // Validate the mutable-tail boundary before changing caches or rows.
+        assert!(self.elements.can_truncate_tail(boundary));
+        self.invalidate_semantic_indexes();
+        self.elements.truncate_tail(boundary);
+        self.semantic_ownership = Some(Arc::new(ownership));
+        self.implied.as_mut().unwrap().owned_results_state = OwnedResultState::Pending;
+        self.refresh_materialized_specializations();
+        self.publication.published();
+    }
+    fn refresh_materialized_specializations(&mut self) {
+        if self.implied.is_none() {
+            return;
+        }
+        let owners = self.semantic_relationship_owners();
+        let (_, graph) = self.required_specialization_edges(&[], self.elements.len(), &owners);
+        if let Some(table) = self.implied.as_mut() {
+            table.specializations = graph;
+        }
+    }
+    /// The former plan, used only to preserve identifiers for relationships
+    /// already emitted by earlier versions. It does not decide semantics.
+    fn legacy_implied_plan_with_owners(
+        &self,
+        i: usize,
+        names: &HashMap<String, Uuid>,
+        owners: &[Option<usize>],
+    ) -> Vec<PlannedEdge> {
+        self.legacy_implied_plan_with_budget(i, names, owners, None)
+            .expect("unbounded legacy recipe cannot exhaust budget")
+    }
+}
+
+#[cfg(test)]
+mod central_publication_tests {
+    use super::*;
+    fn fixture() -> ResolvedModel {
+        let mut m = crate::model::Model::new();
+        m.add_source(
+            "publication.kerml",
+            "feature original=4; feature use=original;",
+        );
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+    #[test]
+    fn stored_and_retained_report_reads_do_not_become_demands() {
+        let mut r = fixture();
+        let before = r.b.elements.len();
+        let original = r.resolve_qualified("original").unwrap();
+        assert_eq!(r.element_name(original), Some("original"));
+        let expression =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "FeatureReferenceExpression")
+                .unwrap();
+        let _report = r.model_level_evaluability(ElementRef(expression));
+        assert_eq!(r.b.elements.len(), before);
+        assert!(r.b.implied.is_none());
+        assert!(r.b.semantic_ownership.is_none());
+    }
+    #[test]
+    fn builder_and_resolved_demand_share_one_table_and_order() {
+        let mut direct = fixture();
+        let mut wrapped = fixture();
+        assert_eq!(
+            direct.b.ensure_semantic_graph(),
+            super::super::publication::Status::Ready
+        );
+        wrapped.ensure_implied();
+        let rows = |r: &ResolvedModel| {
+            r.b.elements
+                .iter()
+                .map(|e| (e.ty, e.id))
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(rows(&direct), rows(&wrapped));
+        let count = direct.b.elements.len();
+        let revision = direct.b.publication.revision();
+        direct.ensure_implied();
+        direct.ensure_implied();
+        assert_eq!(direct.b.elements.len(), count);
+        assert!(revision.same_as(&direct.b.publication.revision()));
+        assert_eq!(direct.by_id_built_for, count);
+    }
+    #[test]
+    fn suppressed_preparation_keeps_logical_readiness_without_publication() {
+        let mut r = fixture();
+        r.b.suppress_semantic_publication();
+        assert!(r.b.semantic_ready);
+        let count = r.b.elements.len();
+        assert_eq!(
+            r.b.ensure_semantic_graph(),
+            super::super::publication::Status::Construction
+        );
+        r.prepare_quantity_memo();
+        let _facts = r.b.prepare_facts();
+        assert_eq!(r.b.elements.len(), count);
+        assert!(r.b.implied.is_none());
+        assert!(r.b.semantic_ownership.is_none());
+    }
+    #[test]
+    fn prepared_build_and_decoded_install_keep_source_prefix_unpublished() {
+        let mut model = crate::model::Model::new();
+        model.add_library_source(
+            "publication-library.kerml",
+            "standard library package L { feature n=4; feature read=n; }",
+        );
+        assert!(!model.has_errors());
+        let prepared = model.prepare_library().unwrap();
+        assert!(prepared.builder.implied.is_none());
+        assert!(prepared.builder.semantic_ownership.is_none());
+        assert!(
+            prepared
+                .builder
+                .publication
+                .revision()
+                .same_as(&Default::default())
+        );
+        let decoded = Arc::new(
+            crate::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(918).unwrap(), 918)
+                .unwrap(),
+        );
+        assert!(decoded.builder.implied.is_none());
+        assert!(decoded.builder.semantic_ownership.is_none());
+        assert!(
+            decoded
+                .builder
+                .publication
+                .revision()
+                .same_as(&Default::default())
+        );
+        let mut replay = crate::model::Model::new();
+        decoded.install(&mut replay).unwrap();
+        replay.add_source("publication-user.kerml", "feature answer=L::n;");
+        let mut r = ResolvedModel::build(&replay);
+        assert!(r.b.implied.is_none());
+        assert!(r.b.semantic_ownership.is_none());
+        r.ensure_implied();
+        assert!(r.b.implied.is_some());
+        assert!(r.b.semantic_ownership.is_some());
+    }
+    #[test]
+    fn reentrant_demand_publishes_nothing_and_outer_retry_succeeds() {
+        let mut r = fixture();
+        let count = r.b.elements.len();
+        let guard = r.b.publication.begin(true).unwrap();
+        assert_eq!(
+            r.b.ensure_semantic_graph(),
+            super::super::publication::Status::Reentrant
+        );
+        assert_eq!(r.b.elements.len(), count);
+        assert!(r.b.implied.is_none());
+        drop(guard);
+        r.ensure_implied();
+        assert!(r.b.implied.is_some());
+    }
+    #[test]
+    fn equal_length_tail_republication_invalidates_resolved_memos() {
+        let mut r = fixture();
+        r.ensure_implied();
+        let count = r.b.elements.len();
+        let revision = r.b.publication.revision();
+        r.redefiner_index = Some(HashMap::new());
+        r.import_truncated.insert((0, true), true);
+        r.b.discard_semantic_result_tail();
+        assert_eq!(
+            r.b.ensure_semantic_graph(),
+            super::super::publication::Status::Ready
+        );
+        assert_eq!(r.b.elements.len(), count);
+        assert!(!revision.same_as(&r.b.publication.revision()));
+        // Entry sync is observation-only, and detects equal-size replacement.
+        r.ensure_by_id();
+        assert!(r.redefiner_index.is_none());
+        assert!(r.import_truncated.is_empty());
+        assert_eq!(r.by_id_built_for, count);
+    }
+}
+
+impl Builder {
+    pub(super) fn required_specialization_edges_with_fixed_prefix(
+        &mut self,
+        candidates: &[(usize, PlannedEdge)],
+        fixed: usize,
+        explicit_len: usize,
+        rel_owner: &[Option<usize>],
+        mut steps: Option<&mut usize>,
+    ) -> Option<(Vec<bool>, SpecializationGraph)> {
+        let chains = self.checked_chain_bases(explicit_len, steps.as_deref_mut())?;
+        self.required_specialization_edges_with_chain_bases(
+            candidates,
+            fixed,
+            explicit_len,
+            rel_owner,
+            &chains,
+            steps,
+        )
+    }
+
+    pub(super) fn required_specialization_edges_with_chain_bases(
+        &self,
+        candidates: &[(usize, PlannedEdge)],
+        fixed: usize,
+        explicit_len: usize,
+        rel_owner: &[Option<usize>],
+        chains: &super::type_relations::FeatureChainBases,
+        mut steps: Option<&mut usize>,
+    ) -> Option<(Vec<bool>, SpecializationGraph)> {
+        planning_charge(&mut steps, 1)?;
+        if fixed > candidates.len() {
+            return None;
+        }
+        let mut graph: HashMap<Uuid, Vec<(Uuid, Option<usize>)>> = HashMap::new();
+        for (r, relation) in self.elements.iter().take(explicit_len).enumerate() {
+            planning_charge(&mut steps, 1)?;
+            if !conforms(relation.ty, "Specialization") {
+                continue;
+            }
+            let source = [
+                "specific",
+                "subclassifier",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ]
+            .iter()
+            .find_map(|key| relation.props.get(key));
+            let source = match source {
+                Some(value) => value.as_reference(),
+                None => rel_owner[r].map(|owner| self.elements[owner].id),
+            };
+            let target = specialization_target(relation);
+            if let (Some(source), Some(target)) = (source, target) {
+                graph.entry(source).or_default().push((target, None));
+            }
+        }
+        for (index, &(owner, edge)) in candidates.iter().enumerate() {
+            planning_charge(&mut steps, 1)?;
+            graph
+                .entry(self.elements[owner].id)
+                .or_default()
+                .push((edge.3, Some(index)));
+        }
+        for (&source, &target) in &chains.targets {
+            planning_charge(&mut steps, 1)?;
+            graph
+                .entry(self.elements[source].id)
+                .or_default()
+                .push((self.elements[target].id, None));
+        }
+        // Consider dependents before their bases. On a long inheritance
+        // chain, each candidate can then find the next ancestor's still-live
+        // base edge immediately instead of repeatedly walking to the root.
+        // Reverse DFS postorder also handles cycles without recursion.
+        let mut visited = HashSet::new();
+        let mut postorder = Vec::new();
+        let mut todo = Vec::new();
+        for &(owner, _) in candidates {
+            planning_charge(&mut steps, 1)?;
+            let source = self.elements[owner].id;
+            // Each prior DFS drains before the next candidate. An already
+            // visited source therefore has a complete postorder, including
+            // cyclic graphs. Repeated candidates need no new traversal stack.
+            if visited.contains(&source) {
+                continue;
+            }
+            todo.push((source, false));
+            while let Some((at, exiting)) = todo.pop() {
+                planning_charge(&mut steps, 1)?;
+                if exiting {
+                    postorder.push(at);
+                } else if visited.insert(at) {
+                    todo.push((at, true));
+                    planning_charge(&mut steps, graph.get(&at).map_or(0, Vec::len))?;
+                    todo.extend(
+                        graph
+                            .get(&at)
+                            .into_iter()
+                            .flatten()
+                            .map(|&(next, _)| (next, false)),
+                    );
+                }
+            }
+        }
+        planning_charge(&mut steps, postorder.len())?;
+        let rank: HashMap<_, _> = postorder
+            .into_iter()
+            .enumerate()
+            .map(|(rank, id)| (id, rank))
+            .collect();
+        // Rank is dense. Stable buckets produce exactly the previous stable
+        // descending-rank order without comparing every candidate O(log n)
+        // times. Keeping each bucket in candidate order preserves cycle anchors
+        // and the fixed prefix while avoiding a second semantic graph.
+        let order = reverse_rank_order(
+            fixed..candidates.len(),
+            rank.len(),
+            |index| rank[&self.elements[candidates[index].0].id],
+            &mut steps,
+        )?;
+        planning_charge(&mut steps, candidates.len())?;
+        let mut retained = vec![true; candidates.len()];
+        let mut seen = HashSet::new();
+        let mut stack = Vec::new();
+        for index in order {
+            planning_charge(&mut steps, 1)?;
+            let (owner, edge) = candidates[index];
+            // A ReferenceSubsetting identifies an end, not merely a reachable
+            // superfeature. Keep the required relationship itself.
+            if edge.0 == "ReferenceSubsetting" {
+                continue;
+            }
+            retained[index] = false;
+            seen.clear();
+            stack.clear();
+            stack.push(self.elements[owner].id);
+            let mut reaches = false;
+            while let Some(at) = stack.pop() {
+                planning_charge(&mut steps, 1)?;
+                if at == edge.3 {
+                    reaches = true;
+                    break;
+                }
+                if !seen.insert(at) {
+                    continue;
+                }
+                for &(next, candidate) in graph.get(&at).into_iter().flatten() {
+                    planning_charge(&mut steps, 1)?;
+                    if candidate.is_none_or(|candidate| retained[candidate]) {
+                        // Reachability consumes a Boolean, not a traversal
+                        // sequence. A witnessed edge can decide immediately.
+                        if next == edge.3 {
+                            reaches = true;
+                            break;
+                        }
+                        stack.push(next);
+                    }
+                }
+                if reaches {
+                    break;
+                }
+            }
+            retained[index] = !reaches;
+        }
+        let mut final_graph = HashMap::new();
+        for (source, edges) in graph {
+            planning_charge(&mut steps, 1)?;
+            let mut targets = Vec::new();
+            for (target, candidate) in edges {
+                planning_charge(&mut steps, 1 + targets.len())?;
+                if candidate.is_none_or(|candidate| retained[candidate])
+                    && !targets.contains(&target)
+                {
+                    targets.push(target);
+                }
+            }
+            final_graph.insert(source, targets);
+        }
+        Some((retained, final_graph))
+    }
+}
+
+impl Builder {
+    pub(super) fn static_specialization_prefix(
+        &mut self,
+        names: &HashMap<String, Uuid>,
+        library_configuration: bool,
+        steps: Option<&mut usize>,
+    ) -> Option<Arc<super::semantic_batch::StaticPrefix>> {
+        self.static_specialization_prefix_with_workspace(
+            names,
+            library_configuration,
+            steps,
+            &mut super::positional::PositionalWorkspace::one_shot(),
+        )
+    }
+
+    pub(super) fn static_specialization_prefix_with_workspace(
+        &mut self,
+        names: &HashMap<String, Uuid>,
+        library_configuration: bool,
+        mut steps: Option<&mut usize>,
+        workspace: &mut super::positional::PositionalWorkspace,
+    ) -> Option<Arc<super::semantic_batch::StaticPrefix>> {
+        let required = self.supported_implied_specializations_with_budget(
+            names,
+            library_configuration,
+            steps.as_deref_mut(),
+        )?;
+        let (direct_bases, incomplete_bases) =
+            self.positional_direct_bases_from_static_plan(&required, steps.as_deref_mut())?;
+        let positional = self.plan_positional_redefinitions_with_workspace(
+            &direct_bases,
+            &incomplete_bases,
+            steps.as_deref_mut(),
+            workspace,
+        )?;
+        planning_charge(&mut steps, self.elements.len())?;
+        for element in &self.elements {
+            planning_charge(&mut steps, element.owned_relationships.len())?;
         }
-        self.ensure_by_id();
-        self.ensure_rel_owner();
-        let from = self.b.elements.len();
-        let lib_by_name: HashMap<String, Uuid> = self
-            .b
-            .lib_qnames
-            .iter()
-            .map(|(id, segments)| (segments.join("::"), *id))
-            .chain(
-                self.external_by_name
-                    .iter()
-                    .map(|(name, id)| (name.clone(), *id)),
-            )
-            .collect();
-        let mut owner_of: Vec<usize> = Vec::new();
-        let mut by_owner: HashMap<usize, Vec<usize>> = HashMap::new();
-        // User elements only, as the emitter did: the library's own
-        // elements specialize explicitly. No bases known, nothing at all.
-        let range = if lib_by_name.is_empty() {
-            0..0
-        } else {
-            self.b.lib_boundary..from
-        };
-        for i in range {
-            let plan = self.implied_plan(i, &lib_by_name);
-            if plan.is_empty() {
+        let owners = self.specialization_relation_owners();
+        let mut rows = Vec::new();
+        for (index, &(owner, edge)) in required.candidates.iter().enumerate() {
+            planning_charge(&mut steps, 1)?;
+            if !required.retained[index] {
                 continue;
             }
-            let owner_id = self.b.elements[i].id;
-            for (n, (rel_ty, src_key, tgt_key, target)) in plan.into_iter().enumerate() {
-                let id = Uuid::new_v5(
-                    &Uuid::NAMESPACE_OID,
-                    format!("{owner_id}/implied{n}").as_bytes(),
-                );
-                let mut props = crate::properties::Properties::new();
-                props.insert("isImplied", json!(true));
-                props.insert(src_key, json!({ "@id": owner_id.to_string() }));
-                props.insert(tgt_key, json!({ "@id": target.to_string() }));
-                self.b.elements.push(Elem {
-                    ty: rel_ty,
-                    id,
-                    path: String::new(),
-                    props,
-                    owned_relationships: Default::default(),
-                    children: Default::default(),
-                    owning_relationship: None,
-                });
-                let idx = self.b.elements.len() - 1;
-                owner_of.push(i);
-                by_owner.entry(i).or_default().push(idx);
+            let legacy_slot = if owner >= self.lib_boundary {
+                self.legacy_implied_plan_with_budget(owner, names, &owners, steps.as_deref_mut())?
+                    .iter()
+                    .position(|old| *old == edge)
+            } else {
+                None
+            };
+            rows.push(static_recipe(
+                self.elements[owner].id,
+                owner,
+                edge,
+                legacy_slot,
+            ));
+        }
+        planning_charge(
+            &mut steps,
+            positional.targets.len().saturating_mul(
+                (usize::BITS - positional.targets.len().max(1).leading_zeros()) as usize + 1,
+            ),
+        )?;
+        let mut sources: Vec<_> = positional.targets.keys().copied().collect();
+        sources.sort_unstable();
+        for source in sources {
+            let targets = &positional.targets[&source];
+            planning_charge(&mut steps, targets.len())?;
+            for &target in targets {
+                rows.push(static_recipe(
+                    self.elements[source].id,
+                    source,
+                    (
+                        "Redefinition",
+                        "redefiningFeature",
+                        "redefinedFeature",
+                        self.elements[target].id,
+                    ),
+                    None,
+                ));
             }
         }
-        self.b.implied_from = Some(from);
-        self.implied = Some(ImpliedTable {
-            from,
-            owner_of,
-            by_owner,
-        });
-        // The lazy maps are keyed on the element count: rebuild them so
-        // the new relationships have ids and owners.
-        self.ensure_by_id();
-        self.rel_owner.clear();
-        self.ensure_rel_owner();
+        let mut specializations = HashMap::new();
+        for (&source, targets) in &required.graph {
+            planning_charge(&mut steps, targets.len().saturating_add(1))?;
+            specializations.insert(source, targets.clone());
+        }
+        for row in &rows {
+            planning_charge(&mut steps, 1)?;
+            let targets = specializations.entry(row.owner_id).or_insert_with(Vec::new);
+            planning_charge(&mut steps, targets.len().saturating_add(1))?;
+            if !targets.contains(&row.target) {
+                targets.push(row.target);
+            }
+        }
+        Some(Arc::new(super::semantic_batch::StaticPrefix {
+            authored_end: self.explicit_len(),
+            rows,
+            positional: Arc::new(positional),
+            planner_bases: direct_bases,
+            planner_incomplete: incomplete_bases,
+            chain_bases: Arc::clone(&required.chain_bases),
+            specializations,
+        }))
     }
+}
+
+fn static_recipe(
+    owner_id: Uuid,
+    owner: usize,
+    edge: PlannedEdge,
+    legacy_slot: Option<usize>,
+) -> super::semantic_batch::Edge {
+    let (kind, source_key, target_key, target) = edge;
+    let key = match legacy_slot {
+        Some(n) => format!("{owner_id}/implied{n}"),
+        None => format!("{owner_id}/implied/{kind}/{target}"),
+    };
+    super::semantic_batch::Edge {
+        owner,
+        owner_id,
+        id: Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()),
+        kind,
+        source_key,
+        target_key,
+        target,
+    }
+}
 
-    /// The implied relationships element `i` gets: `(metaclass, source
-    /// key, target key, target id)`, in emission order.
-    fn implied_plan(
+impl Builder {
+    fn legacy_implied_plan_with_budget(
         &self,
         i: usize,
         lib_by_name: &HashMap<String, Uuid>,
-    ) -> Vec<(&'static str, &'static str, &'static str, Uuid)> {
-        let t = self.b.elements[i].ty;
+        rel_owner: &[Option<usize>],
+        mut steps: Option<&mut usize>,
+    ) -> Option<Vec<(&'static str, &'static str, &'static str, Uuid)>> {
+        planning_charge(
+            &mut steps,
+            self.elements[i]
+                .owned_relationships
+                .len()
+                .saturating_mul(4)
+                .saturating_add(1),
+        )?;
+        let t = self.elements[i].ty;
         let mut plan = Vec::new();
-        let explicit: Vec<usize> = self.b.elements[i].owned_relationships.to_vec();
+        let explicit: Vec<usize> = self.elements[i].owned_relationships.to_vec();
         // Tables 31/32: the library bases of the element's kind, unless an
         // explicit specialization of the covering kind is present
         // (anti-redundancy, approximated as any explicit same-kind
@@ -170,9 +4483,10 @@ impl ResolvedModel {
             })
         };
         if let Some((bases, rel_ty, src, tgt, covering)) = bases {
+            planning_charge(&mut steps, bases.len())?;
             let covered = explicit
                 .iter()
-                .any(|&r| covering.contains(&self.b.elements[r].ty));
+                .any(|&r| covering.contains(&self.elements[r].ty));
             if !covered {
                 for base in bases {
                     if let Some(&id) = lib_by_name.get(*base) {
@@ -188,21 +4502,21 @@ impl ResolvedModel {
         // one is recognized here (`variant part small : Sub` with `Sub :>
         // Box` still gets the implied typing by `Box`), the same
         // approximation as the covering rule above.
-        if let Some(rel) = self.b.elements[i].owning_relationship {
-            if self.b.elements[rel].ty == "VariantMembership" {
-                if let Some(variation) = self.rel_owner[rel] {
-                    let variation_id = self.b.elements[variation].id;
+        if let Some(rel) = self.elements[i].owning_relationship {
+            if self.elements[rel].ty == "VariantMembership" {
+                if let Some(variation) = rel_owner[rel] {
+                    let variation_id = self.elements[variation].id;
                     let targets = |kinds: &[&str], key: &str| -> bool {
                         explicit.iter().any(|&r| {
-                            kinds.contains(&self.b.elements[r].ty)
-                                && self.b.elements[r]
+                            kinds.contains(&self.elements[r].ty)
+                                && self.elements[r]
                                     .props
                                     .get(key)
                                     .and_then(|v| v.as_reference())
                                     == Some(variation_id)
                         })
                     };
-                    let vty = self.b.elements[variation].ty;
+                    let vty = self.elements[variation].ty;
                     if conforms(vty, "Definition") {
                         if !targets(&["FeatureTyping", "ConjugatedPortTyping"], "type") {
                             plan.push(("FeatureTyping", "typedFeature", "type", variation_id));
@@ -223,36 +4537,1517 @@ impl ResolvedModel {
                 }
             }
         }
-        plan
+        Some(plan)
     }
+}
 
-    /// The implied relationships `e` owns — the library specializations
-    /// of its kind (SysML Tables 31/32) and a variant's specialization of
-    /// its variation — as relationship elements of the model, in
-    /// emission order. Materialized for the whole model on first call
-    /// (see the module documentation); empty for a library element, and
-    /// for every element of a model built without its library and
-    /// without a library name table ([`Self::set_library_names`]).
-    pub fn implied_relationships(&mut self, e: ElementRef) -> Vec<ElementRef> {
-        self.ensure_implied();
-        self.implied
-            .as_ref()
-            .and_then(|t| t.by_owner.get(&e.0))
-            .map(|v| v.iter().copied().map(ElementRef).collect())
-            .unwrap_or_default()
+#[cfg(test)]
+mod feature_chain_operator_tests {
+    use super::*;
+    use crate::{
+        json::{ElementRef, ResolvedModel},
+        model::Model,
+    };
+    const LIB: &str = "standard library package ControlFunctions {function '.' {in source {feature target;} return result;}}";
+    const USER: &str = "class A {feature x;} feature a:A; feature y=a.x;";
+    fn fixture(library: &str) -> (ResolvedModel, usize, usize) {
+        let mut m = Model::new();
+        assert!(
+            m.add_library_source("dot-library.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(m.add_source("dot-user.kerml", USER).diagnostics.is_empty());
+        let r = ResolvedModel::build(&m);
+        let chain = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureChainExpression")
+            .unwrap()
+            .0;
+        let parameter = r.b.elements[chain]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "ParameterMembership")
+            .unwrap();
+        let input = r.b.elements[parameter].children[0];
+        (r, chain, input)
+    }
+    fn typing(r: &mut ResolvedModel, chain: usize) -> Vec<Uuid> {
+        r.implied_relationships(ElementRef(chain))
+            .into_iter()
+            .filter(|&rel| r.element_type(rel) == "FeatureTyping")
+            .filter_map(|rel| {
+                r.b.elements[rel.0]
+                    .props
+                    .get("type")
+                    .and_then(|v| v.as_reference())
+            })
+            .collect()
+    }
+    #[test]
+    fn fixed_dot_function_typing_and_input_redefinition_share_the_static_plan() {
+        let (mut r, chain, input) = fixture(LIB);
+        let dot = r.resolve_qualified("ControlFunctions::'.'").unwrap();
+        let source = r
+            .resolve_qualified("ControlFunctions::'.'::source")
+            .unwrap();
+        let authored: Vec<_> = r.b.elements.iter().map(|e| e.id).collect();
+        assert_eq!(typing(&mut r, chain), vec![r.element_id(dot)]);
+        assert!(
+            r.b.semantic_redefinition_targets(input, true)
+                .contains(&source.0)
+        );
+        assert!(
+            r.b.completed_positional_targets(input)
+                .unwrap()
+                .contains(&source.0)
+        );
+        assert_eq!(
+            r.b.elements
+                .iter()
+                .take(authored.len())
+                .map(|e| e.id)
+                .collect::<Vec<_>>(),
+            authored
+        );
+        assert!(r.feature_type_report(ElementRef(chain)).function.is_err());
+    }
+    #[test]
+    fn fixed_dot_role_requires_a_loaded_unique_function_and_exact_operator() {
+        for kind in ["feature", "class", "behavior", "expr"] {
+            let (mut r, chain, _) = fixture(&format!(
+                "standard library package ControlFunctions {{{kind} '.';}}"
+            ));
+            assert!(typing(&mut r, chain).is_empty(), "{kind}");
+        }
+        for operator in [
+            serde_json::json!("+"),
+            serde_json::Value::Null,
+            serde_json::json!(false),
+        ] {
+            let (mut r, chain, _) = fixture(LIB);
+            r.b.elements[chain].props.insert("operator", operator);
+            assert!(typing(&mut r, chain).is_empty());
+        }
+        let (mut r, chain, _) = fixture(LIB);
+        let user = r.resolve_qualified("a").unwrap();
+        let id = r.element_id(user);
+        r.b.lib_qnames
+            .push((id, vec!["ControlFunctions".into(), ".".into()]));
+        assert!(typing(&mut r, chain).is_empty());
+        let (mut r, chain, _) = fixture(LIB);
+        let dot = r.resolve_qualified("ControlFunctions::'.'").unwrap();
+        let user = r.resolve_qualified("a").unwrap();
+        r.b.elements[user.0].id = r.element_id(dot);
+        assert!(typing(&mut r, chain).is_empty());
+    }
+    #[test]
+    fn absent_fixed_operator_uses_default_but_external_spelling_does_not_certify_role() {
+        let (mut r, chain, _) = fixture(LIB);
+        let mut props = r.b.elements[chain].props.to_json();
+        props.remove("operator");
+        let mut retained = crate::properties::Properties::new();
+        for (key, value) in props {
+            retained.insert(&key, value);
+        }
+        r.b.elements[chain].props = retained;
+        assert_eq!(typing(&mut r, chain).len(), 1);
+        let (mut r, chain, _) = fixture("");
+        let id = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"external dot role");
+        r.set_library_names(&HashMap::from([(
+            id.to_string(),
+            vec!["ControlFunctions".into(), ".".into()],
+        )]));
+        assert!(typing(&mut r, chain).is_empty());
+    }
+    #[test]
+    fn fixed_dot_bounded_planning_refuses_before_publication_and_retries() {
+        let (mut r, chain, input) = fixture(LIB);
+        let source = r
+            .resolve_qualified("ControlFunctions::'.'::source")
+            .unwrap();
+        r.b.positional_redefinitions = None;
+        r.b.supported_implied = None;
+        let count = r.b.elements.len();
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert!(!r.b.ensure_positional_redefinitions_with_budget(&mut steps));
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(r.b.implied.is_none());
+        assert_eq!(r.b.elements.len(), count);
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(
+            r.b.completed_positional_targets(input)
+                .unwrap()
+                .contains(&source.0)
+        );
+        assert_eq!(typing(&mut r, chain).len(), 1);
     }
 
-    /// `Element::ownedRelationship` with the implied relationships
-    /// included, as the specification lists them: the explicit ones in
-    /// declaration order, then the implied ones.
-    pub(super) fn d_owned_relationships(&mut self, e: ElementRef) -> Vec<ElementRef> {
-        let mut out = self.owned_relationships(e);
-        out.extend(self.implied_relationships(e));
-        out
+    #[test]
+    fn actual_dot_library_reuses_checked_parameter_identity() {
+        let mut m = Model::new();
+        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        m.load_library_dir(&path).unwrap();
+        m.add_source("actual-dot.kerml", USER);
+        let mut r = ResolvedModel::build(&m);
+        let chain = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureChainExpression")
+            .unwrap()
+            .0;
+        let parameter = r.b.elements[chain]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "ParameterMembership")
+            .unwrap();
+        let raw =
+            super::super::structural_index::StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        let input = super::super::membership_evidence::member(&r.b, &raw, chain, parameter, &mut 0)
+            .unwrap();
+        let dot = r.resolve_qualified("ControlFunctions::'.'").unwrap();
+        let source = r
+            .resolve_qualified("ControlFunctions::'.'::source")
+            .unwrap();
+        assert_eq!(typing(&mut r, chain), vec![r.element_id(dot)]);
+        assert!(
+            r.b.semantic_redefinition_targets(input, true)
+                .contains(&source.0)
+        );
     }
+}
 
-    /// Whether `e` is a materialized implied relationship.
-    pub fn is_implied(&self, e: ElementRef) -> bool {
-        self.implied.as_ref().is_some_and(|t| e.0 >= t.from)
+#[cfg(test)]
+mod partial_expression_role_tests {
+    use super::*;
+    use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+
+    const GENERIC: &str = "standard library package Values {datatype Value;} standard library package Performances {function Evaluation {return result:Values::Value;} expr evaluations:Evaluation;";
+    const USER: &str = "class C; feature constructed=new C(); feature literal=1; feature decoy;";
+
+    fn models(library: &str) -> Vec<ResolvedModel> {
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("partial-roles.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(127).unwrap(), 127).unwrap());
+        (0..4)
+            .map(|mode| {
+                let mut model = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.add_library_source("partial-roles.kerml", library);
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                assert!(
+                    model
+                        .add_source("partial-roles-user.kerml", USER)
+                        .diagnostics
+                        .is_empty()
+                );
+                ResolvedModel::build(&model)
+            })
+            .collect()
+    }
+
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, parts)| (parts.join("::"), *id))
+            .collect()
+    }
+
+    fn expression(r: &ResolvedModel, ty: &str) -> ElementRef {
+        r.user_elements()
+            .find(|&e| r.element_type(e) == ty)
+            .unwrap()
+    }
+
+    fn retained(plan: &SupportedImpliedSpecializations, owner: usize) -> Vec<Uuid> {
+        plan.candidates
+            .iter()
+            .enumerate()
+            .filter_map(|(i, (at, edge))| (*at == owner && plan.retained[i]).then_some(edge.3))
+            .collect()
+    }
+
+    #[test]
+    fn actually_missing_leaf_and_constructor_roles_keep_broader_ancestry_across_replay() {
+        for literal_role in [false, true] {
+            let library = format!(
+                "{GENERIC} {} }}",
+                if literal_role {
+                    "expr literalEvaluations subsets evaluations;"
+                } else {
+                    ""
+                }
+            );
+            let mut expected = None;
+            for mut r in models(&library) {
+                let sources: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+                let generic = r.resolve_qualified("Performances::evaluations").unwrap();
+                let literal = expression(&r, "LiteralInteger");
+                let constructor = expression(&r, "ConstructorExpression");
+                let literal_base = if literal_role {
+                    r.resolve_qualified("Performances::literalEvaluations")
+                        .unwrap()
+                } else {
+                    generic
+                };
+                let mut ids = Vec::new();
+                for (owner, target) in [(literal, literal_base), (constructor, generic)] {
+                    assert!(r.conforms_with_implied(owner, generic));
+                    let rows = r.implied_relationships(owner);
+                    assert_eq!(
+                        rows.len(),
+                        1,
+                        "only the available broader Subsetting is retained"
+                    );
+                    let row = &r.b.elements[rows[0].0];
+                    assert_eq!(row.ty, "Subsetting");
+                    assert_eq!(specialization_target(row), Some(r.element_id(target)));
+                    let key = format!(
+                        "{}/implied/Subsetting/{}",
+                        r.element_id(owner),
+                        r.element_id(target)
+                    );
+                    assert_eq!(row.id, Uuid::new_v5(&Uuid::NAMESPACE_OID, key.as_bytes()));
+                    ids.push(row.id);
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(&ids, expected);
+                } else {
+                    expected = Some(ids);
+                }
+                assert!(r.b.planned_literal_target("LiteralInteger").is_none());
+                assert!(
+                    r.b.literal_inherited_memberships(literal.0, true)
+                        .incomplete,
+                    "even a typed broader return cannot certify a missing leaf role"
+                );
+                assert!(matches!(
+                    r.model_level_evaluability(constructor).classification,
+                    crate::json::ModelLevelEvaluability::Unknown(_)
+                ));
+                assert!(
+                    r.b.semantic_ownership
+                        .as_ref()
+                        .unwrap()
+                        .result(constructor.0)
+                        .is_none()
+                );
+                assert_eq!(
+                    sources,
+                    r.user_elements()
+                        .map(|e| r.element_id(e))
+                        .collect::<Vec<_>>()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn all_leaf_kinds_accumulate_independent_generic_and_literal_requirements() {
+        // Deliberately disconnected roles: availability of the leaf role says
+        // nothing about whether the library supplied its required ancestry.
+        let library = format!(
+            "{GENERIC} expr literalEvaluations; expr literalBooleanEvaluations; expr literalIntegerEvaluations; expr literalRationalEvaluations; expr literalStringEvaluations; expr nullEvaluations; expr metadataAccessEvaluations; expr constructorEvaluations; }}"
+        );
+        for ty in [
+            "LiteralBoolean",
+            "LiteralInteger",
+            "LiteralInfinity",
+            "LiteralRational",
+            "LiteralString",
+            "NullExpression",
+            "MetadataAccessExpression",
+            "ConstructorExpression",
+        ] {
+            let mut r = models(&library).remove(0);
+            let owner = expression(&r, "LiteralInteger");
+            // Planning depends on metaclass, not literal value. This exercises
+            // abstract-syntax kinds without pretending they share text syntax.
+            r.b.elements[owner.0].ty = ty;
+            let configuration = names(&r);
+            let plan = r.b.supported_implied_specializations(&configuration, true);
+            let mut expected = vec![configuration[expression_implied_base(ty).unwrap()]];
+            if conforms(ty, "LiteralExpression") {
+                expected.push(configuration["Performances::literalEvaluations"]);
+            }
+            expected.push(configuration["Performances::evaluations"]);
+            let actual: Vec<_> = plan
+                .candidates
+                .iter()
+                .filter_map(|(at, edge)| (*at == owner.0).then_some(edge.3))
+                .collect();
+            assert_eq!(
+                actual, expected,
+                "{ty}: every independent obligation is planned"
+            );
+            let survivors = retained(&plan, owner.0);
+            for target in expected {
+                let target = ElementRef(r.b.element_index_of_uuid(target).unwrap());
+                assert!(
+                    r.conforms_with_implied(owner, target),
+                    "{ty}: required target remains reachable"
+                );
+            }
+            assert!(!survivors.is_empty());
+        }
+    }
+
+    #[test]
+    fn invalid_narrow_roles_do_not_suppress_available_broader_roles() {
+        let library = format!(
+            "{GENERIC} expr literalEvaluations subsets evaluations; expr literalIntegerEvaluations subsets literalEvaluations; expr constructorEvaluations subsets evaluations; expr other; }}"
+        );
+        for (ty, role, parent) in [
+            (
+                "LiteralInteger",
+                "Performances::literalIntegerEvaluations",
+                "Performances::literalEvaluations",
+            ),
+            (
+                "ConstructorExpression",
+                "Performances::constructorEvaluations",
+                "Performances::evaluations",
+            ),
+        ] {
+            for problem in 0..6 {
+                let mut r = models(&library).remove(0);
+                let owner = expression(&r, ty);
+                let target = r.resolve_qualified(role).unwrap();
+                let mut configuration = names(&r);
+                match problem {
+                    0 => {
+                        configuration.remove(role);
+                    }
+                    1 => {
+                        r.b.elements[target.0].ty = "Class";
+                    }
+                    2 => {
+                        r.b.elements[target.0].ty = "Feature";
+                    }
+                    3 => {
+                        r.b.elements[target.0].ty = "Step";
+                    }
+                    4 => {
+                        let other = r.resolve_qualified("Performances::other").unwrap();
+                        r.b.lib_qnames.push((
+                            r.element_id(other),
+                            role.split("::").map(str::to_owned).collect(),
+                        ));
+                    }
+                    5 => {
+                        let decoy = r.resolve_qualified("decoy").unwrap();
+                        configuration.insert(role.into(), r.element_id(decoy));
+                    }
+                    _ => unreachable!(),
+                }
+                r.b.id_index = None;
+                r.b.supported_implied = None;
+                let plan = r.b.supported_implied_specializations(&configuration, true);
+                assert_eq!(
+                    retained(&plan, owner.0),
+                    vec![configuration[parent]],
+                    "{ty}: invalid role {problem}"
+                );
+                assert!(
+                    !plan
+                        .candidates
+                        .iter()
+                        .any(|(at, edge)| *at == owner.0 && edge.3 == r.element_id(target))
+                );
+                assert!(!plan.expression_targets.contains_key(role));
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod generic_feature_tests {
+    use super::*;
+    use crate::{json::model_to_compact_json, model::Model};
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything; feature narrow subsets things;}";
+    fn fixture() -> (Model, ResolvedModel) {
+        let mut m = Model::new();
+        assert!(
+            m.add_library_source("generic-feature.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(m.add_source("kinds.kerml","feature plain; var feature variable; class C {end feature e; portion feature piece;} step s; expr x; feature narrower subsets Base::narrow;").diagnostics.is_empty());
+        assert!(
+            m.add_source("usages.sysml", "part def P {ref r; end item e; action a;}")
+                .diagnostics
+                .is_empty()
+        );
+        let r = ResolvedModel::build(&m);
+        (m, r)
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, q)| (q.join("::"), *id))
+            .collect()
+    }
+    fn required(r: &mut ResolvedModel, owner: usize) -> Vec<Uuid> {
+        let plan = r.b.supported_implied_specializations(&names(r), true);
+        plan.candidates
+            .iter()
+            .filter_map(|(e, edge)| (*e == owner).then_some(edge.3))
+            .collect()
+    }
+    #[test]
+    fn feature_ancestry_applies_to_variable_end_portion_and_usage_descendants() {
+        let (_, mut r) = fixture();
+        let target = r.resolve_qualified("Base::things").unwrap();
+        let id = r.element_id(target);
+        for name in [
+            "plain", "variable", "C::e", "C::piece", "s", "x", "P::r", "P::e", "P::a",
+        ] {
+            let e = r.resolve_qualified(name).unwrap();
+            assert!(required(&mut r, e.0).contains(&id), "{name}");
+        }
+        let classifier = r.resolve_qualified("C").unwrap();
+        assert!(!required(&mut r, classifier.0).contains(&id));
+        // Independent unconditional ancestry is not a Boolean validity proof.
+        let plain = r.resolve_qualified("plain").unwrap();
+        r.b.set(plain.0, "isVariable", json!("malformed"));
+        r.b.supported_implied = None;
+        assert!(required(&mut r, plain.0).contains(&id));
+    }
+    #[test]
+    fn feature_role_requires_unique_loaded_feature_identity() {
+        for mode in 0..5 {
+            let (_, mut r) = fixture();
+            let e = r.resolve_qualified("plain").unwrap();
+            let target = r.resolve_qualified("Base::things").unwrap();
+            let mut configuration = names(&r);
+            match mode {
+                0 => {
+                    configuration.remove(FEATURE_BASE);
+                }
+                1 => r.b.elements[target.0].ty = "Class",
+                2 => {
+                    let other = r.resolve_qualified("Base::narrow").unwrap();
+                    r.b.lib_qnames
+                        .push((r.element_id(other), vec!["Base".into(), "things".into()]));
+                }
+                3 => {
+                    let other = r.resolve_qualified("Base::narrow").unwrap();
+                    r.b.elements[other.0].id = r.element_id(target);
+                }
+                _ => {
+                    configuration.insert(
+                        FEATURE_BASE.into(),
+                        Uuid::new_v5(&Uuid::NAMESPACE_OID, b"unloaded-feature-role"),
+                    );
+                }
+            }
+            r.b.id_index = None;
+            r.b.supported_implied = None;
+            let plan = r.b.supported_implied_specializations(&configuration, false);
+            assert!(
+                !plan.expression_targets.contains_key(FEATURE_BASE),
+                "mode {mode}"
+            );
+            assert!(!plan.candidates.iter().any(|(owner, _)| *owner == e.0));
+        }
+    }
+    #[test]
+    fn generic_requirement_minimizes_self_and_indirect_paths_and_preserves_source_identity() {
+        let (m, mut r) = fixture();
+        let compact = model_to_compact_json(&m);
+        let source: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let base = r.resolve_qualified(FEATURE_BASE).unwrap();
+        let narrower = r.resolve_qualified("narrower").unwrap();
+        let plain = r.resolve_qualified("plain").unwrap();
+        let base_id = r.element_id(base);
+        let relationships = r.implied_relationships(plain);
+        let edge = relationships
+            .iter()
+            .find(|&&e| specialization_target(&r.b.elements[e.0]) == Some(base_id))
+            .unwrap();
+        assert_eq!(r.element_type(*edge), "Subsetting");
+        assert_eq!(
+            r.element_id(*edge),
+            Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{}/implied/Subsetting/{base_id}", r.element_id(plain)).as_bytes()
+            )
+        );
+        for owner in [base, narrower] {
+            assert!(
+                !r.implied_relationships(owner)
+                    .iter()
+                    .any(|e| specialization_target(&r.b.elements[e.0]) == Some(base_id))
+            );
+        }
+        assert!(r.conforms_with_implied(narrower, base));
+        assert_eq!(
+            source,
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(compact, model_to_compact_json(&m));
+    }
+    #[test]
+    fn generic_feature_plan_exhaustion_is_unpublished_and_retryable() {
+        let (_, mut r) = fixture();
+        r.b.supported_implied = None;
+        let names = names(&r);
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(
+            r.b.supported_implied_specializations_with_budget(&names, true, Some(&mut steps))
+                .is_none()
+        );
+        assert!(r.b.supported_implied.is_none());
+        assert!(
+            r.b.supported_implied_specializations_with_budget(&names, true, Some(&mut 0))
+                .is_some()
+        );
+    }
+}
+
+#[cfg(test)]
+mod reduction_rank_tests {
+    use super::*;
+
+    #[test]
+    fn buckets_preserve_stable_comparison_order_for_every_fixed_prefix() {
+        // Exhaust all four-rank words up to length seven, including ties,
+        // empty ranks and every immutable prefix used by dynamic reduction.
+        for len in 0..=7 {
+            for word in 0..4usize.pow(len as u32) {
+                let ranks: Vec<_> = (0..len).map(|shift| (word >> (shift * 2)) & 3).collect();
+                for fixed in 0..=len {
+                    let mut expected: Vec<_> = (fixed..len).collect();
+                    expected.sort_by_key(|&i| std::cmp::Reverse(ranks[i]));
+                    let mut steps = 0;
+                    let actual =
+                        reverse_rank_order(fixed..len, 4, |i| ranks[i], &mut Some(&mut steps))
+                            .unwrap();
+                    assert_eq!(actual, expected, "ranks={ranks:?}, fixed={fixed}");
+                    assert_eq!(steps, 8 + 2 * (len - fixed));
+                }
+            }
+        }
+        assert_eq!(
+            reverse_rank_order(0..0, 0, |_| unreachable!(), &mut None),
+            Some(vec![])
+        );
+    }
+
+    #[test]
+    fn exhausted_order_is_not_published_and_fresh_budget_retries() {
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(reverse_rank_order(0..3, 3, |i| i, &mut Some(&mut exhausted)).is_none());
+        let mut mid = crate::eval::MAX_STEPS - 4;
+        assert!(reverse_rank_order(0..3, 3, |i| i, &mut Some(&mut mid)).is_none());
+        let mut fresh = 0;
+        assert_eq!(
+            reverse_rank_order(0..3, 3, |i| i, &mut Some(&mut fresh)),
+            Some(vec![2, 1, 0])
+        );
+    }
+}
+
+#[cfg(test)]
+mod checked_chain_base_tests {
+    use super::*;
+    use crate::{json::id_ref, model::Model};
+
+    fn fixture() -> ResolvedModel {
+        let mut model = Model::new();
+        let parsed=model.add_source("chain-bases.kerml", "function F {in p; return r;} class Holder {feature fnMember:F {end feature terminal;}} feature h:Holder; feature chain chains h.fnMember; feature next subsets chain {end feature q;} feature call=chain(1);");
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        ResolvedModel::build(&model)
+    }
+    #[test]
+    fn static_producer_rebuilds_positional_evidence_before_sharing_its_prefix() {
+        for format in [
+            crate::model::GraphFormat::LegacyV2,
+            crate::model::GraphFormat::CanonicalV3,
+        ] {
+            let mut model = Model::with_graph_format(format);
+            let parsed = model.add_source(
+                "producer-evidence.kerml",
+                "class A {end feature a;} class B specializes A {end feature b;}",
+            );
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let a = r.resolve_qualified("A::a").unwrap();
+            let b = r.resolve_qualified("B::b").unwrap();
+            r.b.ensure_positional_redefinitions();
+            assert!(r.b.positional_redefinitions.as_ref().unwrap().targets[&b.0].contains(&a.0));
+            // A compatibility cache is not the producer's new certificate.
+            r.b.positional_redefinitions
+                .as_mut()
+                .unwrap()
+                .targets
+                .clear();
+            let relationships = r.implied_relationships(b);
+            assert!(relationships.iter().any(|at| {
+                r.b.elements[at.0].ty == "Redefinition"
+                    && specialization_target(&r.b.elements[at.0]) == Some(r.element_id(a))
+            }));
+            let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+            let prefix =
+                r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                    .unwrap();
+            assert!(
+                super::super::dynamic_invocations::capture_static_prefix(
+                    &mut r.b,
+                    prefix,
+                    Some(boundary),
+                    &mut 0,
+                )
+                .is_ok()
+            );
+        }
+    }
+    #[test]
+    fn checked_one_hop_chain_bases_supply_static_positional_ends() {
+        let mut r = fixture();
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let last = r.resolve_qualified("Holder::fnMember").unwrap().0;
+        let p = r.resolve_qualified("Holder::fnMember::terminal").unwrap().0;
+        let q = r.resolve_qualified("next::q").unwrap().0;
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        assert_eq!(prefix.chain_bases.targets[&chain], last);
+        assert!(prefix.planner_bases[&chain].contains(&last));
+        assert!(prefix.specializations[&r.b.elements[chain].id].contains(&r.b.elements[last].id));
+        assert!(prefix.positional.targets[&q].contains(&p));
+        let supers = super::super::type_relations::TypeRelations::default()
+            .checked_supertypes(&mut r.b, chain, true, &mut 0)
+            .unwrap();
+        assert_eq!(supers, vec![last]);
+        // Admission remains separate while owned-callee and whole-family
+        // qualification are reviewed; this prerequisite does not bypass guard.
+        assert!(matches!(
+            super::super::dynamic_invocations::prepare(
+                &mut r.b,
+                prefix,
+                &HashSet::new(),
+                None,
+                &mut 0
+            ),
+            Err(super::super::dynamic_invocations::Refusal::Incomplete)
+        ));
+    }
+    #[test]
+    fn invalid_chain_never_supplies_a_partial_final_target() {
+        for malformed in 0..5 {
+            let mut r = fixture();
+            let chain = r.resolve_qualified("chain").unwrap().0;
+            let q = r.resolve_qualified("next::q").unwrap().0;
+            let last = r.resolve_qualified("Holder::fnMember").unwrap().0;
+            let relations: Vec<_> = r.b.elements[chain]
+                .owned_relationships
+                .iter()
+                .copied()
+                .filter(|&e| r.b.elements[e].ty == "FeatureChaining")
+                .collect();
+            match malformed {
+                0 => {
+                    r.b.set(relations[0], "chainingFeature", serde_json::json!(null))
+                }
+                1 => {
+                    let id = r.b.elements[last].id;
+                    r.b.set(relations[0], "featureChained", id_ref(id));
+                }
+                2 => {
+                    let id = r.b.elements[chain].id;
+                    r.b.set(
+                        relations[1],
+                        "target",
+                        crate::properties::Atom::Array(vec![id_ref(id)]),
+                    );
+                }
+                3 => r.b.elements[chain].owned_relationships.push(relations[0]),
+                4 => {
+                    let f = r.resolve_qualified("F").unwrap().0;
+                    let id = r.b.elements[f].id;
+                    r.b.set(relations[1], "chainingFeature", id_ref(id));
+                }
+                _ => unreachable!(),
+            }
+            let prefix =
+                r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                    .unwrap();
+            assert!(
+                prefix.chain_bases.incomplete.contains(&chain),
+                "{malformed}"
+            );
+            assert!(!prefix.chain_bases.targets.contains_key(&chain));
+            assert!(!prefix.positional.targets.contains_key(&q));
+        }
+    }
+    #[test]
+    fn cached_chain_projection_observes_same_length_endpoint_edits() {
+        let mut r = fixture();
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let h = r.resolve_qualified("h").unwrap().0;
+        let first =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        let last = r.b.elements[chain]
+            .owned_relationships
+            .iter()
+            .copied()
+            .rfind(|&e| r.b.elements[e].ty == "FeatureChaining")
+            .unwrap();
+        let id = r.b.elements[h].id;
+        r.b.set(last, "chainingFeature", id_ref(id));
+        let second =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        assert_ne!(first.chain_bases.targets[&chain], h);
+        assert_eq!(second.chain_bases.targets[&chain], h);
+    }
+    #[test]
+    fn unchanged_static_append_preserves_chain_authority_and_warm_work() {
+        let mut r = fixture();
+        let q = r.resolve_qualified("next::q").unwrap().0;
+        let p = r.resolve_qualified("Holder::fnMember::terminal").unwrap().0;
+        r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+            .unwrap();
+        let plan = Arc::clone(r.b.supported_implied.as_ref().unwrap());
+        r.implied_relationships(ElementRef(q));
+        assert!(Arc::ptr_eq(&plan, r.b.supported_implied.as_ref().unwrap()));
+        assert_eq!(
+            super::super::type_relations::TypeRelations::default()
+                .specializes(&mut r.b, q, p, &mut 0),
+            super::super::type_relations::RelationFact::Yes
+        );
+        assert!(Arc::ptr_eq(&plan, r.b.supported_implied.as_ref().unwrap()));
+        let mut warm = 0;
+        r.b.refresh_supported_chain_evidence(Some(&mut warm))
+            .unwrap();
+        assert_eq!(warm, 1);
+    }
+    #[test]
+    fn changed_chain_budget_refusal_does_not_refresh_old_stamp() {
+        let mut r = fixture();
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+            .unwrap();
+        let old = Arc::clone(r.b.supported_implied.as_ref().unwrap());
+        let last = r.b.elements[chain]
+            .owned_relationships
+            .iter()
+            .copied()
+            .rfind(|&e| r.b.elements[e].ty == "FeatureChaining")
+            .unwrap();
+        r.b.set(last, "chainingFeature", serde_json::json!(null));
+        assert!(
+            r.b.refresh_supported_chain_evidence(Some(&mut (crate::eval::MAX_STEPS - 1)))
+                .is_none()
+        );
+        assert!(Arc::ptr_eq(&old, r.b.supported_implied.as_ref().unwrap()));
+        assert!(!r.b.supported_chain_evidence_current());
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        assert!(prefix.chain_bases.incomplete.contains(&chain));
+        assert!(!Arc::ptr_eq(&old, r.b.supported_implied.as_ref().unwrap()));
+    }
+    #[test]
+    fn materialized_chain_positional_rows_do_not_survive_endpoint_mutation() {
+        let mut r = fixture();
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let q = r.resolve_qualified("next::q").unwrap().0;
+        let p = r.resolve_qualified("Holder::fnMember::terminal").unwrap().0;
+        let h = r.resolve_qualified("h").unwrap().0;
+        let rows = r.implied_relationships(ElementRef(q));
+        assert!(rows.iter().any(|e| r.b.elements[e.0].ty == "Redefinition"));
+        let last = r.b.elements[chain]
+            .owned_relationships
+            .iter()
+            .copied()
+            .rfind(|&e| r.b.elements[e].ty == "FeatureChaining")
+            .unwrap();
+        let id = r.b.elements[h].id;
+        r.b.set(last, "chainingFeature", id_ref(id));
+        let fact = super::super::type_relations::TypeRelations::default()
+            .specializes(&mut r.b, q, p, &mut 0);
+        assert_ne!(
+            fact,
+            super::super::type_relations::RelationFact::Yes,
+            "old physical positional edge is not current evidence"
+        );
+    }
+    #[test]
+    fn changed_end_membership_cannot_be_hidden_by_unchanged_chain_targets() {
+        let mut r = fixture();
+        let q = r.resolve_qualified("next::q").unwrap().0;
+        let p = r.resolve_qualified("Holder::fnMember::terminal").unwrap().0;
+        r.implied_relationships(ElementRef(q));
+        r.b.set(p, "isEnd", serde_json::json!(false));
+        let fact = super::super::type_relations::TypeRelations::default()
+            .specializes(&mut r.b, q, p, &mut 0);
+        assert_ne!(fact, super::super::type_relations::RelationFact::Yes);
+        assert!(r.b.value_context_bases(q, &mut 0).is_none());
+        let explicit = super::super::type_relations::TypeRelations::default()
+            .checked_supertypes(&mut r.b, q, true, &mut 0)
+            .unwrap();
+        assert!(
+            explicit.is_empty(),
+            "stale implied rows are outside explicit-only domain"
+        );
+    }
+    #[test]
+    fn remapped_static_chain_rows_recertify_without_any_invocation() {
+        let mut model = Model::new();
+        model.add_source("chain-remap.kerml","class C {feature last {end feature terminal;}} feature h:C; feature chain chains h.last; feature next subsets chain {end feature q;}");
+        let mut r = ResolvedModel::build(&model);
+        let q = r.resolve_qualified("next::q").unwrap();
+        let p = r.resolve_qualified("C::last::terminal").unwrap();
+        let before = r.implied_relationships(q);
+        let relation = before
+            .into_iter()
+            .find(|e| r.element_type(*e) == "Redefinition")
+            .unwrap();
+        let relation_id = r.element_id(relation);
+        let new = Uuid::new_v4();
+        r.override_ids(&HashMap::from([(r.element_id(p), new)]));
+        r.implied_relationships(q);
+        let fact = super::super::type_relations::TypeRelations::default()
+            .specializes(&mut r.b, q.0, p.0, &mut 0);
+        assert_eq!(fact, super::super::type_relations::RelationFact::Yes);
+        assert_eq!(r.element_id(relation), relation_id);
+        assert!(r.b.value_context_bases(q.0, &mut 0).unwrap().contains(&p.0));
+    }
+    #[test]
+    fn name_only_role_change_revokes_physical_and_positional_authority() {
+        let mut model = Model::new();
+        model.add_library_source(
+            "chain-role.kerml",
+            "standard library package Performances {expr evaluations;}",
+        );
+        model.add_source("chain-role-user.kerml", "feature answer=1;");
+        let mut r = ResolvedModel::build(&model);
+        let literal = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "LiteralInteger")
+            .unwrap();
+        let role = r.resolve_qualified("Performances::evaluations").unwrap();
+        let rows = r.implied_relationships(literal);
+        let edge = rows
+            .into_iter()
+            .find(|e| r.element_type(*e) == "Subsetting")
+            .unwrap();
+        let edge_id = r.element_id(edge);
+        assert!(r.b.physical_static_authority_current());
+        let row_revision = r.b.elements.observe_revision();
+        let role_id = r.element_id(role);
+        for at in 0..r.b.lib_qnames.len() {
+            let (id, parts) = &mut r.b.lib_qnames[at];
+            if *id == role_id {
+                *parts = vec!["Performances".into(), "renamed".into()];
+            }
+        }
+        assert!(r.b.elements.revision().unwrap().same_as(&row_revision));
+        assert!(!r.b.physical_static_authority_current());
+        assert!(r.b.effective_positional_redefinitions().is_none());
+        r.b.supported_implied = None;
+        assert!(!r.b.physical_static_authority_current());
+        assert_ne!(
+            super::super::type_relations::TypeRelations::default()
+                .specializes(&mut r.b, literal.0, role.0, &mut 0),
+            super::super::type_relations::RelationFact::Yes
+        );
+        assert_eq!(r.element_id(edge), edge_id);
+        assert!(!r.b.static_chain_row_current(edge.0));
+    }
+    #[test]
+    fn missing_required_authority_cannot_leave_a_positional_cache_current() {
+        let mut r = fixture();
+        let q = r.resolve_qualified("next::q").unwrap().0;
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(r.b.completed_positional_targets(q).is_some());
+        r.b.supported_implied = None;
+        assert!(r.b.completed_positional_targets(q).is_none());
+        r.b.refresh_supported_chain_evidence(Some(&mut 0)).unwrap();
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(r.b.completed_positional_targets(q).is_some());
+    }
+    #[test]
+    fn virtual_chain_graph_refreshes_even_when_physical_recipes_are_unchanged() {
+        let mut model = Model::new();
+        model.add_source(
+            "chain-virtual.kerml",
+            "class C {feature a; feature b;} feature h:C; feature chain chains h.a;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let chain = r.resolve_qualified("chain").unwrap();
+        let old = r.resolve_qualified("C::a").unwrap();
+        let new = r.resolve_qualified("C::b").unwrap();
+        assert!(r.conforms_with_implied(chain, old));
+        let count = r.b.elements.len();
+        let last = *r.b.elements[chain.0]
+            .owned_relationships
+            .iter()
+            .rfind(|&&at| r.b.elements[at].ty == "FeatureChaining")
+            .unwrap();
+        let id = r.element_id(new);
+        r.b.set(last, "chainingFeature", id_ref(id));
+        assert!(!r.conforms_with_implied(chain, old));
+        assert!(r.conforms_with_implied(chain, new));
+        assert_eq!(r.b.elements.len(), count);
+    }
+    #[test]
+    fn static_chain_prerequisites_cannot_depend_on_semantic_tail_features() {
+        for intermediate in [false, true] {
+            let mut r = fixture();
+            let chain = r.resolve_qualified("chain").unwrap().0;
+            let h = r.resolve_qualified("h").unwrap().0;
+            r.implied_relationships(ElementRef(chain));
+            let boundary = r.b.explicit_len();
+            let mut suffix = r.b.elements[h].clone();
+            suffix.id = Uuid::new_v4();
+            suffix.owning_relationship = None;
+            let id = suffix.id;
+            r.b.elements.push(suffix);
+            let links: Vec<_> = r.b.elements[chain]
+                .owned_relationships
+                .iter()
+                .copied()
+                .filter(|&at| r.b.elements[at].ty == "FeatureChaining")
+                .collect();
+            r.b.set(
+                links[usize::from(!intermediate)],
+                "chainingFeature",
+                id_ref(id),
+            );
+            let bases = r.b.checked_chain_bases(boundary, Some(&mut 0)).unwrap();
+            assert!(bases.incomplete.contains(&chain));
+            assert!(!bases.targets.contains_key(&chain));
+        }
+    }
+    #[test]
+    fn chain_projection_budget_refusal_does_not_publish_a_prefix() {
+        let mut r = fixture();
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut steps))
+                .is_none()
+        );
+        assert!(r.b.implied.is_none());
+        assert!(r.b.positional_redefinitions.is_none());
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let prefix =
+            r.b.static_specialization_prefix(&HashMap::new(), true, Some(&mut 0))
+                .unwrap();
+        assert!(prefix.chain_bases.targets.contains_key(&chain));
+    }
+}
+
+#[cfg(test)]
+mod minimizer_witness_tests {
+    use crate::{json::ResolvedModel, model::Model};
+
+    #[test]
+    fn direct_witness_skips_irrelevant_branches_and_keeps_order() {
+        let mut m = Model::new();
+        assert!(
+            m.add_source(
+                "witness.kerml",
+                "class Goal; class Wide; class A specializes Goal, Wide;"
+            )
+            .diagnostics
+            .is_empty()
+        );
+        let mut r = ResolvedModel::build(&m);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let goal = r.resolve_qualified("Goal").unwrap().0;
+        let wide = r.resolve_qualified("Wide").unwrap().0;
+        let edge = (
+            a,
+            (
+                "Subclassification",
+                "subclassifier",
+                "superclassifier",
+                r.b.elements[goal].id,
+            ),
+        );
+        let owners = r.b.specialization_relation_owners();
+        let limit = r.b.explicit_len();
+        let (keep, graph) =
+            r.b.required_specialization_edges_with_fixed_prefix(
+                &[edge],
+                0,
+                limit,
+                &owners,
+                Some(&mut 0),
+            )
+            .unwrap();
+        assert_eq!(keep, [false]);
+        assert_eq!(
+            graph[&r.b.elements[a].id],
+            [r.b.elements[goal].id, r.b.elements[wide].id]
+        );
+        let (keep, _) =
+            r.b.required_specialization_edges_with_fixed_prefix(
+                &[edge],
+                1,
+                limit,
+                &owners,
+                Some(&mut 0),
+            )
+            .unwrap();
+        assert_eq!(
+            keep,
+            [true],
+            "fixed prefix must survive even a direct witness"
+        );
+    }
+
+    #[test]
+    fn disabled_candidate_is_not_its_own_witness_and_cycles_keep_an_anchor() {
+        let mut m = Model::new();
+        assert!(
+            m.add_source(
+                "cycle.kerml",
+                "class Goal; class A specializes B; class B specializes A;"
+            )
+            .diagnostics
+            .is_empty()
+        );
+        let mut r = ResolvedModel::build(&m);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let goal = r.resolve_qualified("Goal").unwrap().0;
+        let edge = |owner| {
+            (
+                owner,
+                (
+                    "Subclassification",
+                    "subclassifier",
+                    "superclassifier",
+                    r.b.elements[goal].id,
+                ),
+            )
+        };
+        let candidates = [edge(a), edge(b)];
+        let owners = r.b.specialization_relation_owners();
+        let limit = r.b.explicit_len();
+        let (keep, _) =
+            r.b.required_specialization_edges_with_fixed_prefix(
+                &candidates[..1],
+                0,
+                limit,
+                &owners,
+                Some(&mut 0),
+            )
+            .unwrap();
+        assert_eq!(keep, [true]);
+        let (keep, graph) =
+            r.b.required_specialization_edges_with_fixed_prefix(
+                &candidates,
+                0,
+                limit,
+                &owners,
+                Some(&mut 0),
+            )
+            .unwrap();
+        assert_eq!(keep.iter().filter(|&&keep| keep).count(), 1);
+        for owner in [a, b] {
+            assert!(
+                graph[&r.b.elements[owner].id]
+                    .contains(&r.b.elements[if owner == a { b } else { a }].id)
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod owned_typing_requirement_tests {
+    use super::*;
+    use crate::{
+        json::id_ref,
+        model::{GraphFormat, Model},
+    };
+
+    const LIB: &str = "standard library package Base { classifier Anything; datatype DataValue specializes Anything; feature things : Anything; feature dataValues : DataValue subsets things; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences : Occurrence subsets Base::things; } standard library package Objects { struct Object specializes Occurrences::Occurrence; feature objects : Object subsets Occurrences::occurrences; }";
+
+    fn fixture(format: GraphFormat) -> ResolvedModel {
+        let mut model = Model::with_graph_format(format);
+        assert!(
+            model
+                .add_library_source("typed-roles.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(model.add_source("typed-features.kerml", "struct O; class C; datatype D; feature object : O; feature occurrence : C; feature datum : D; feature inherited subsets object;").diagnostics.is_empty());
+        ResolvedModel::build(&model)
+    }
+    fn names(r: &ResolvedModel) -> HashMap<String, Uuid> {
+        r.b.lib_qnames
+            .iter()
+            .map(|(id, name)| (name.join("::"), *id))
+            .collect()
+    }
+    fn targets(r: &mut ResolvedModel, owner: usize) -> Vec<Uuid> {
+        let plan = r.b.supported_implied_specializations(&names(r), true);
+        plan.candidates
+            .iter()
+            .filter_map(|(source, edge)| (*source == owner).then_some(edge.3))
+            .collect()
+    }
+    fn typing(r: &ResolvedModel, owner: usize) -> usize {
+        *r.b.elements[owner]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| r.b.elements[rel].ty == "FeatureTyping")
+            .unwrap()
+    }
+    #[test]
+    fn canonical_owned_typings_add_each_applicable_obligation_before_reduction() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture(format);
+            for (name, kinds) in [
+                (
+                    "object",
+                    vec!["Objects::objects", "Occurrences::occurrences"],
+                ),
+                ("occurrence", vec!["Occurrences::occurrences"]),
+                ("datum", vec!["Base::dataValues"]),
+            ] {
+                let owner = r.resolve_qualified(name).unwrap();
+                let obligations = targets(&mut r, owner.0);
+                for role in kinds {
+                    let role = r.resolve_qualified(role).unwrap();
+                    assert_eq!(
+                        obligations.contains(&r.element_id(role)),
+                        format == GraphFormat::CanonicalV3,
+                        "{format:?} {name}"
+                    );
+                }
+            }
+            let inherited = r.resolve_qualified("inherited").unwrap();
+            let object_role = r.resolve_qualified("Objects::objects").unwrap();
+            assert!(!targets(&mut r, inherited.0).contains(&r.element_id(object_role)));
+            if format == GraphFormat::CanonicalV3 {
+                let object = r.resolve_qualified("object").unwrap();
+                let object_id = r.element_id(object_role);
+                let emitted = r.implied_relationships(object);
+                assert_eq!(
+                    emitted
+                        .iter()
+                        .filter(|e| specialization_target(&r.b.elements[e.0]) == Some(object_id))
+                        .count(),
+                    1
+                );
+                assert!(r.conforms_with_implied(inherited, object_role));
+            }
+        }
+    }
+    #[test]
+    fn duplicate_typing_obligations_preserve_minimized_paths_and_recipe_order() {
+        let mut r = fixture(GraphFormat::CanonicalV3);
+        let object = r.resolve_qualified("object").unwrap();
+        let occurrence = r.resolve_qualified("occurrence").unwrap();
+        let base = r.resolve_qualified("Base::things").unwrap();
+        let objects = r.resolve_qualified("Objects::objects").unwrap();
+        let occurrences = r.resolve_qualified("Occurrences::occurrences").unwrap();
+        let edge = |owner: ElementRef, target: ElementRef| {
+            (
+                owner.0,
+                (
+                    "Subsetting",
+                    "subsettingFeature",
+                    "subsettedFeature",
+                    r.element_id(target),
+                ),
+            )
+        };
+        // Repeated requirements interleave with both stronger obligations and
+        // a feature cycle; a weaker family may be independently necessary.
+        let duplicated = vec![
+            edge(object, objects),
+            edge(object, base),
+            edge(object, occurrence),
+            edge(object, objects),
+            edge(object, occurrences),
+            edge(occurrence, occurrences),
+            edge(occurrence, object),
+            edge(occurrence, occurrences),
+        ];
+        let reduced_input = vec![
+            edge(object, base),
+            edge(object, occurrence),
+            edge(object, objects),
+            edge(object, occurrences),
+            edge(occurrence, object),
+            edge(occurrence, occurrences),
+        ];
+        let owners = r.b.specialization_relation_owners();
+        for missing_base_path in [false, true] {
+            if missing_base_path {
+                // Keep the canonical occurrence role but remove its inherited
+                // Base::things path, so that independent weak role must survive.
+                let relationships = r.b.elements[occurrences.0].owned_relationships.to_vec();
+                for relationship in relationships {
+                    if r.b.elements[relationship].ty == "Subsetting" {
+                        r.b.set(relationship, "subsettedFeature", json!(null));
+                    }
+                }
+            }
+            let (before, before_graph) =
+                r.b.required_specialization_edges(&duplicated, r.b.explicit_len(), &owners);
+            let (after, after_graph) =
+                r.b.required_specialization_edges(&reduced_input, r.b.explicit_len(), &owners);
+            let retained_before: Vec<_> = duplicated
+                .iter()
+                .zip(before)
+                .filter_map(|(edge, keep)| keep.then_some(edge))
+                .collect();
+            let retained_after: Vec<_> = reduced_input
+                .iter()
+                .zip(after)
+                .filter_map(|(edge, keep)| keep.then_some(edge))
+                .collect();
+            assert_eq!(retained_before, retained_after);
+            assert_eq!(before_graph, after_graph);
+        }
+    }
+    #[test]
+    fn malformed_owned_typing_never_supplies_an_object_specialization() {
+        for mutation in 0..7 {
+            let mut r = fixture(GraphFormat::CanonicalV3);
+            let object = r.resolve_qualified("object").unwrap();
+            let other = r.resolve_qualified("occurrence").unwrap();
+            let datum = r.resolve_qualified("D").unwrap();
+            let role = r.resolve_qualified("Objects::objects").unwrap();
+            let relationship = typing(&r, object.0);
+            match mutation {
+                0 => r.b.set(
+                    relationship,
+                    "owningRelatedElement",
+                    id_ref(r.element_id(other)),
+                ),
+                1 => {
+                    r.b.set(relationship, "specific", id_ref(r.element_id(other)))
+                }
+                2 => {
+                    r.b.set(relationship, "general", id_ref(r.element_id(datum)))
+                }
+                3 => r.b.set(
+                    relationship,
+                    "source",
+                    crate::properties::Atom::Array(vec![id_ref(r.element_id(other))]),
+                ),
+                4 => r.b.set(relationship, "type", id_ref(r.element_id(other))),
+                5 => {
+                    r.b.set(
+                        relationship,
+                        "owningRelatedElement",
+                        id_ref(r.element_id(object)),
+                    );
+                    r.b.elements[object.0].owned_relationships = Vec::new().into();
+                }
+                _ => {
+                    r.b.elements[datum.0].id = r.element_id(object);
+                    r.b.id_index = None;
+                }
+            }
+            assert!(
+                !targets(&mut r, object.0).contains(&r.element_id(role)),
+                "mutation {mutation}"
+            );
+        }
+    }
+    #[test]
+    fn typed_roles_require_unique_loaded_feature_identities() {
+        for role_name in [
+            "Objects::objects",
+            "Occurrences::occurrences",
+            "Base::dataValues",
+        ] {
+            for mutation in 0..4 {
+                let mut r = fixture(GraphFormat::CanonicalV3);
+                let role = r.resolve_qualified(role_name).unwrap();
+                let other = r.resolve_qualified("Base::things").unwrap();
+                let mut configuration = names(&r);
+                match mutation {
+                    0 => {
+                        configuration.remove(role_name);
+                    }
+                    1 => r.b.elements[role.0].ty = "Class",
+                    2 => r.b.lib_qnames.push((
+                        r.element_id(other),
+                        role_name.split("::").map(str::to_owned).collect(),
+                    )),
+                    _ => {
+                        configuration.insert(role_name.into(), r.element_id(other));
+                    }
+                }
+                let plan = r.b.supported_implied_specializations(&configuration, false);
+                assert!(
+                    !plan.expression_targets.contains_key(role_name),
+                    "{role_name} mutation {mutation}"
+                );
+            }
+        }
+    }
+    #[test]
+    fn changed_typing_cannot_reuse_old_static_evidence_and_exhaustion_retries() {
+        let mut r = fixture(GraphFormat::CanonicalV3);
+        let object = r.resolve_qualified("object").unwrap();
+        let datatype = r.resolve_qualified("D").unwrap();
+        let role = r.resolve_qualified("Base::dataValues").unwrap();
+        let relationship = typing(&r, object.0);
+        r.implied_relationships(object);
+        assert!(r.b.physical_static_authority_current());
+        r.b.set(relationship, "type", id_ref(r.element_id(datatype)));
+        assert!(!r.b.physical_static_authority_current());
+        r.b.supported_implied = None;
+        let names = names(&r);
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(
+            r.b.supported_implied_specializations_with_budget(&names, true, Some(&mut exhausted))
+                .is_none()
+        );
+        assert!(r.b.supported_implied.is_none());
+        let plan =
+            r.b.supported_implied_specializations_with_budget(&names, true, Some(&mut 0))
+                .unwrap();
+        assert!(
+            plan.candidates
+                .iter()
+                .any(|(source, edge)| *source == object.0 && edge.3 == r.element_id(role))
+        );
+        assert!(!r.b.physical_static_authority_current());
+    }
+}
+
+#[cfg(test)]
+mod binary_role_tests {
+    use super::*;
+    use crate::model::{GraphFormat, Model};
+
+    const LIB: &str = "standard library package Connections {
+        connection def Connection;
+        connection def BinaryConnection :> Connection { end source; end target; }
+        connection connections : Connection;
+        connection binaryConnections : BinaryConnection;
+    }
+    standard library package Interfaces {
+        interface def Interface;
+        interface def BinaryInterface :> Interface { end port a; end port b; }
+        interface interfaces : Interface;
+        interface binaryInterfaces : BinaryInterface;
+    }";
+    const USER: &str = "connection def CD { end a; end b; }
+        interface def ID { end port a; end port b; }
+        connection cu { end a; end b; }
+        interface iu { end port a; end port b; }
+        ref decoy;";
+
+    #[test]
+    fn binary_roles_require_canonical_loaded_identity_and_kind() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            for (role, owner) in BINARY_ROLES.iter().zip(["CD", "ID", "cu", "iu"]) {
+                for mode in 0..7 {
+                    let mut model = Model::with_graph_format(format);
+                    model.add_library_source("binary.sysml", LIB);
+                    model.add_source("user.sysml", USER);
+                    assert!(
+                        !model.has_errors(),
+                        "{:?}",
+                        model
+                            .units()
+                            .iter()
+                            .flat_map(|unit| &unit.diagnostics)
+                            .collect::<Vec<_>>()
+                    );
+                    let mut r = ResolvedModel::build(&model);
+                    let target = r.resolve_qualified(role.0).unwrap();
+                    let receiver = r.resolve_qualified(owner).unwrap();
+                    let decoy = r.resolve_qualified("decoy").unwrap();
+                    let target_id = r.element_id(target);
+                    let mut names: HashMap<_, _> =
+                        r.b.lib_qnames
+                            .iter()
+                            .map(|(id, parts)| (parts.join("::"), *id))
+                            .collect();
+                    match mode {
+                        0 => {}
+                        1 => {
+                            names.remove(role.0);
+                        }
+                        2 => {
+                            names.insert(role.0.into(), r.element_id(decoy));
+                        }
+                        3 => {
+                            r.b.lib_qnames.push((
+                                r.element_id(decoy),
+                                role.0.split("::").map(str::to_owned).collect(),
+                            ));
+                        }
+                        4 => {
+                            r.b.elements[decoy.0].id = target_id;
+                        }
+                        5 => {
+                            r.b.elements[target.0].ty = "Feature";
+                        }
+                        6 => {
+                            names.insert(
+                                role.0.into(),
+                                Uuid::new_v5(&Uuid::NAMESPACE_OID, b"unloaded binary role"),
+                            );
+                        }
+                        _ => unreachable!(),
+                    }
+                    r.b.id_index = None;
+                    r.b.supported_implied = None;
+                    let plan = r.b.supported_implied_specializations(&names, false);
+                    assert_eq!(
+                        plan.expression_targets.contains_key(role.0),
+                        mode == 0,
+                        "{} mode {mode}",
+                        role.0
+                    );
+                    assert_eq!(
+                        plan.candidates
+                            .iter()
+                            .any(|(source, edge)| *source == receiver.0 && edge.3 == target_id),
+                        mode == 0,
+                        "{owner} mode {mode}"
+                    );
+                    if matches!(mode, 0 | 3 | 4 | 5) {
+                        assert_eq!(
+                            r.b.binary_lookup_target(target.0, role.0),
+                            mode == 0,
+                            "lookup {} mode {mode}",
+                            role.0
+                        );
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/crates/sysmlv2-model/src/json/import_memberships.rs b/crates/sysmlv2-model/src/json/import_memberships.rs
new file mode 100644
index 0000000..bbc4de1
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/import_memberships.rs
@@ -0,0 +1,363 @@
+//! Membership identity and name/type distinguishability without semantic lookup.
+
+use super::Builder;
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+/// Raw Import endpoint evidence shared by namespace operations and Type
+/// membership providers. A MembershipImport points to two distinct identities:
+/// its selected Membership and that Membership's imported member Element.
+pub(super) struct ImportTarget {
+    pub element: usize,
+    pub membership: Option<usize>,
+    pub recursive: bool,
+    pub all: bool,
+}
+pub(super) fn checked_import_target(
+    b: &Builder,
+    raw: &super::structural_index::StoredStructure,
+    owner: usize,
+    relationship: usize,
+    steps: &mut usize,
+) -> Option<ImportTarget> {
+    fn charge(steps: &mut usize, n: usize) -> Option<()> {
+        *steps = steps.saturating_add(n);
+        (*steps <= crate::eval::MAX_STEPS).then_some(())
+    }
+    charge(steps, 12)?;
+    if !raw.import_domains(b, steps)?.owner_complete(owner)
+        || super::semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)?
+            != Some(owner)
+    {
+        return None;
+    }
+    let relation = b.elements.get(relationship)?;
+    let (key, kind) = match relation.ty {
+        "MembershipImport" => ("importedMembership", "Membership"),
+        "NamespaceImport" => ("importedNamespace", "Namespace"),
+        _ => return None,
+    };
+    if relation
+        .props
+        .get("visibility")
+        .is_some_and(|v| !matches!(v.as_str(), Some("private" | "protected" | "public")))
+    {
+        return None;
+    }
+    let flag = |key| match relation.props.get(key) {
+        None => Some(false),
+        Some(v) => v.as_bool(),
+    };
+    let recursive = flag("isRecursive")?;
+    let all = flag("isImportAll")?;
+    let selected = raw.element_for_uuid(b, relation.props.get(key)?.as_reference()?)?;
+    if !conforms(b.elements.get(selected)?.ty, kind) {
+        return None;
+    }
+    let (element, membership) = if kind == "Membership" {
+        let declaring =
+            super::semantic_ownership::checked_relationship_carrier(b, raw, selected, steps)??;
+        if !raw.membership_domains(b, steps)?.owner_complete(declaring) {
+            return None;
+        }
+        let member = super::membership_evidence::member(b, raw, declaring, selected, steps)?;
+        if b.elements[selected]
+            .props
+            .get("visibility")
+            .is_some_and(|v| !matches!(v.as_str(), Some("private" | "protected" | "public")))
+        {
+            return None;
+        }
+        (member, Some(selected))
+    } else {
+        (selected, None)
+    };
+    let expected = b.elements[element].id;
+    if relation
+        .props
+        .get("importedElement")
+        .is_some_and(|v| v.as_reference() != Some(expected))
+    {
+        return None;
+    }
+    // Relationship.target is redefined by importedMembership or
+    // importedNamespace; importedElement is the selected Membership's member.
+    let relationship_target = b.elements[selected].id;
+    for (key, expected) in [
+        ("target", vec![relationship_target]),
+        (
+            "relatedElement",
+            vec![b.elements[owner].id, relationship_target],
+        ),
+        (
+            "ownedRelatedElement",
+            relation
+                .children
+                .iter()
+                .map(|&e| b.elements[e].id)
+                .collect(),
+        ),
+    ] {
+        if let Some(value) = relation.props.get(key) {
+            let values = value.as_array()?;
+            charge(steps, values.len())?;
+            if values.len() != expected.len()
+                || values
+                    .iter()
+                    .zip(expected)
+                    .any(|(v, id)| v.as_reference() != Some(id))
+            {
+                return None;
+            }
+        }
+    }
+    Some(ImportTarget {
+        element,
+        membership,
+        recursive,
+        all,
+    })
+}
+
+struct Signature {
+    names: Vec<String>,
+    member_type: &'static str,
+}
+
+impl Builder {
+    /// Remove imported memberships indistinguishable from an owned membership
+    /// or another imported membership (KerML Namespace::importedMemberships).
+    /// The boolean qualifies signatures unavailable from the stored graph; such
+    /// candidates remain, rather than guessing their effective names or type.
+    /// This operation never performs name resolution or derived-property reads.
+    pub(crate) fn distinguishable_import_memberships(
+        &mut self,
+        owner: usize,
+        candidates: Vec<usize>,
+    ) -> (Vec<usize>, bool) {
+        let mut seen = HashSet::new();
+        let candidates: Vec<_> = candidates.into_iter().filter(|r| seen.insert(*r)).collect();
+        if candidates.is_empty() {
+            return (candidates, false);
+        }
+        let owned: Vec<_> = self.elements[owner]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&r| conforms(self.elements[r].ty, "Membership"))
+            .collect();
+        let owned: HashSet<_> = owned.into_iter().collect();
+        let mut signatures = HashMap::new();
+        let mut incomplete = false;
+        for &rel in candidates.iter().chain(owned.iter()) {
+            let signature = self.import_membership_signature(rel);
+            incomplete |= signature.is_none();
+            signatures.insert(rel, signature);
+        }
+        // Index only actual names. Unnamed memberships never collide, and most
+        // namespaces require no pairwise metaclass comparisons at all.
+        let mut by_name: HashMap<&str, Vec<usize>> = HashMap::new();
+        for (&rel, signature) in &signatures {
+            if let Some(signature) = signature {
+                for name in &signature.names {
+                    by_name.entry(name).or_default().push(rel);
+                }
+            }
+        }
+        let retained = candidates
+            .into_iter()
+            .filter(|rel| {
+                let Some(Some(signature)) = signatures.get(rel) else {
+                    return true;
+                };
+                !(owned.contains(rel) && !signature.names.is_empty())
+                    && !signature.names.iter().any(|name| {
+                        by_name[name.as_str()].iter().any(|other| {
+                            if other == rel {
+                                return false;
+                            }
+                            let other = signatures[other].as_ref().unwrap();
+                            conforms(signature.member_type, other.member_type)
+                                || conforms(other.member_type, signature.member_type)
+                        })
+                    })
+            })
+            .collect();
+        (retained, incomplete)
+    }
+
+    fn import_membership_signature(&mut self, rel: usize) -> Option<Signature> {
+        let member = self.stored_membership_member(rel)?;
+        let member_type = self.elements[member].ty;
+        let names = if conforms(self.elements[rel].ty, "OwningMembership") {
+            self.stored_import_member_names(member, &mut HashSet::new())?
+        } else {
+            ["memberName", "memberShortName"]
+                .into_iter()
+                .filter_map(|key| {
+                    self.elements[rel]
+                        .props
+                        .get(key)?
+                        .as_str()
+                        .map(str::to_owned)
+                })
+                .collect()
+        };
+        Some(Signature { names, member_type })
+    }
+
+    pub(super) fn stored_membership_member(&mut self, rel: usize) -> Option<usize> {
+        if conforms(self.elements[rel].ty, "OwningMembership") {
+            if let Some(&member) = self.elements[rel].children.first() {
+                return Some(member);
+            }
+        }
+        let id = self.elements[rel]
+            .props
+            .get("memberElement")?
+            .as_reference()?;
+        self.element_index_of_uuid(id)
+    }
+
+    fn stored_import_member_names(
+        &mut self,
+        mut member: usize,
+        active: &mut HashSet<usize>,
+    ) -> Option<Vec<String>> {
+        loop {
+            if !active.insert(member) {
+                return None;
+            }
+            let names: Vec<_> = ["declaredName", "declaredShortName"]
+                .into_iter()
+                .filter_map(|key| {
+                    self.elements[member]
+                        .props
+                        .get(key)?
+                        .as_str()
+                        .map(str::to_owned)
+                })
+                .collect();
+            // Either declared name fixes both effective names; the absent one
+            // remains null, rather than inheriting separately.
+            if self.elements[member].ty == "ConjugatedPortDefinition" {
+                return None;
+            }
+            if !names.is_empty() || !conforms(self.elements[member].ty, "Feature") {
+                return Some(names);
+            }
+            if self.reference_locator_has_no_semantic_name(member) {
+                return Some(Vec::new());
+            }
+            // SysML feature subclasses override namingFeature in several
+            // contexts. Positional obligations can also add a naming target.
+            // Those require a semantic plan, which may itself be calling us.
+            if self.elements[member].ty != "Feature"
+                || self.elements[member]
+                    .props
+                    .get("isEnd")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+                || self.elements[member]
+                    .props
+                    .get("direction")
+                    .is_some_and(|v| !v.is_null())
+            {
+                return None;
+            }
+            let rel = self.elements[member]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&r| self.elements[r].ty == "Redefinition");
+            if let Some(rel) = rel {
+                let id = self.elements[rel]
+                    .props
+                    .get("redefinedFeature")?
+                    .as_reference()?;
+                member = self.element_index_of_uuid(id)?;
+                continue;
+            }
+            if self.elements[member].owning_relationship.is_some_and(|r| {
+                matches!(
+                    self.elements[r].ty,
+                    "ParameterMembership"
+                        | "EndFeatureMembership"
+                        | "ReturnParameterMembership"
+                        | "SubjectMembership"
+                        | "ObjectiveMembership"
+                        | "ViewRenderingMembership"
+                        | "TransitionFeatureMembership"
+                )
+            }) {
+                return None;
+            }
+            // KerML Feature::namingFeature uses only ownedRedefinition; a
+            // ReferenceSubsetting or FeatureChaining is not a naming rule.
+            return Some(Vec::new());
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn membership(b: &mut Builder, owner: usize, ty: &'static str, path: &str) -> (usize, usize) {
+        let rel = b.new_relationship("OwningMembership", owner, path);
+        let element = b.new_element(ty, Some(rel), format!("{path}/member"));
+        (rel, element)
+    }
+
+    #[test]
+    fn unresolved_specialized_and_positional_names_are_qualified_without_deletion() {
+        for (ty, property) in [
+            ("ReferenceUsage", None),
+            ("Feature", Some(("isEnd", json!(true)))),
+            ("Feature", Some(("direction", json!("in")))),
+            (
+                "ConjugatedPortDefinition",
+                Some(("declaredName", json!("X"))),
+            ),
+        ] {
+            let mut b = Builder::default();
+            let owner = b.new_element("Namespace", None, "owner".into());
+            let source = b.new_element("Namespace", None, "source".into());
+            let (known, e) = membership(&mut b, source, ty, "known");
+            b.elements[e].props.insert("declaredName", json!("X"));
+            let (unknown, e) = membership(&mut b, source, ty, "unknown");
+            if let Some((key, value)) = property {
+                b.elements[e].props.insert(key, value);
+            }
+            let (retained, incomplete) =
+                b.distinguishable_import_memberships(owner, vec![known, unknown]);
+            assert_eq!(retained, [known, unknown], "{ty}");
+            assert!(incomplete, "{ty}");
+        }
+    }
+
+    #[test]
+    fn generic_feature_reference_and_chain_do_not_supply_effective_names() {
+        for (ty, property) in [
+            ("ReferenceSubsetting", "referencedFeature"),
+            ("FeatureChaining", "chainingFeature"),
+        ] {
+            let mut b = Builder::default();
+            let owner = b.new_element("Namespace", None, "owner".into());
+            let source = b.new_element("Namespace", None, "source".into());
+            let (named, target) = membership(&mut b, source, "Feature", "named");
+            b.elements[target].props.insert("declaredName", json!("X"));
+            let (unnamed, element) = membership(&mut b, source, "Feature", "unnamed");
+            let rel = b.new_relationship(ty, element, "naming-candidate");
+            let target_id = b.elements[target].id;
+            b.elements[rel]
+                .props
+                .insert(property, super::super::id_ref(target_id));
+            assert_eq!(
+                b.distinguishable_import_memberships(owner, vec![named, unnamed]),
+                (vec![named, unnamed], false)
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/invocation_bindings.rs b/crates/sysmlv2-model/src/json/invocation_bindings.rs
new file mode 100644
index 0000000..a5c0a36
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/invocation_bindings.rs
@@ -0,0 +1,1074 @@
+//! Checked direct argument bindings over authored or current admitted positional evidence.
+use super::{
+    ElementRef, ResolvedModel, TypeInputIssue, membership_evidence,
+    semantic::certified_types::Stamp, semantic_ownership, structural_index::StoredStructure,
+    type_relations,
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+/// A supplied argument and the exact input it directly redefines.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct InvocationBinding {
+    pub input: ElementRef,
+    pub parameter: ElementRef,
+    pub value: ElementRef,
+}
+/// Complete supplied arguments in callee input order. Omitted inputs remain in
+/// `inputs` but do not produce a binding. This is not an arity/default/evaluability
+/// certificate or a promise that all Invocation constraints are satisfied.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct InvocationBindings {
+    pub callee: ElementRef,
+    pub inputs: Vec<ElementRef>,
+    pub bindings: Vec<InvocationBinding>,
+}
+/// A failed proof never denotes an empty argument list.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum InvocationBindingIssue {
+    InvalidElement,
+    InvalidRelationship,
+    IncompleteInputs(TypeInputIssue),
+    IncompleteProvider,
+    UnsupportedConfiguration,
+    UnmappedArgument,
+    DuplicateArgument,
+    StaleEvidence,
+    WorkLimit,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct InvocationBindingReport {
+    pub arguments: Result<InvocationBindings, InvocationBindingIssue>,
+    pub steps: usize,
+}
+use InvocationBindingIssue::*;
+fn charge(steps: &mut usize, n: usize) -> Result<(), InvocationBindingIssue> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+impl ResolvedModel {
+    /// Certify supplied arguments of ordinary InvocationExpressions and admitted
+    /// canonical numeric OperatorExpressions calling exact loaded library Functions.
+    /// Each argument must have one checked owned direct Redefinition.
+    /// Named authored mappings are supported without truncating after an omitted
+    /// earlier input. Positional mappings additionally require the current shared
+    /// published dynamic plan and agreement with complete input order. Missing
+    /// plans and defaults remain qualified; constructors have a separate report.
+    /// This query publishes no rows.
+    pub fn invocation_binding_report(&mut self, receiver: ElementRef) -> InvocationBindingReport {
+        self.invocation_binding_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn invocation_binding_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> InvocationBindingReport {
+        let mut steps = initial;
+        let arguments = self
+            .b
+            .checked_invocation_bindings(receiver.0, &mut steps, None);
+        InvocationBindingReport {
+            arguments: if steps > crate::eval::MAX_STEPS {
+                Err(WorkLimit)
+            } else {
+                arguments
+            },
+            steps,
+        }
+    }
+}
+impl super::Builder {
+    pub(super) fn checked_invocation_bindings(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        proposed: Option<&mut HashMap<usize, Vec<usize>>>,
+    ) -> Result<InvocationBindings, InvocationBindingIssue> {
+        self.checked_invocation_bindings_in_batch(
+            receiver,
+            steps,
+            proposed,
+            &mut super::constructor_bindings::ConstructorBatchEvidence::default(),
+        )
+    }
+    pub(super) fn checked_invocation_bindings_in_batch(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        mut proposed: Option<&mut HashMap<usize, Vec<usize>>>,
+        batch: &mut super::constructor_bindings::ConstructorBatchEvidence,
+    ) -> Result<InvocationBindings, InvocationBindingIssue> {
+        charge(steps, 1)?;
+        let operator =
+            self.elements.get(receiver).ok_or(InvalidElement)?.ty == "OperatorExpression";
+        if (!operator && self.elements[receiver].ty != "InvocationExpression")
+            || (operator && self.graph_format != crate::model::GraphFormat::CanonicalV3)
+            || self.positional_planning
+        {
+            return Err(UnsupportedConfiguration);
+        }
+        let raw = StoredStructure::for_query(self, steps).ok_or(IncompleteProvider)?;
+        let callee = if operator {
+            batch
+                .numeric_target(self, receiver, steps)
+                .ok_or(UnsupportedConfiguration)?
+        } else {
+            membership_evidence::first_unowned_member(
+                self,
+                &raw,
+                receiver,
+                "FeatureMembership",
+                "Function",
+                None,
+                steps,
+            )
+            .ok_or(InvalidRelationship)?
+        };
+        let features = batch
+            .features(self, callee, steps)
+            .map_err(|issue| match issue {
+                super::ConstructorBindingIssue::IncompleteFeatures(issue) => {
+                    IncompleteInputs(issue)
+                }
+                super::ConstructorBindingIssue::WorkLimit => WorkLimit,
+                _ => IncompleteProvider,
+            })?;
+        let inputs = features.inputs;
+        if operator {
+            // The admitted generic parameter rule pairs direct owned slots;
+            // inherited-only or interleaved-output signatures stay qualified.
+            charge(
+                steps,
+                inputs
+                    .len()
+                    .saturating_add(features.directed_features.len()),
+            )?;
+            let mut directed = features.directed_features.iter().filter(|feature| {
+                let membership = self.elements[feature.0].owning_relationship;
+                !membership.is_some_and(|m| self.elements[m].ty == "ReturnParameterMembership")
+            });
+            for input in &inputs {
+                let membership = self.elements[input.0]
+                    .owning_relationship
+                    .ok_or(InvalidRelationship)?;
+                if semantic_ownership::checked_relationship_carrier(self, &raw, membership, steps)
+                    != Some(Some(callee))
+                    || directed.next() != Some(input)
+                {
+                    return Err(UnsupportedConfiguration);
+                }
+            }
+        }
+        let raw = StoredStructure::for_query(self, steps).ok_or(IncompleteProvider)?;
+        if !operator
+            && membership_evidence::first_unowned_member(
+                self,
+                &raw,
+                receiver,
+                "FeatureMembership",
+                "Function",
+                None,
+                steps,
+            ) != Some(callee)
+        {
+            return Err(StaleEvidence);
+        }
+        let domains = raw
+            .membership_domains(self, steps)
+            .ok_or(IncompleteProvider)?;
+        let inverse = raw.typing(self, steps).ok_or(IncompleteProvider)?;
+        if !raw.ids_unique
+            || raw.annotations_incomplete
+            || inverse.sources_incomplete
+            || self.metadata_associations_incomplete
+            || !domains.owner_complete(receiver)
+            || raw.metadata_annotation_targets.contains(&receiver)
+            || self
+                .metadata_of
+                .get(&receiver)
+                .is_some_and(|m| !m.is_empty())
+            || !semantic_ownership::owned_feature_projection_complete(self, receiver)
+        {
+            return Err(IncompleteProvider);
+        }
+        let stamp = Stamp::capture_builder(self);
+        charge(steps, inputs.len())?;
+        let eligible: HashSet<_> = inputs.iter().map(|e| e.0).collect();
+        let relationships =
+            semantic_ownership::owned_relationships(self, receiver).ok_or(IncompleteProvider)?;
+        charge(steps, relationships.len())?;
+        let relationships: Vec<_> = relationships.iter().collect();
+        let mut seen = HashSet::new();
+        let mut mapped = HashMap::new();
+        let mut argument_position = 0;
+        for relationship in relationships {
+            if !seen.insert(relationship)
+                || semantic_ownership::checked_relationship_carrier(self, &raw, relationship, steps)
+                    != Some(Some(receiver))
+            {
+                return Err(InvalidRelationship);
+            }
+            let kind = self.elements[relationship].ty;
+            if !conforms(kind, "FeatureMembership") {
+                continue;
+            }
+            let parameter = membership_evidence::member(self, &raw, receiver, relationship, steps)
+                .ok_or(InvalidRelationship)?;
+            if !domains.owner_complete(parameter)
+                || raw.metadata_annotation_targets.contains(&parameter)
+                || self
+                    .metadata_of
+                    .get(&parameter)
+                    .is_some_and(|m| !m.is_empty())
+                || self.elements[parameter].ty != "Feature"
+            {
+                return Err(IncompleteProvider);
+            }
+            let direction = membership_evidence::parameter_direction(self, &raw, parameter, steps)
+                .ok_or(InvalidRelationship)?;
+            let valuation = membership_evidence::valuation(self, &raw, parameter, steps)
+                .ok_or(InvalidRelationship)?;
+            if conforms(kind, "ReturnParameterMembership") {
+                if direction != Some("out") || valuation.is_some() {
+                    return Err(UnsupportedConfiguration);
+                }
+                continue;
+            }
+            if kind != "ParameterMembership" || direction != Some("in") {
+                return Err(UnsupportedConfiguration);
+            }
+            let position = argument_position;
+            argument_position += 1;
+            let (value_membership, value) = valuation.ok_or(UnmappedArgument)?;
+            for key in ["isInitial", "isDefault"] {
+                if self.elements[value_membership]
+                    .props
+                    .get(key)
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+                {
+                    return Err(UnsupportedConfiguration);
+                }
+            }
+            let owned = semantic_ownership::owned_relationships(self, parameter)
+                .ok_or(IncompleteProvider)?;
+            charge(steps, owned.len())?;
+            let owned: Vec<_> = owned.iter().collect();
+            let mut target = None;
+            let mut witnessed = HashSet::new();
+            for rel in owned.iter().copied().chain(
+                inverse
+                    .relationships
+                    .get(&parameter)
+                    .into_iter()
+                    .flatten()
+                    .copied(),
+            ) {
+                charge(steps, 1)?;
+                if !witnessed.insert(rel) {
+                    continue;
+                }
+                let row = &self.elements[rel];
+                // Extra owned features, conjugation or value-affecting metadata
+                // require a broader provider; do not silently drop them.
+                if conforms(row.ty, "FeatureMembership") || conforms(row.ty, "Conjugation") {
+                    return Err(UnsupportedConfiguration);
+                }
+                if !conforms(row.ty, "Redefinition") {
+                    continue;
+                }
+                if target.is_some() {
+                    return Err(UnsupportedConfiguration);
+                }
+                if !owned.contains(&rel)
+                    || semantic_ownership::checked_relationship_carrier(self, &raw, rel, steps)
+                        != Some(Some(parameter))
+                    || !self.static_chain_row_current(rel)
+                    || !self.result_redefinition_row_current(rel)
+                {
+                    return Err(InvalidRelationship);
+                }
+                let implied = match row.props.get("isImplied") {
+                    None => false,
+                    Some(v) => v.as_bool().ok_or(InvalidRelationship)?,
+                };
+                let mapped_input = type_relations::endpoint_with_carrier(
+                    self,
+                    parameter,
+                    Some(parameter),
+                    rel,
+                    &["specific", "subsettingFeature", "redefiningFeature"],
+                    &["general", "subsettedFeature", "redefinedFeature"],
+                    "Feature",
+                    steps,
+                )
+                .ok_or(InvalidRelationship)?;
+                if !eligible.contains(&mapped_input) {
+                    return Err(UnmappedArgument);
+                }
+                if implied {
+                    // Generic parameter ordinals include output parameters. An
+                    // input-only position cannot repair a declined shared plan.
+                    // Source flags alone never admit a purported implied edge.
+                    if rel < self.explicit_len()
+                        || inputs.get(position) != Some(&ElementRef(mapped_input))
+                        || !self.semantic_ownership.as_ref().is_some_and(|view| {
+                            view.matches_suffix(self)
+                                && view.generated_relationship_owner(rel) == Some(parameter)
+                        })
+                    {
+                        return Err(UnsupportedConfiguration);
+                    }
+                    let plan = self.effective_dynamic_plan().ok_or(StaleEvidence)?;
+                    if !plan.affected_owners.contains(&parameter)
+                        || plan.incomplete_bases.contains(&receiver)
+                        || plan.positional.incomplete.contains(&receiver)
+                    {
+                        return Err(IncompleteProvider);
+                    }
+                    let targets = plan
+                        .positional
+                        .targets
+                        .get(&parameter)
+                        .ok_or(UnmappedArgument)?;
+                    charge(steps, targets.len().saturating_add(1))?;
+                    if targets.as_slice() != [mapped_input] {
+                        return Err(UnsupportedConfiguration);
+                    }
+                } else if rel >= self.explicit_len() {
+                    return Err(InvalidRelationship);
+                }
+                target = Some(mapped_input);
+            }
+            let input = if let Some(target) = target {
+                target
+            } else if let Some(proposed) = proposed.as_deref_mut().filter(|_| operator) {
+                let target = inputs.get(position).ok_or(UnmappedArgument)?.0;
+                proposed.insert(parameter, vec![target]);
+                target
+            } else {
+                return Err(UnmappedArgument);
+            };
+            if mapped
+                .insert(
+                    input,
+                    InvocationBinding {
+                        input: ElementRef(input),
+                        parameter: ElementRef(parameter),
+                        value: ElementRef(value),
+                    },
+                )
+                .is_some()
+            {
+                return Err(DuplicateArgument);
+            }
+        }
+        charge(steps, inputs.len())?;
+        let bindings = inputs.iter().filter_map(|i| mapped.remove(&i.0)).collect();
+        if !stamp.current_builder(self) {
+            return Err(StaleEvidence);
+        }
+        Ok(InvocationBindings {
+            callee: ElementRef(callee),
+            inputs,
+            bindings,
+        })
+    }
+}
+
+/// Shared exact loaded-library identity used by the evaluator's designated
+/// Function lookup. Only ordinary numeric operators enter this bounded domain.
+pub(super) fn numeric_operator_name(b: &super::Builder, receiver: usize) -> Option<&'static str> {
+    if b.graph_format != crate::model::GraphFormat::CanonicalV3
+        || b.elements.get(receiver)?.ty != "OperatorExpression"
+    {
+        return None;
+    }
+    let operator = b.elements[receiver].props.get("operator")?.as_str()?;
+    Some(match operator {
+        "+" => "+",
+        "-" => "-",
+        "*" => "*",
+        "/" => "/",
+        "%" => "%",
+        "^" => "^",
+        _ => return None,
+    })
+}
+pub(super) fn numeric_operator_target(
+    b: &mut super::Builder,
+    receiver: usize,
+    steps: &mut usize,
+) -> Option<usize> {
+    let operator = numeric_operator_name(b, receiver)?;
+    let raw = StoredStructure::for_query(b, steps)?;
+    if !raw.ids_unique || raw.annotations_incomplete || b.metadata_associations_incomplete {
+        return None;
+    }
+    // The global roots and external package lookup use the same reciprocal
+    // membership authority as checked Namespace operations. This bounded
+    // direct-name subset never interprets a compatibility-resolver miss as an
+    // absence certificate, or enters its unbudgeted import/alias traversal.
+    charge(steps, b.unit_starts.len()).ok()?;
+    let roots: Vec<_> = b.unit_starts.iter().map(|&(root, _)| root).collect();
+    let mut base = None;
+    let mut data = None;
+    for root in roots {
+        if b.elements[root].ty != "Namespace" || b.elements[root].owning_relationship.is_some() {
+            return None;
+        }
+        for (name, selected) in [("BaseFunctions", &mut base), ("DataFunctions", &mut data)] {
+            if let Some(found) = direct_designated_member(b, &raw, root, name, false, steps)? {
+                if selected.replace(found).is_some() {
+                    return None;
+                }
+            }
+        }
+    }
+    // OperatorExpression::instantiatedType searches BaseFunctions first. Its
+    // absence is established over the complete public direct-name domain.
+    if let Some(base) = base {
+        if !matches!(b.elements[base].ty, "Package" | "LibraryPackage")
+            || direct_designated_member(b, &raw, base, operator, true, steps)?.is_some()
+        {
+            return None;
+        }
+    }
+    let data = data?;
+    if !matches!(b.elements[data].ty, "Package" | "LibraryPackage") {
+        return None;
+    }
+    let target = direct_designated_member(b, &raw, data, operator, true, steps)??;
+    charge(steps, b.lib_qnames.len()).ok()?;
+    let mut names = b
+        .lib_qnames
+        .iter()
+        .filter(|(_, name)| name.as_slice() == ["DataFunctions", operator]);
+    let (id, _) = names.next()?;
+    (target < b.lib_boundary
+        && b.elements[target].ty == "Function"
+        && *id == b.elements[target].id
+        && names.next().is_none())
+    .then_some(target)
+}
+
+/// A deliberately narrow, complete subset of Namespace name selection. Public
+/// imports and aliases need the contextual provider and remain qualified here.
+/// Valid private imports cannot contribute an externally visible member.
+fn direct_designated_member(
+    b: &super::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    name: &str,
+    external: bool,
+    steps: &mut usize,
+) -> Option<Option<usize>> {
+    if !raw.membership_domains(b, steps)?.owner_complete(owner)
+        || !raw.import_domains(b, steps)?.owner_complete(owner)
+        || raw.metadata_annotation_targets.contains(&owner)
+        || b.metadata_of.get(&owner).is_some_and(|v| !v.is_empty())
+    {
+        return None;
+    }
+    let relationships = semantic_ownership::owned_relationships(b, owner)?;
+    charge(steps, relationships.len()).ok()?;
+    let mut seen = HashSet::new();
+    let mut result = None;
+    for relationship in relationships.iter() {
+        if !seen.insert(relationship)
+            || semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)?
+                != Some(owner)
+        {
+            return None;
+        }
+        let relation = &b.elements[relationship];
+        let visibility = match relation.props.get("visibility") {
+            None if conforms(relation.ty, "Import") => "private",
+            None => "public",
+            Some(value) => value.as_str()?,
+        };
+        if !matches!(visibility, "private" | "protected" | "public") {
+            return None;
+        }
+        if conforms(relation.ty, "Import") {
+            super::import_memberships::checked_import_target(b, raw, owner, relationship, steps)?;
+            if !external || visibility == "public" {
+                return None;
+            }
+            continue;
+        }
+        if matches!(relation.ty, "ElementFilterMembership")
+            || conforms(relation.ty, "Specialization")
+        {
+            return None;
+        }
+        if !conforms(relation.ty, "Membership") {
+            continue;
+        }
+        let member = membership_evidence::member(b, raw, owner, relationship, steps)?;
+        if external && visibility != "public" {
+            continue;
+        }
+        // Restrict names to literal declaration names; effective names and
+        // alias providers retain explicit qualification, never false absence.
+        if !conforms(relation.ty, "OwningMembership")
+            || raw.metadata_annotation_targets.contains(&member)
+            || b.metadata_of.get(&member).is_some_and(|v| !v.is_empty())
+        {
+            return None;
+        }
+        let row = &b.elements[member];
+        let mut named = false;
+        let mut matches = false;
+        for key in ["declaredName", "declaredShortName"] {
+            if let Some(value) = row.props.get(key).filter(|v| !v.is_null()) {
+                let value = value.as_str()?;
+                charge(steps, value.len()).ok()?;
+                named = true;
+                matches |= value == name;
+            }
+        }
+        if !named && conforms(row.ty, "Feature") {
+            return None;
+        }
+        if matches && result.replace(member).is_some() {
+            return None;
+        }
+    }
+    Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ClosurePolicy, PropertyError},
+        model::{GraphFormat, Model},
+    };
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+    fn fixture(source: &str, format: GraphFormat) -> (ResolvedModel, ElementRef) {
+        let mut m = Model::with_graph_format(format);
+        assert!(
+            m.add_library_source("binding-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let parsed = m.add_source("bindings.kerml", source);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let r = ResolvedModel::build(&m);
+        let call = ElementRef(
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap(),
+        );
+        (r, call)
+    }
+    #[test]
+    fn accepted_call_that_becomes_unadmitted_cannot_reuse_old_family() {
+        let (mut r, call) = fixture(
+            "function F {in p; return result;} feature call=F(1);",
+            GraphFormat::CanonicalV3,
+        );
+        r.implied_relationships(call);
+        assert!(r.invocation_binding_report(call).arguments.is_ok());
+        let old_ids: Vec<_> =
+            r.b.effective_dynamic_plan()
+                .unwrap()
+                .tail
+                .iter()
+                .map(|edge| edge.id)
+                .collect();
+        assert!(!old_ids.is_empty());
+        let callee = r.b.elements[call.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&row| {
+                conforms(r.b.elements[row].ty, "Membership")
+                    && !conforms(r.b.elements[row].ty, "FeatureMembership")
+            })
+            .unwrap();
+        r.b.elements[callee]
+            .props
+            .insert("memberElement", serde_json::json!({"@ref":"Missing"}));
+        assert!(r.invocation_binding_report(call).arguments.is_err());
+        // An edit transaction retracts the shared tail before replanning. The
+        // unsupported call may then be locally qualified, never retain old
+        // dynamic rows under a new accepted plan with a smaller owner set.
+        r.discard_owned_result_tail();
+        r.implied_relationships(call);
+        let current = r.b.effective_dynamic_plan().unwrap();
+        assert!(current.incomplete_bases.contains(&call.0));
+        assert!(!current.affected_owners.contains(&call.0));
+        assert!(current.tail.iter().all(|edge| !old_ids.contains(&edge.id)));
+        assert!(r.b.elements.iter().all(|row| !old_ids.contains(&row.id)));
+        assert!(r.invocation_binding_report(call).arguments.is_err());
+    }
+
+    #[test]
+    fn numeric_operator_bindings_require_canonical_shared_publication() {
+        use crate::json::ModelLevelEvaluability::{Evaluable, Unknown};
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut m = Model::with_graph_format(format);
+            m.add_library_source("binding-library.kerml", LIB);
+            m.add_library_source(
+                "numeric-functions.kerml",
+                "standard library package DataFunctions {function '+' {in a; in b; return r;}} ",
+            );
+            m.add_source("operator.kerml", "feature sum=1+2;");
+            let mut r = ResolvedModel::build(&m);
+            let call = r
+                .elements()
+                .find(|&e| r.element_type(e) == "OperatorExpression")
+                .unwrap();
+            assert!(r.invocation_binding_report(call).arguments.is_err());
+            assert!(matches!(
+                r.model_level_evaluability(call).classification,
+                Unknown(_)
+            ));
+            let _ = r.implied_relationships(call);
+            if format == GraphFormat::CanonicalV3 {
+                let report = r.invocation_binding_report(call).arguments.unwrap();
+                assert_eq!(report.bindings.len(), 2);
+                assert_eq!(r.model_level_evaluability(call).classification, Evaluable);
+                r.b.elements[call.0]
+                    .props
+                    .insert("operator", serde_json::json!("missing"));
+                assert!(r.invocation_binding_report(call).arguments.is_err());
+                assert!(matches!(
+                    r.model_level_evaluability(call).classification,
+                    Unknown(_)
+                ));
+            } else {
+                assert!(r.invocation_binding_report(call).arguments.is_err());
+            }
+        }
+    }
+    #[test]
+    fn numeric_operator_absence_requires_complete_earlier_package() {
+        for earlier in [
+            "standard library package BaseFunctions {public import Missing::*;}",
+            "standard library package BaseFunctions {function '+' {in a; in b; return r;}}",
+            "standard library package BaseFunctions {alias '+' for Missing::unknown;}",
+        ] {
+            let mut m = Model::with_graph_format(GraphFormat::CanonicalV3);
+            m.add_library_source("binding-library.kerml", LIB);
+            m.add_library_source("earlier.kerml", earlier);
+            m.add_library_source(
+                "numeric.kerml",
+                "standard library package DataFunctions {function '+' {in a; in b; return r;}}",
+            );
+            m.add_source("operator.kerml", "feature sum=1+2;");
+            let mut r = ResolvedModel::build(&m);
+            let call = r
+                .elements()
+                .find(|&e| r.element_type(e) == "OperatorExpression")
+                .unwrap();
+            r.implied_relationships(call);
+            assert!(
+                r.invocation_binding_report(call).arguments.is_err(),
+                "{earlier}"
+            );
+        }
+        // The real designated packages use private imports. They cannot
+        // contribute an externally selected operator and do not block proof.
+        let mut m = Model::with_graph_format(GraphFormat::CanonicalV3);
+        m.add_library_source("binding-library.kerml", LIB);
+        m.add_library_source("numeric.kerml", "standard library package BaseFunctions {private import Base::*;} standard library package DataFunctions {private import Base::Anything; function '+' {in a; in b; return r;}}");
+        m.add_source("operator.kerml", "feature sum=1+2;");
+        let mut r = ResolvedModel::build(&m);
+        // Serialized imports may omit the normative default-private flag.
+        for index in 0..r.b.elements.len() {
+            let row = &mut r.b.elements[index];
+            if conforms(row.ty, "Import") {
+                let old = row.props.to_json();
+                row.props = crate::properties::Properties::new();
+                for (key, value) in old {
+                    if key != "visibility" {
+                        row.props.insert(&key, value);
+                    }
+                }
+            }
+        }
+        let call = r
+            .elements()
+            .find(|&e| r.element_type(e) == "OperatorExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        assert_eq!(
+            r.invocation_binding_report(call)
+                .arguments
+                .unwrap()
+                .bindings
+                .len(),
+            2
+        );
+    }
+    #[test]
+    fn unavailable_numeric_operator_does_not_poison_valid_invocations() {
+        let (mut r, call) = fixture(
+            "function F {in a; return r;} feature x=F(1); feature unsupported=1+2;",
+            GraphFormat::CanonicalV3,
+        );
+        let _ = r.implied_relationships(call);
+        assert_eq!(
+            r.invocation_binding_report(call)
+                .arguments
+                .unwrap()
+                .bindings
+                .len(),
+            1
+        );
+    }
+    #[test]
+    fn named_arguments_preserve_input_order_and_do_not_truncate_at_omissions() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            for args in ["b=2, a=1", "b=2", ""] {
+                let (mut r, call) = fixture(
+                    &format!("function F {{in a; in b; return r;}} feature x=F({args});"),
+                    format,
+                );
+                let len = r.b.elements.len();
+                let a = r.resolve_qualified("F::a").unwrap();
+                let b = r.resolve_qualified("F::b").unwrap();
+                let report = r.invocation_binding_report(call);
+                let result = report.arguments.unwrap();
+                assert_eq!(result.inputs, [a, b]);
+                let expected = match args {
+                    "" => vec![],
+                    "b=2" => vec![b],
+                    _ => vec![a, b],
+                };
+                assert_eq!(
+                    result.bindings.iter().map(|b| b.input).collect::<Vec<_>>(),
+                    expected
+                );
+                assert_eq!(r.b.elements.len(), len);
+                assert!(r.b.implied.is_none());
+                assert_eq!(
+                    r.invocation_binding_report(call).arguments,
+                    Ok(result.clone())
+                );
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                assert_eq!(
+                    r.property(call, "argument")
+                        .unwrap()
+                        .as_array()
+                        .unwrap()
+                        .len(),
+                    result.bindings.len()
+                );
+            }
+        }
+    }
+    #[test]
+    fn positional_bindings_require_a_current_published_plan_and_aligned_inputs() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            for source in [
+                "function F {in a; in b; return r;} feature x=F(1,2);",
+                "function F {in a; in b; return r;} feature x=F(1,b=2);",
+            ] {
+                let (mut r, call) = fixture(source, format);
+                assert!(r.invocation_binding_report(call).arguments.is_err());
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let _ = r.implied_relationships(call);
+                let count = r.b.elements.len();
+                let report = r
+                    .invocation_binding_report(call)
+                    .arguments
+                    .unwrap_or_else(|e| panic!("{source}: {e:?}"));
+                assert_eq!(report.bindings.len(), 2);
+                assert_eq!(
+                    report.bindings.iter().map(|b| b.input).collect::<Vec<_>>(),
+                    report.inputs
+                );
+                assert_eq!(
+                    r.property(call, "argument")
+                        .unwrap()
+                        .as_array()
+                        .unwrap()
+                        .len(),
+                    2
+                );
+                assert_eq!(r.b.elements.len(), count);
+                assert_eq!(
+                    r.invocation_binding_report_with_budget(call, crate::eval::MAX_STEPS)
+                        .arguments,
+                    Err(WorkLimit)
+                );
+                assert_eq!(r.invocation_binding_report(call).arguments, Ok(report));
+            }
+        }
+    }
+    #[test]
+    fn admitted_positional_bindings_replay_across_prepared_library_paths() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut base = Model::with_graph_format(format);
+            base.add_library_source("binding-library.kerml", LIB);
+            base.record_library_cache();
+            ResolvedModel::build(&base);
+            let cache =
+                LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                    .unwrap();
+            let prepared = base.prepare_library().unwrap();
+            let decoded = Arc::new(
+                PreparedLibrary::from_bytes(&prepared.to_bytes(131).unwrap(), 131).unwrap(),
+            );
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut m = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                    _ => {
+                        m.add_library_source("binding-library.kerml", LIB);
+                        if mode == 1 {
+                            m.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                m.add_source(
+                    "bindings.kerml",
+                    "function F {in a; in b; return r;} feature x=F(1,b=2);",
+                );
+                let mut r = ResolvedModel::build(&m);
+                let call = r
+                    .elements()
+                    .find(|&e| r.element_type(e) == "InvocationExpression")
+                    .unwrap();
+                let before =
+                    crate::full::resolved_to_full_json(&mut r, &m, Default::default()).unwrap();
+                let report = r.invocation_binding_report(call).arguments.unwrap();
+                let ids: Vec<_> = report
+                    .bindings
+                    .iter()
+                    .map(|b| {
+                        (
+                            r.element_id(b.input),
+                            r.element_id(b.parameter),
+                            r.element_id(b.value),
+                        )
+                    })
+                    .collect();
+                if let Some(ref expected) = expected {
+                    assert_eq!(&ids, expected);
+                } else {
+                    expected = Some(ids);
+                }
+                assert_eq!(
+                    crate::full::resolved_to_full_json(&mut r, &m, Default::default()).unwrap(),
+                    before
+                );
+            }
+        }
+    }
+    #[test]
+    fn output_first_and_authored_implied_flags_never_supply_positional_proof() {
+        // A function's parameters are its own, then the inherited ones
+        // after them: `F(1, 2)` binds the two `A` declares.
+        let (mut r, call) = fixture(
+            "function A {in a; in b; return r;} function F specializes A; feature x=F(1,2);",
+            GraphFormat::LegacyV2,
+        );
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let _ = r.to_full_json_strict();
+        assert!(r.invocation_binding_report(call).arguments.is_ok());
+        for source in [
+            "function F {out feature priorOutput; in a; return r;} feature x=F(1);",
+            "function F {in a; in b; return r;} feature x=F(1,2,3);",
+        ] {
+            let (mut r, call) = fixture(source, GraphFormat::LegacyV2);
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            let _ = r.to_full_json_strict();
+            assert!(r.invocation_binding_report(call).arguments.is_err());
+        }
+        let (mut r, call) = fixture(
+            "function F {in a; return r;} feature x=F(a=1);",
+            GraphFormat::LegacyV2,
+        );
+        let binding = r
+            .invocation_binding_report(call)
+            .arguments
+            .unwrap()
+            .bindings
+            .remove(0);
+        let relationship = r.b.elements[binding.parameter.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| r.b.elements[i].ty == "Redefinition")
+            .unwrap();
+        r.b.set(relationship, "isImplied", serde_json::json!(true));
+        let _ = r.to_full_json_strict();
+        assert!(r.invocation_binding_report(call).arguments.is_err());
+    }
+    #[test]
+    fn positional_snapshot_rejects_same_length_input_and_generated_endpoint_edits() {
+        for change in [0, 1, 2] {
+            let (mut r, call) = fixture(
+                "function F {in a; in b; return r;} feature x=F(1,2);",
+                GraphFormat::CanonicalV3,
+            );
+            let _ = r.to_full_json_strict();
+            let mapping = r.invocation_binding_report(call).arguments.unwrap();
+            let a = mapping.inputs[0];
+            let b = mapping.inputs[1];
+            match change {
+                0 => r.b.set(a.0, "direction", serde_json::json!("out")),
+                1 => {
+                    let p = mapping.bindings[0].parameter.0;
+                    let rel = semantic_ownership::owned_relationships(&r.b, p)
+                        .unwrap()
+                        .iter()
+                        .find(|&i| r.b.elements[i].ty == "Redefinition")
+                        .unwrap();
+                    r.b.set(
+                        rel,
+                        "redefinedFeature",
+                        serde_json::json!({"@id":r.element_id(b)}),
+                    );
+                }
+                _ => {
+                    let f = r.resolve_qualified("F").unwrap();
+                    let mut rows = r.b.elements[f.0].owned_relationships.to_vec();
+                    rows.swap(0, 1);
+                    r.b.elements[f.0].owned_relationships = rows.into();
+                }
+            }
+            assert!(r.invocation_binding_report(call).arguments.is_err());
+        }
+    }
+    #[test]
+    fn inherited_inputs_and_missing_earlier_inputs_keep_supplied_values() {
+        let (mut r, call) = fixture(
+            "function B {in a; in b; return r;} function F specializes B; feature x=F(b=2);",
+            GraphFormat::LegacyV2,
+        );
+        let b = r.resolve_qualified("B::b").unwrap();
+        assert_eq!(
+            r.invocation_binding_report(call)
+                .arguments
+                .unwrap()
+                .bindings[0]
+                .input,
+            b
+        );
+    }
+    #[test]
+    fn duplicate_unknown_and_unproved_positional_arguments_are_qualified() {
+        for args in ["a=1,a=2", "z=1", "1", "a=1,b=2,c=3"] {
+            let (mut r, call) = fixture(
+                &format!("function F {{in a; in b; return r;}} feature x=F({args});"),
+                GraphFormat::LegacyV2,
+            );
+            assert!(
+                r.invocation_binding_report(call).arguments.is_err(),
+                "{args}"
+            );
+        }
+    }
+    #[test]
+    fn malformed_values_and_same_length_redefinition_edits_never_reuse_old_bindings() {
+        for key in [
+            "redefinedFeature",
+            "isDefault",
+            "isInitial",
+            "ownedMemberParameter",
+        ] {
+            let (mut r, call) = fixture(
+                "function F {in a; return r;} feature x=F(a=1);",
+                GraphFormat::LegacyV2,
+            );
+            let report = r.invocation_binding_report(call).arguments.unwrap();
+            let param = report.bindings[0].parameter.0;
+            let row = match key {
+                "ownedMemberParameter" => r.b.elements[param].owning_relationship.unwrap(),
+                "redefinedFeature" => r.b.elements[param]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&e| r.b.elements[e].ty == "Redefinition")
+                    .unwrap(),
+                _ => r.b.elements[param]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&e| r.b.elements[e].ty == "FeatureValue")
+                    .unwrap(),
+            };
+            r.b.elements[row].props.insert(key, serde_json::Value::Null);
+            assert!(
+                r.invocation_binding_report(call).arguments.is_err(),
+                "{key}"
+            );
+        }
+    }
+    #[test]
+    fn inverse_orphan_value_is_not_an_absence_or_unique_value_proof() {
+        let (mut r, call) = fixture(
+            "function F {in a; return r;} feature x=F(a=1);",
+            GraphFormat::LegacyV2,
+        );
+        let binding = r
+            .invocation_binding_report(call)
+            .arguments
+            .unwrap()
+            .bindings
+            .remove(0);
+        let param = binding.parameter.0;
+        let value = r.b.elements[param]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&e| r.b.elements[e].ty == "FeatureValue")
+            .unwrap();
+        r.b.elements[param].owned_relationships = r.b.elements[param]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&e| e != value)
+            .collect::<Vec<_>>()
+            .into();
+        let id = r.b.elements[param].id;
+        r.b.elements[value]
+            .props
+            .insert("featureWithValue", serde_json::json!({"@id":id}));
+        assert!(r.invocation_binding_report(call).arguments.is_err());
+    }
+    #[test]
+    fn budget_retry_and_policy_are_explicit() {
+        let (mut r, call) = fixture(
+            "function F {in a; return r;} feature x=F(a=1);",
+            GraphFormat::LegacyV2,
+        );
+        assert_eq!(
+            r.invocation_binding_report_with_budget(call, crate::eval::MAX_STEPS)
+                .arguments,
+            Err(WorkLimit)
+        );
+        assert!(r.invocation_binding_report(call).arguments.is_ok());
+        assert_eq!(
+            r.property(call, "argument"),
+            Err(PropertyError::Approximate)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/literal_inheritance.rs b/crates/sysmlv2-model/src/json/literal_inheritance.rs
new file mode 100644
index 0000000..9ece0c7
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/literal_inheritance.rs
@@ -0,0 +1,502 @@
+//! Supported fixed-base expression heritage without allocating textual declaration scopes.
+use super::{Builder, MembershipContext, MembershipProjection, implied};
+use crate::metaclass::conforms;
+use uuid::Uuid;
+
+/// Present generic endpoint arrays must describe the same local carrier as
+/// its named ends. relatedElement is a nonunique Sequence: preserve both
+/// occurrences when source and target are the same identity.
+fn consistent_relation_arrays(
+    b: &Builder,
+    relationship: usize,
+    source: Uuid,
+    target: Uuid,
+    context: &mut MembershipContext,
+) -> bool {
+    let relation = &b.elements[relationship];
+    if !context.charge(relation.children.len()) || relation.children.len() > 2 {
+        return false;
+    }
+    let mut children = [Uuid::nil(); 2];
+    for (index, &child) in relation.children.iter().enumerate() {
+        let Some(element) = b.elements.get(child) else {
+            return false;
+        };
+        if children[..index].contains(&element.id)
+            || element.owning_relationship != Some(relationship)
+            || ![source, target].contains(&element.id)
+        {
+            return false;
+        }
+        children[index] = element.id;
+    }
+    for (key, expected) in [
+        ("source", &[source][..]),
+        ("target", &[target][..]),
+        ("relatedElement", &[source, target][..]),
+        ("ownedRelatedElement", &children[..relation.children.len()]),
+    ] {
+        let Some(value) = relation.props.get(key) else {
+            continue;
+        };
+        let Some(values) = value.as_array() else {
+            return false;
+        };
+        if !context.charge(values.len().saturating_add(1))
+            || values.len() != expected.len()
+            || !values
+                .iter()
+                .zip(expected)
+                .all(|(value, id)| value.as_reference() == Some(*id))
+        {
+            return false;
+        }
+    }
+    true
+}
+
+impl Builder {
+    /// Preserve the existing empty result for other scope-less elements.
+    /// Supported fixed-base results require a loaded, typed library feature and exactly one
+    /// surviving typed return Membership. Missing/external library fragments
+    /// remain incomplete; no result or type is invented from the expression value.
+    pub(super) fn literal_inherited_memberships(
+        &mut self,
+        element: usize,
+        include_implied: bool,
+    ) -> MembershipProjection {
+        let Some(owner) = self.elements.get(element) else {
+            return MembershipProjection::default();
+        };
+        let ty = owner.ty;
+        if implied::literal_implied_base(ty).is_none() {
+            return MembershipProjection::default();
+        }
+        if include_implied && self.semantic_ready {
+            self.ensure_positional_redefinitions();
+        }
+        let mut context = MembershipContext::default();
+        if self.literal_identities_unique(Some(&mut context.steps)) != Some(true) {
+            return MembershipProjection {
+                incomplete: true,
+                truncated: context.steps > crate::eval::MAX_STEPS,
+                ..MembershipProjection::default()
+            };
+        }
+        let family = context.new_type_family();
+        let inherited = self.contextual_inherited_bindings(
+            element,
+            include_implied,
+            &[],
+            &[],
+            family,
+            &mut context,
+            0,
+        );
+        let mut result = MembershipProjection {
+            membership_order: inherited.membership_order.clone(),
+            truncated: inherited.truncated,
+            incomplete: inherited.incomplete,
+            implicit_redefinitions: inherited.implicit_redefinitions.clone(),
+        };
+        if !include_implied {
+            return result;
+        }
+        let required = self
+            .planned_literal_target(ty)
+            .and_then(|id| self.element_index_of_uuid(id));
+        let required_ready = required.is_some_and(|required| {
+            conforms(self.elements[required].ty, "Feature")
+                && self.literal_has_typing(required, "Function", &mut context)
+        });
+        let result_ready = self
+            .literal_inherited_result(&result, &mut context)
+            .is_some_and(|member| self.literal_has_typing(member, "Type", &mut context));
+        if !required_ready || !result_ready {
+            result.incomplete = true;
+        }
+        result.incomplete |= self.recorded_lookup_incomplete;
+        result.truncated |= context.steps > crate::eval::MAX_STEPS;
+        result
+    }
+
+    /// Result identity belongs to the library, through the inherited return
+    /// Membership. Distinct surviving returns are indeterminate, not first-wins.
+    pub(super) fn literal_inherited_result(
+        &mut self,
+        inherited: &MembershipProjection,
+        context: &mut MembershipContext,
+    ) -> Option<usize> {
+        if !self.literal_identities_unique(Some(&mut context.steps))? {
+            return None;
+        }
+        if !context.charge(inherited.membership_order.len()) {
+            return None;
+        }
+        let mut found = None;
+        for &membership in &inherited.membership_order {
+            if !conforms(self.elements[membership].ty, "ReturnParameterMembership") {
+                continue;
+            }
+            let member = self.stored_membership_member(membership)?;
+            if !conforms(self.elements[member].ty, "Feature")
+                || self.elements[member].owning_relationship != Some(membership)
+                || self.elements[membership].children.len() != 1
+                || self.elements[membership].children.first().copied() != Some(member)
+                || found.is_some_and(|(previous, _)| previous != membership)
+            {
+                return None;
+            }
+            let relation = &self.elements[membership];
+            let owner_id = relation.props.get("owningRelatedElement")?.as_reference()?;
+            for key in ["membershipOwningNamespace", "owningType"] {
+                if relation
+                    .props
+                    .get(key)
+                    .is_some_and(|v| v.as_reference() != Some(owner_id))
+                {
+                    return None;
+                }
+            }
+            for key in [
+                "memberElement",
+                "ownedMemberElement",
+                "ownedMemberFeature",
+                "memberFeature",
+            ] {
+                if relation
+                    .props
+                    .get(key)
+                    .is_some_and(|v| v.as_reference() != Some(self.elements[member].id))
+                {
+                    return None;
+                }
+            }
+            if !consistent_relation_arrays(
+                self,
+                membership,
+                owner_id,
+                self.elements[member].id,
+                context,
+            ) {
+                return None;
+            }
+            let owner = self.element_index_of_uuid(owner_id)?;
+            if !conforms(self.elements[owner].ty, "Type")
+                || !context.charge(self.elements[owner].owned_relationships.len())
+                || self.elements[owner]
+                    .owned_relationships
+                    .iter()
+                    .filter(|&&r| r == membership)
+                    .count()
+                    != 1
+            {
+                return None;
+            }
+            found = Some((membership, member));
+        }
+        found.map(|(_, member)| member)
+    }
+
+    fn literal_has_typing(
+        &mut self,
+        feature: usize,
+        target_kind: &str,
+        context: &mut MembershipContext,
+    ) -> bool {
+        let relationships = self.elements[feature].owned_relationships.clone();
+        if !context.charge(relationships.len()) {
+            return false;
+        }
+        let mut found = false;
+        let mut seen = std::collections::HashSet::new();
+        for relationship in relationships {
+            let relation = &self.elements[relationship];
+            if !conforms(relation.ty, "FeatureTyping") {
+                continue;
+            }
+            if !seen.insert(relationship)
+                || relation
+                    .props
+                    .get("owningRelatedElement")
+                    .and_then(|v| v.as_reference())
+                    != Some(self.elements[feature].id)
+            {
+                return false;
+            }
+            let Some(id) = implied::specialization_target(relation) else {
+                return false;
+            };
+            for key in ["type", "general"] {
+                if relation
+                    .props
+                    .get(key)
+                    .is_some_and(|value| value.as_reference() != Some(id))
+                {
+                    return false;
+                }
+            }
+            for key in ["typedFeature", "specific"] {
+                if relation
+                    .props
+                    .get(key)
+                    .is_some_and(|value| value.as_reference() != Some(self.elements[feature].id))
+                {
+                    return false;
+                }
+            }
+            if !consistent_relation_arrays(
+                self,
+                relationship,
+                self.elements[feature].id,
+                id,
+                context,
+            ) {
+                return false;
+            }
+            let Some(target) = self.element_index_of_uuid(id) else {
+                return false;
+            };
+            if !conforms(self.elements[target].ty, target_kind) {
+                return false;
+            }
+            found = true;
+        }
+        found
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    use serde_json::json;
+    fn model() -> (ResolvedModel, usize, usize) {
+        let mut m = Model::new();
+        m.add_library_source("literal.kerml", "standard library package Values {datatype Integer;} standard library package Performances {function F {return result:Values::Integer;} expr literalIntegerEvaluations:F;}");
+        m.add_source("use.kerml", "feature x=1;");
+        assert!(!m.has_errors());
+        let mut r = ResolvedModel::build(&m);
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "LiteralInteger")
+            .unwrap()
+            .0;
+        let role = r
+            .resolve_qualified("Performances::literalIntegerEvaluations")
+            .unwrap();
+        assert!(
+            r.b.lib_qnames
+                .iter()
+                .any(|(id, name)| *id == r.element_id(role)
+                    && name
+                        == &[
+                            "Performances".to_owned(),
+                            "literalIntegerEvaluations".to_owned()
+                        ])
+        );
+        let result = r.resolve_qualified("Performances::F::result").unwrap().0;
+        (r, e, result)
+    }
+    #[test]
+    fn malformed_result_typing_aliases_are_incomplete_without_scope_creation() {
+        let (mut r, e, result) = model();
+        let scopes = r.b.scopes.len();
+        r.b.identity_origin_unit = Some(1);
+        let good = r.b.literal_inherited_memberships(e, true);
+        assert!(!good.incomplete);
+        assert_eq!(r.b.identity_origin_unit, Some(1));
+        let relation = r.b.elements[result]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "FeatureTyping")
+            .unwrap();
+        let conflict = r.b.elements[e].id;
+        r.b.elements[relation]
+            .props
+            .insert("general", json!({"@id":conflict.to_string()}));
+        let bad = r.b.literal_inherited_memberships(e, true);
+        assert!(bad.incomplete);
+        assert_eq!(r.b.scopes.len(), scopes);
+        assert!(!r.b.elem_scope.contains_key(&e));
+    }
+    #[test]
+    fn nonreciprocal_return_membership_is_not_a_result() {
+        let (mut r, e, result) = model();
+        let membership = r.b.elements[result].owning_relationship.unwrap();
+        r.b.elements[result].owning_relationship = None;
+        let inherited = r.b.literal_inherited_memberships(e, true);
+        assert!(inherited.incomplete);
+        assert!(
+            r.b.literal_inherited_result(&inherited, &mut MembershipContext::default())
+                .is_none()
+        );
+        assert!(r.b.elements[membership].children.contains(&result));
+    }
+    #[test]
+    fn conflicting_required_library_names_do_not_emit_an_arbitrary_edge() {
+        let (mut r, e, _) = model();
+        let other = r.resolve_qualified("Values::Integer").unwrap();
+        let other_id = r.element_id(other);
+        r.b.lib_qnames.push((
+            other_id,
+            vec![
+                "Performances".to_owned(),
+                "literalIntegerEvaluations".to_owned(),
+            ],
+        ));
+        r.b.reset_lookup_caches();
+        let projection = r.b.literal_inherited_memberships(e, true);
+        assert!(projection.incomplete);
+        assert!(projection.membership_order.is_empty());
+        assert!(
+            r.implied_relationships(crate::json::ElementRef(e))
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn conflicting_return_owner_or_typing_carrier_is_incomplete() {
+        for return_owner in [false, true] {
+            let (mut r, e, result) = model();
+            let relationship = if return_owner {
+                r.b.elements[result].owning_relationship.unwrap()
+            } else {
+                r.b.elements[result]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| r.b.elements[rel].ty == "FeatureTyping")
+                    .unwrap()
+            };
+            let wrong = r.b.elements[e].id;
+            r.b.elements[relationship]
+                .props
+                .insert("owningRelatedElement", json!({"@id":wrong.to_string()}));
+            let projection = r.b.literal_inherited_memberships(e, true);
+            assert!(projection.incomplete);
+        }
+    }
+    #[test]
+    fn contradictory_generic_arrays_refuse_literal_result_readiness() {
+        for membership in [false, true] {
+            for key in ["source", "target", "relatedElement", "ownedRelatedElement"] {
+                for invalid_kind in [false, true] {
+                    let (mut r, e, result) = model();
+                    let relationship = if membership {
+                        r.b.elements[result].owning_relationship.unwrap()
+                    } else {
+                        r.b.elements[result]
+                            .owned_relationships
+                            .iter()
+                            .copied()
+                            .find(|&rel| r.b.elements[rel].ty == "FeatureTyping")
+                            .unwrap()
+                    };
+                    r.b.identity_origin_unit = Some(1);
+                    let before = r.b.literal_inherited_memberships(e, true);
+                    assert!(!before.incomplete);
+                    let wrong = r.b.elements[e].id;
+                    let value = if invalid_kind {
+                        json!({"@id":wrong.to_string()})
+                    } else {
+                        json!([{"@id":wrong.to_string()}])
+                    };
+                    r.b.elements[relationship].props.insert(key, value);
+                    let after = r.b.literal_inherited_memberships(e, true);
+                    assert_eq!(r.b.identity_origin_unit, Some(1));
+                    assert!(
+                        after.incomplete,
+                        "membership={membership} key={key} invalid_kind={invalid_kind}"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn consistent_generic_arrays_preserve_returns_and_charge_shared_budget() {
+        let (mut r, e, result) = model();
+        let membership = r.b.elements[result].owning_relationship.unwrap();
+        let owner = r.b.elements[membership]
+            .props
+            .get("owningRelatedElement")
+            .unwrap()
+            .as_reference()
+            .unwrap();
+        let member = r.b.elements[result].id;
+        for (key, value) in [
+            ("source", json!([{"@id":owner.to_string()}])),
+            ("target", json!([{"@id":member.to_string()}])),
+            (
+                "relatedElement",
+                json!([{"@id":owner.to_string()},{"@id":member.to_string()}]),
+            ),
+            ("ownedRelatedElement", json!([{"@id":member.to_string()}])),
+        ] {
+            r.b.elements[membership].props.insert(key, value);
+        }
+        assert!(!r.b.literal_inherited_memberships(e, true).incomplete);
+        let mut context = MembershipContext::default();
+        context.steps = crate::eval::MAX_STEPS - 1;
+        assert!(!consistent_relation_arrays(
+            &r.b,
+            membership,
+            owner,
+            member,
+            &mut context
+        ));
+        assert!(context.steps > crate::eval::MAX_STEPS);
+        assert!(consistent_relation_arrays(
+            &r.b,
+            membership,
+            owner,
+            member,
+            &mut MembershipContext::default()
+        ));
+        r.b.elements[membership].props.insert(
+            "relatedElement",
+            json!([{"@id":member.to_string()},{"@id":owner.to_string()}]),
+        );
+        assert!(r.b.literal_inherited_memberships(e, true).incomplete);
+    }
+
+    #[test]
+    fn related_elements_preserve_reflexive_endpoint_occurrences() {
+        let (mut r, _, result) = model();
+        let relationship = r.b.elements[result]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "FeatureTyping")
+            .unwrap();
+        let id = r.b.elements[result].id;
+        for key in ["source", "target"] {
+            r.b.elements[relationship]
+                .props
+                .insert(key, json!([{"@id":id.to_string()}]));
+        }
+        r.b.elements[relationship].props.insert(
+            "relatedElement",
+            json!([{"@id":id.to_string()},{"@id":id.to_string()}]),
+        );
+        assert!(consistent_relation_arrays(
+            &r.b,
+            relationship,
+            id,
+            id,
+            &mut MembershipContext::default()
+        ));
+        r.b.elements[relationship]
+            .props
+            .insert("relatedElement", json!([{"@id":id.to_string()}]));
+        assert!(!consistent_relation_arrays(
+            &r.b,
+            relationship,
+            id,
+            id,
+            &mut MembershipContext::default()
+        ));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/local_featuring.rs b/crates/sysmlv2-model/src/json/local_featuring.rs
new file mode 100644
index 0000000..1f3a48c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/local_featuring.rs
@@ -0,0 +1,597 @@
+//! Optional local featuring rows over already staged, certified result groups.
+//! Failure never mutates or rejects those groups or the dynamic Invocation tail.
+use super::{Builder, Elem, dynamic_invocations::Refusal, semantic_ownership::SemanticOwnership};
+use crate::properties::Properties;
+use std::collections::HashSet;
+use uuid::Uuid;
+
+#[derive(Clone, Copy)]
+pub(super) struct Role {
+    pub source: usize,
+    pub target: usize,
+    pub anchor: usize,
+}
+pub(super) struct Plan {
+    from: usize,
+    before: usize,
+    rows: Vec<Elem>,
+    replacements: Vec<(usize, Vec<usize>)>,
+    roles: Vec<Role>,
+    sources: HashSet<usize>,
+}
+fn charge(steps: &mut usize, n: usize) -> Result<(), Refusal> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(Refusal::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+fn staged<'a>(b: &'a Builder, rows: &'a [Elem], index: usize) -> Option<&'a Elem> {
+    if index < b.elements.len() {
+        b.elements.get(index)
+    } else {
+        rows.get(index - b.elements.len())
+    }
+}
+fn ref_is(row: &Elem, key: &str, id: Uuid) -> bool {
+    row.props.get(key).and_then(|v| v.as_reference()) == Some(id)
+}
+/// The recipe factory supplies roles; this gate validates their complete local
+/// membership path and the nonvariable defaults that justify owned featuring.
+pub(super) fn valid(b: &Builder, rows: &[Elem], role: Role) -> bool {
+    b.elements
+        .get(role.anchor)
+        .is_some_and(|anchor| anchor.ty == "FeatureReferenceExpression")
+        && valid_path(b, rows, role, role.anchor, true)
+}
+
+/// The result factory's BindingConnector is owned by the referenced expression
+/// or by the constructor's checked result. Ends remain featured by that exact
+/// connector, independently of its own featuring or specialization obligations.
+fn valid_path(
+    b: &Builder,
+    rows: &[Elem],
+    role: Role,
+    binding_owner: usize,
+    allow_result: bool,
+) -> bool {
+    let Some(source) = staged(b, rows, role.source) else {
+        return false;
+    };
+    let Some(target) = staged(b, rows, role.target) else {
+        return false;
+    };
+    if role.source < b.elements.len()
+        || role.target >= role.source
+        || role.anchor >= b.explicit_len()
+        || source.ty != "Feature"
+        || source.props.get("isVariable").is_some()
+            && source.props.get("isVariable").and_then(|v| v.as_bool()) != Some(false)
+    {
+        return false;
+    }
+    let Some(member_index) = source
+        .owning_relationship
+        .filter(|&i| i >= b.elements.len() && i < role.source)
+    else {
+        return false;
+    };
+    let Some(member) = staged(b, rows, member_index) else {
+        return false;
+    };
+    if member.children.len() != 1
+        || member.children[0] != role.source
+        || member.owning_relationship.is_some()
+        || !ref_is(member, "owningRelatedElement", target.id)
+    {
+        return false;
+    }
+    if role.target == role.anchor {
+        allow_result
+            && member.ty == "ReturnParameterMembership"
+            && source.props.get("direction").and_then(|v| v.as_str()) == Some("out")
+    } else {
+        if target.ty != "BindingConnector"
+            || member.ty != "EndFeatureMembership"
+            || source.props.get("isEnd").and_then(|v| v.as_bool()) != Some(true)
+            || !target
+                .owned_relationships
+                .iter()
+                .any(|&r| Some(r) == source.owning_relationship)
+        {
+            return false;
+        }
+        let Some(binding_member) = target.owning_relationship.and_then(|i| staged(b, rows, i))
+        else {
+            return false;
+        };
+        binding_member.ty == "OwningMembership"
+            && binding_member.owning_relationship.is_none()
+            && binding_member.children.len() == 1
+            && binding_member.children[0] == role.target
+            && ref_is(
+                binding_member,
+                "owningRelatedElement",
+                b.elements[binding_owner].id,
+            )
+    }
+}
+pub(super) fn prepare(
+    b: &Builder,
+    rows: &[Elem],
+    roles: &[Role],
+    steps: &mut usize,
+) -> Result<Plan, Refusal> {
+    charge(
+        steps,
+        1_usize
+            .saturating_add(rows.len().saturating_mul(2))
+            .saturating_add(roles.len().saturating_mul(20)),
+    )?;
+    // Reuse the exact immutable UUID projection already admitted by result
+    // planning. No extra whole-source map or scan is needed for this family.
+    let raw = b
+        .stored_structure
+        .as_ref()
+        .filter(|raw| raw.is_current(b))
+        .ok_or(Refusal::Stale)?;
+    if !raw.ids_unique {
+        return Err(Refusal::Collision);
+    }
+    let mut ids = HashSet::new();
+    for row in rows {
+        if raw.element_for_uuid(b, row.id).is_some() || !ids.insert(row.id) {
+            return Err(Refusal::Collision);
+        }
+    }
+    let mut plan = Plan {
+        from: b.elements.len(),
+        before: rows.len(),
+        rows: Vec::new(),
+        replacements: Vec::new(),
+        roles: Vec::new(),
+        sources: HashSet::new(),
+    };
+    for &role in roles {
+        let source = staged(b, rows, role.source).ok_or(Refusal::Stale)?;
+        let target = staged(b, rows, role.target).ok_or(Refusal::Stale)?;
+        // Charge traversal before allocating or validating membership lists.
+        let member = source.owning_relationship.and_then(|i| staged(b, rows, i));
+        let binding_member = target.owning_relationship.and_then(|i| staged(b, rows, i));
+        charge(
+            steps,
+            source
+                .owned_relationships
+                .len()
+                .saturating_add(target.owned_relationships.len())
+                .saturating_add(member.map_or(0, |m| m.children.len()))
+                .saturating_add(binding_member.map_or(0, |m| m.children.len())),
+        )?;
+        let valid_role = if b
+            .elements
+            .get(role.anchor)
+            .is_some_and(|anchor| anchor.ty == "ConstructorExpression")
+        {
+            let result = super::constructor_bindings::owned_result(b, raw, role.anchor, steps)
+                .ok_or({
+                    if *steps > crate::eval::MAX_STEPS {
+                        Refusal::WorkLimit
+                    } else {
+                        Refusal::Stale
+                    }
+                })?;
+            valid_path(b, rows, role, result, false)
+        } else {
+            valid(b, rows, role)
+        };
+        if !valid_role || !plan.sources.insert(role.source) {
+            return Err(Refusal::Stale);
+        }
+        let id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{}/implied/TypeFeaturing/{}", source.id, target.id).as_bytes(),
+        );
+        if raw.element_for_uuid(b, id).is_some() || !ids.insert(id) {
+            return Err(Refusal::Collision);
+        }
+        let index = b.elements.len() + rows.len() + plan.rows.len();
+        let mut relationships: Vec<_> = source.owned_relationships.iter().copied().collect();
+        relationships.push(index);
+        plan.replacements
+            .push((role.source - b.elements.len(), relationships));
+        plan.roles.push(role);
+        let mut props = Properties::new();
+        props.insert("isImplied", serde_json::json!(true));
+        props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":source.id.to_string()}),
+        );
+        props.insert(
+            "featureOfType",
+            serde_json::json!({"@id":source.id.to_string()}),
+        );
+        props.insert(
+            "featuringType",
+            serde_json::json!({"@id":target.id.to_string()}),
+        );
+        plan.rows.push(Elem {
+            ty: "TypeFeaturing",
+            id,
+            path: String::new(),
+            path_parent: None,
+            props,
+            owned_relationships: Default::default(),
+            children: Default::default(),
+            owning_relationship: None,
+        });
+    }
+    Ok(plan)
+}
+impl Plan {
+    /// No fallible semantic work remains. These vectors are still private to
+    /// the one publisher; old physical rows are not modified or relocated.
+    pub(super) fn append(
+        self,
+        rows: &mut Vec<Elem>,
+        ownership: &mut SemanticOwnership,
+    ) -> HashSet<usize> {
+        assert_eq!(rows.len(), self.before);
+        for (owner, relationships) in self.replacements {
+            rows[owner].owned_relationships = relationships.into();
+        }
+        for (row, role) in self.rows.into_iter().zip(self.roles) {
+            ownership
+                .register(
+                    self.from + rows.len(),
+                    Some(role.source),
+                    role.anchor,
+                    false,
+                )
+                .expect("prevalidated local featuring carrier");
+            rows.push(row);
+        }
+        self.sources
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ElementRef, ResolvedModel, dynamic_graph::Outcome, type_relations::TypeRelations},
+        model::Model,
+    };
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        m.add_source("local.kerml", source);
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+    fn staging(r: &mut ResolvedModel) -> (Vec<Elem>, Vec<Role>, SemanticOwnership) {
+        let plans = super::super::owned_results::plan_reference_results(&mut r.b, &mut 0).unwrap();
+        let mut rows = Vec::new();
+        let mut roles = Vec::new();
+        let mut view = SemanticOwnership::new(r.b.elements.len());
+        for plan in plans {
+            let start = r.b.elements.len() + rows.len();
+            let staged = super::super::owned_results::stage_owned_result(
+                &r.b, &mut view, plan, start, &mut rows,
+            );
+            roles.extend(staged.featuring);
+        }
+        (rows, roles, view)
+    }
+    #[test]
+    fn constructor_ends_preserve_reference_result_featuring_in_one_transaction() {
+        let mut model = Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+        model.add_library_source("local-bases.kerml", "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}");
+        model.add_source("mixed-local.kerml", "feature n; feature read=n; class C {feature a; feature b default=2;} feature made=new C(1);");
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let (mut rows, mut roles, mut view) = staging(&mut r);
+        assert_eq!(roles.len(), 3);
+        let reserved = rows.iter().map(|row| row.id).collect();
+        let defaults =
+            super::super::owned_results::plan_constructor_defaults(&mut r.b, &reserved, &mut 0)
+                .unwrap();
+        assert_eq!(defaults.len(), 1);
+        for plan in defaults {
+            let start = r.b.elements.len() + rows.len();
+            let (_, featuring) = super::super::owned_results::stage_constructor_default(
+                &r.b, &mut view, plan, start, &mut rows,
+            );
+            roles.extend(featuring);
+        }
+        assert_eq!(roles.len(), 5);
+        let constructor_role = roles[3];
+        let binding_member = rows[constructor_role.target - r.b.elements.len()]
+            .owning_relationship
+            .unwrap()
+            - r.b.elements.len();
+        let original = rows[binding_member].props.clone();
+        // A constructor binding is owned by its result, never the expression.
+        rows[binding_member].props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":r.b.elements[constructor_role.anchor].id.to_string()}),
+        );
+        assert!(matches!(
+            prepare(&r.b, &rows, &roles, &mut 0),
+            Err(Refusal::Stale)
+        ));
+        rows[binding_member].props = original;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(matches!(
+            prepare(&r.b, &rows, &roles, &mut exhausted),
+            Err(Refusal::WorkLimit)
+        ));
+        let initial = rows.len();
+        let plan = prepare(&r.b, &rows, &roles, &mut 0).unwrap();
+        let owners = plan.append(&mut rows, &mut view);
+        assert_eq!(owners.len(), 5);
+        assert_eq!(rows.len() - initial, 5);
+        for (row, role) in rows[initial..].iter().zip(&roles) {
+            assert_eq!(row.ty, "TypeFeaturing");
+            assert!(ref_is(
+                row,
+                "featureOfType",
+                rows[role.source - r.b.elements.len()].id
+            ));
+            assert!(ref_is(
+                row,
+                "featuringType",
+                staged(&r.b, &rows, role.target).unwrap().id
+            ));
+        }
+        let call = ElementRef(constructor_role.anchor);
+        r.implied_relationships(call);
+        let snapshot = r.b.dynamic_graph.as_ref().unwrap();
+        assert_eq!(snapshot.local_featuring_outcome, Outcome::Accepted);
+        assert_eq!(snapshot.local_featuring.as_ref().unwrap().len(), 5);
+    }
+
+    #[test]
+    fn local_rows_append_after_every_old_group_and_dynamic_row() {
+        let mut r = fixture(
+            "function F {in p;return result;} feature n;feature x=n;feature y=n;feature call=F(1);",
+        );
+        let calls: Vec<_> = r
+            .user_elements()
+            .filter(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .collect();
+        assert_eq!(calls.len(), 2);
+        let (old, _, _) = staging(&mut r);
+        let call = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "InvocationExpression")
+            .unwrap();
+        r.implied_relationships(call);
+        let boundary = r.b.implied.as_ref().unwrap().owned_results_from;
+        let dynamic = r.b.dynamic_graph.as_ref().unwrap();
+        assert_eq!(dynamic.outcome, Outcome::Accepted);
+        assert_eq!(dynamic.local_featuring_outcome, Outcome::Accepted);
+        let dynamic_len = dynamic.plan.as_ref().unwrap().tail.len();
+        let auxiliary = boundary + old.len() + dynamic_len;
+        assert_eq!(r.b.elements.len(), auxiliary + 6);
+        for (offset, prior) in old.iter().enumerate() {
+            let row = &r.b.elements[boundary + offset];
+            assert_eq!(row.id, prior.id);
+            assert_eq!(row.ty, prior.ty);
+            assert_eq!(row.props.to_json(), prior.props.to_json());
+            assert_eq!(row.owning_relationship, prior.owning_relationship);
+            assert!(
+                row.owned_relationships
+                    .iter()
+                    .copied()
+                    .collect::<Vec<_>>()
+                    .starts_with(
+                        &prior
+                            .owned_relationships
+                            .iter()
+                            .copied()
+                            .collect::<Vec<_>>()
+                    )
+            );
+        }
+        for row in r.b.elements.iter().skip(auxiliary) {
+            assert_eq!(row.ty, "TypeFeaturing");
+        }
+        for expr in calls {
+            let result =
+                r.b.semantic_ownership
+                    .as_ref()
+                    .unwrap()
+                    .result(expr.0)
+                    .unwrap()
+                    .feature;
+            assert_eq!(
+                TypeRelations::default().featuring_types(&mut r.b, result, &mut 0),
+                Some(vec![expr.0])
+            );
+            assert!(
+                !super::super::semantic_ownership::owned_feature_projection_complete(&r.b, expr.0)
+            );
+        }
+        let ids: Vec<_> = r.b.elements.iter().map(|e| e.id).collect();
+        r.implied_relationships(call);
+        assert_eq!(ids, r.b.elements.iter().map(|e| e.id).collect::<Vec<_>>());
+    }
+    #[test]
+    fn local_admission_survives_dynamic_refusal_and_no_library() {
+        let mut r = fixture("feature n;feature x=n;feature bad=Missing();");
+        let expr = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(expr);
+        let snapshot = r.b.dynamic_graph.as_ref().unwrap();
+        assert!(matches!(snapshot.outcome, Outcome::Declined(_)));
+        assert_eq!(snapshot.local_featuring_outcome, Outcome::Accepted);
+        assert_eq!(snapshot.local_featuring.as_ref().unwrap().len(), 3);
+        assert_eq!(
+            r.b.elements.len() - r.b.implied.as_ref().unwrap().owned_results_from,
+            14
+        );
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expr.0)
+                .unwrap()
+                .feature;
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, result, &mut 0),
+            Some(vec![expr.0])
+        );
+    }
+    #[test]
+    fn refusal_has_no_private_or_physical_effect_and_can_retry() {
+        let mut r = fixture("feature n;feature x=n;");
+        let (mut rows, roles, mut view) = staging(&mut r);
+        let ids: Vec<_> = rows.iter().map(|e| e.id).collect();
+        let before = r.b.elements.len();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(matches!(
+            prepare(&r.b, &rows, &roles, &mut exhausted),
+            Err(Refusal::WorkLimit)
+        ));
+        assert_eq!(ids, rows.iter().map(|e| e.id).collect::<Vec<_>>());
+        assert_eq!(before, r.b.elements.len());
+        let first = roles[0].source - before;
+        let original = rows[first].props.clone();
+        rows[first]
+            .props
+            .insert("isVariable", serde_json::json!(true));
+        assert!(matches!(
+            prepare(&r.b, &rows, &roles, &mut 0),
+            Err(Refusal::Stale)
+        ));
+        rows[first].props = original;
+        let accepted = prepare(&r.b, &rows, &roles, &mut 0)
+            .unwrap()
+            .append(&mut rows, &mut view);
+        assert_eq!(accepted.len(), 3);
+        assert_eq!(rows.len(), 14);
+        assert_eq!(ids, rows[..11].iter().map(|e| e.id).collect::<Vec<_>>());
+    }
+    #[test]
+    fn auxiliary_collision_keeps_result_binding_and_dynamic_family() {
+        let mut r = fixture(
+            "function F {return result;} feature spare;feature n;feature x=n;feature call=F();",
+        );
+        let expr = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        let spare = r.resolve_qualified("spare").unwrap();
+        let result = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{}/implied/ownedResult", r.element_id(expr)).as_bytes(),
+        );
+        let collision = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{result}/implied/TypeFeaturing/{}", r.element_id(expr)).as_bytes(),
+        );
+        r.override_ids(&std::collections::HashMap::from([(
+            r.element_id(spare),
+            collision,
+        )]));
+        r.implied_relationships(expr);
+        let snapshot = r.b.dynamic_graph.as_ref().unwrap();
+        assert_eq!(snapshot.outcome, Outcome::Accepted);
+        assert!(matches!(
+            snapshot.local_featuring_outcome,
+            Outcome::Declined(Refusal::Collision)
+        ));
+        assert!(snapshot.local_featuring.is_none());
+        assert!(
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expr.0)
+                .is_some()
+        );
+        assert_eq!(
+            r.b.elements
+                .iter()
+                .filter(|e| e.ty == "BindingConnector")
+                .count(),
+            1
+        );
+    }
+    #[test]
+    fn id_override_preserves_auxiliary_handles_and_metadata_is_not_local_dependency() {
+        let mut r = fixture("feature n;feature x=n;");
+        let expr = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(expr);
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expr.0)
+                .unwrap()
+                .feature;
+        let rel = r.b.elements[result]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| r.b.elements[i].ty == "TypeFeaturing")
+            .unwrap();
+        let id = r.element_id(ElementRef(rel));
+        let next = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"explicit local featuring");
+        let count = r.b.elements.len();
+        r.override_ids(&std::collections::HashMap::from([(id, next)]));
+        assert_eq!(r.b.elements.len(), count);
+        assert_eq!(r.element_id(ElementRef(rel)), next);
+        assert!(r.b.dynamic_graph.as_ref().unwrap().local_current(&r.b));
+        let mut held = TypeRelations::default();
+        assert_eq!(
+            held.featuring_types(&mut r.b, result, &mut 0),
+            Some(vec![expr.0])
+        );
+        r.b.metadata_association_generation = Some(std::sync::Arc::new(()));
+        assert!(held.featuring_types(&mut r.b, result, &mut 0).is_none());
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, result, &mut 0),
+            Some(vec![expr.0])
+        );
+        r.b.elements[result]
+            .props
+            .insert("isVariable", serde_json::json!(true));
+        assert!(
+            TypeRelations::default()
+                .featuring_types(&mut r.b, result, &mut 0)
+                .is_none()
+        );
+        let old = r.element_id(expr);
+        r.override_ids(&std::collections::HashMap::from([(
+            old,
+            Uuid::new_v5(&Uuid::NAMESPACE_OID, b"stale local owner"),
+        )]));
+        assert!(
+            TypeRelations::default()
+                .featuring_types(&mut r.b, result, &mut 0)
+                .is_none()
+        );
+        assert_eq!(r.element_id(ElementRef(rel)), next);
+    }
+    #[test]
+    fn auxiliary_work_reuses_uuid_snapshot_without_unrelated_source_scan() {
+        let mut work = Vec::new();
+        for unrelated in [0, 1000] {
+            let mut source = "feature n;feature x=n;".to_string();
+            for i in 0..unrelated {
+                source.push_str(&format!("feature unused{i};"));
+            }
+            let mut r = fixture(&source);
+            let (rows, roles, _) = staging(&mut r);
+            let mut steps = 0;
+            prepare(&r.b, &rows, &roles, &mut steps).unwrap();
+            work.push(steps);
+        }
+        assert_eq!(work[0], work[1]);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/membership_context.rs b/crates/sysmlv2-model/src/json/membership_context.rs
new file mode 100644
index 0000000..aa4bf01
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/membership_context.rs
@@ -0,0 +1,558 @@
+//! Contextual inheritance for import-operation Membership projections.
+use super::{Builder, InheritedBindings, LookupAccess};
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+/// Ordered semantic identities; no textual scope is fabricated for leaf Types.
+#[derive(Default)]
+pub(super) struct MembershipProjection {
+    pub(super) membership_order: Vec<usize>,
+    pub(super) truncated: bool,
+    pub(super) incomplete: bool,
+    pub(super) implicit_redefinitions: Vec<(usize, usize)>,
+}
+
+const MAX_CONTEXT_DEPTH: usize = 128;
+
+#[derive(Clone, Default)]
+struct Guards {
+    namespaces: HashMap<usize, bool>,
+    types: HashMap<usize, bool>,
+}
+impl Guards {
+    fn matches(&self, namespaces: &[usize], types: &[usize]) -> bool {
+        self.namespaces
+            .iter()
+            .all(|(e, excluded)| namespaces.contains(e) == *excluded)
+            && self
+                .types
+                .iter()
+                .all(|(e, excluded)| types.contains(e) == *excluded)
+    }
+}
+struct Tracking {
+    namespaces: HashSet<usize>,
+    types: HashSet<usize>,
+    family: usize,
+    guards: Guards,
+}
+#[derive(Clone)]
+struct Complete {
+    guards: Arc<Guards>,
+    value: Arc<MembershipProjection>,
+}
+pub(super) struct ImportProjection {
+    pub(super) blocked: Vec<usize>,
+    guards: Arc<Guards>,
+}
+/// Query-local: graph mutation cannot invalidate a proof between public calls.
+#[derive(Default)]
+pub(super) struct MembershipContext {
+    known: HashMap<(usize, bool), Vec<Complete>>,
+    tracking: Vec<Tracking>,
+    family: usize,
+    pub(super) steps: usize,
+}
+impl MembershipContext {
+    pub(super) fn begin_namespace(&mut self, excluded: &[usize]) {
+        self.tracking.push(Tracking {
+            namespaces: excluded.iter().copied().collect(),
+            types: HashSet::new(),
+            family: 0,
+            guards: Guards::default(),
+        });
+    }
+    pub(super) fn finish_namespace(&mut self, blocked: Vec<usize>) -> ImportProjection {
+        let tracking = self.tracking.pop().expect("balanced namespace projection");
+        debug_assert_eq!(tracking.family, 0);
+        ImportProjection {
+            blocked,
+            guards: Arc::new(tracking.guards),
+        }
+    }
+    pub(super) fn reuse_namespace(&mut self, value: &ImportProjection, excluded: &[usize]) -> bool {
+        self.charge(
+            value
+                .guards
+                .namespaces
+                .len()
+                .saturating_mul(excluded.len().saturating_add(1)),
+        ) && value.guards.matches(excluded, &[])
+            && self.replay(0, &value.guards)
+    }
+    pub(super) fn charge(&mut self, count: usize) -> bool {
+        self.steps = self.steps.saturating_add(count);
+        self.steps <= crate::eval::MAX_STEPS
+    }
+    pub(super) fn new_type_family(&mut self) -> usize {
+        self.family += 1;
+        self.family
+    }
+    /// Namespace exclusions continue through imports and inheritance. An
+    /// exclusion introduced inside a tracked operation is constant for that
+    /// operation, not a dependency on its caller's original exclusion set.
+    pub(super) fn namespace_test(&mut self, namespace: usize, excluded: bool) -> bool {
+        if !self.charge(self.tracking.len()) {
+            return false;
+        }
+        for tracking in &mut self.tracking {
+            if !excluded || tracking.namespaces.contains(&namespace) {
+                tracking.guards.namespaces.insert(namespace, excluded);
+            }
+        }
+        true
+    }
+    fn type_test(&mut self, family: usize, ty: usize, excluded: bool) -> bool {
+        if !self.charge(self.tracking.len()) {
+            return false;
+        }
+        for tracking in &mut self.tracking {
+            // visibleMemberships starts inheritedMemberships with fresh Type
+            // exclusions. Its proof must not constrain an outer heritage walk.
+            if tracking.family == family && (!excluded || tracking.types.contains(&ty)) {
+                tracking.guards.types.insert(ty, excluded);
+            }
+        }
+        true
+    }
+    fn replay(&mut self, family: usize, guards: &Guards) -> bool {
+        if !self.charge(guards.namespaces.len() + guards.types.len()) {
+            return false;
+        }
+        for (&e, &excluded) in &guards.namespaces {
+            if !self.namespace_test(e, excluded) {
+                return false;
+            }
+        }
+        for (&e, &excluded) in &guards.types {
+            if !self.type_test(family, e, excluded) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+fn incomplete() -> Arc<MembershipProjection> {
+    Arc::new(MembershipProjection {
+        truncated: true,
+        incomplete: true,
+        ..Default::default()
+    })
+}
+
+impl Builder {
+    /// Actual candidate gathering precedes redefinition removal. Reusing an
+    /// already reduced global list cannot recover a candidate whose blocker is
+    /// excluded in this import operation's namespace context.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn contextual_inherited_bindings(
+        &mut self,
+        element: usize,
+        include_implied: bool,
+        excluded_namespaces: &[usize],
+        excluded_types: &[usize],
+        family: usize,
+        context: &mut MembershipContext,
+        depth: usize,
+    ) -> Arc<MembershipProjection> {
+        if depth > MAX_CONTEXT_DEPTH
+            || context.tracking.len() >= MAX_CONTEXT_DEPTH
+            || !context.charge(1)
+        {
+            return incomplete();
+        }
+        let variants = context
+            .known
+            .get(&(element, include_implied))
+            .cloned()
+            .unwrap_or_default();
+        let mut hit = None;
+        for candidate in variants {
+            if !context.charge(
+                candidate
+                    .guards
+                    .namespaces
+                    .len()
+                    .saturating_mul(excluded_namespaces.len().saturating_add(1))
+                    + candidate
+                        .guards
+                        .types
+                        .len()
+                        .saturating_mul(excluded_types.len().saturating_add(1)),
+            ) {
+                return incomplete();
+            }
+            if candidate
+                .guards
+                .matches(excluded_namespaces, excluded_types)
+            {
+                hit = Some(candidate);
+                break;
+            }
+        }
+        if let Some(hit) = hit {
+            if !context.replay(family, &hit.guards)
+                || !context.charge(hit.value.membership_order.len())
+            {
+                return incomplete();
+            }
+            return hit.value;
+        }
+        context.tracking.push(Tracking {
+            namespaces: excluded_namespaces.iter().copied().collect(),
+            types: excluded_types.iter().copied().collect(),
+            family,
+            guards: Guards::default(),
+        });
+        let value = self.contextual_inherited_uncached(
+            element,
+            include_implied,
+            excluded_namespaces,
+            excluded_types,
+            family,
+            context,
+            depth,
+        );
+        let tracking = context
+            .tracking
+            .pop()
+            .expect("balanced contextual inheritance");
+        let value = Arc::new(value);
+        if !value.incomplete && !value.truncated && context.steps <= crate::eval::MAX_STEPS {
+            // A bounded variant count limits retained memory in highly cyclic
+            // models. Uncached variants still compute with the shared budget.
+            let variants = context.known.entry((element, include_implied)).or_default();
+            if variants.len() < 8 {
+                variants.push(Complete {
+                    guards: Arc::new(tracking.guards),
+                    value: Arc::clone(&value),
+                });
+            }
+        }
+        value
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn contextual_inherited_uncached(
+        &mut self,
+        element: usize,
+        include_implied: bool,
+        excluded_namespaces: &[usize],
+        excluded_types: &[usize],
+        family: usize,
+        context: &mut MembershipContext,
+        depth: usize,
+    ) -> MembershipProjection {
+        let mut types = excluded_types.to_vec();
+        if !types.contains(&element) {
+            types.push(element);
+        }
+        let mut result = MembershipProjection::default();
+        let scope = self.elem_scope.get(&element).copied();
+        // Preserve known positive bases but distinguish an unresolved authored
+        // endpoint from a proven complete absence of other supertypes.
+        let relationships = self.elements[element].owned_relationships.clone();
+        if !context.charge(relationships.len()) {
+            result.truncated = true;
+            result.incomplete = true;
+            return result;
+        }
+        for relationship in relationships {
+            let relation = &self.elements[relationship];
+            if crate::metaclass::conforms(relation.ty, "Specialization")
+                && (include_implied
+                    || relation
+                        .props
+                        .get("isImplied")
+                        .and_then(|value| value.as_bool())
+                        != Some(true))
+            {
+                let id = super::implied::specialization_target(relation);
+                let target = id.and_then(|id| self.element_index_of_uuid(id));
+                if target.is_none_or(|target| {
+                    !crate::metaclass::conforms(self.elements[target].ty, "Type")
+                }) {
+                    result.incomplete = true;
+                }
+            }
+        }
+        if self.metadata_associations_incomplete
+            || scope.is_some_and(|scope| !self.scopes[scope].chain_bases.is_empty())
+            || self
+                .metadata_of
+                .get(&element)
+                .is_some_and(|values| !values.is_empty())
+        {
+            result.incomplete = true;
+        }
+        let bases = if let Some(scope) = scope {
+            let (mut bases, explicit) = self.base_scopes_split(scope);
+            if !include_implied {
+                bases.truncate(explicit);
+            }
+            let mut identities = Vec::new();
+            for base in bases {
+                if let Some(owner) = self.scopes[base].owner {
+                    identities.push(owner);
+                } else {
+                    result.incomplete = true;
+                }
+            }
+            identities
+        } else {
+            match self.semantic_inheritance_bases(element, include_implied, &mut context.steps) {
+                Some(bases) => bases,
+                None => {
+                    result.incomplete = true;
+                    result.truncated = context.steps > crate::eval::MAX_STEPS;
+                    return result;
+                }
+            }
+        };
+        if !context.charge(bases.len()) {
+            result.truncated = true;
+            result.incomplete = true;
+            return result;
+        }
+        for base in bases {
+            let excluded = types.contains(&base);
+            if !context.type_test(family, base, excluded) {
+                result.incomplete = true;
+                result.truncated = true;
+                break;
+            }
+            if excluded {
+                continue;
+            }
+            // nonPrivateMemberships: public own/imported, protected
+            // own/imported, then already reduced inherited memberships.
+            for access in [LookupAccess::Public, LookupAccess::Protected] {
+                let own = self.contextual_own_memberships(base, access, context);
+                Self::append_contextual_bindings(&mut result, &own);
+                if context.steps > crate::eval::MAX_STEPS {
+                    break;
+                }
+                let Some(base_scope) = self.elem_scope.get(&base).copied() else {
+                    // Semantic Type identity exists independently of a textual
+                    // declaration scope. No synthetic scopes are allocated.
+                    continue;
+                };
+                let mut excluded = excluded_namespaces.to_vec();
+                if !excluded.contains(&base_scope) {
+                    excluded.push(base_scope);
+                }
+                let mut seen = HashMap::new();
+                let mut imported = InheritedBindings::default();
+                let mut order = Vec::new();
+                if self
+                    .collect_import_edges(
+                        base_scope,
+                        access,
+                        include_implied,
+                        &[],
+                        &mut excluded,
+                        &mut seen,
+                        &mut imported,
+                        &mut order,
+                        0,
+                        false,
+                        context,
+                    )
+                    .is_none()
+                {
+                    imported.incomplete = true;
+                }
+                let imported = MembershipProjection {
+                    membership_order: order,
+                    truncated: imported.truncated,
+                    incomplete: imported.incomplete,
+                    implicit_redefinitions: Vec::new(),
+                };
+                Self::append_contextual_bindings(&mut result, &imported);
+            }
+            if context.steps > crate::eval::MAX_STEPS {
+                result.truncated = true;
+                result.incomplete = true;
+                break;
+            }
+            let inherited = self.contextual_inherited_bindings(
+                base,
+                include_implied,
+                excluded_namespaces,
+                &types,
+                family,
+                context,
+                depth + 1,
+            );
+            Self::append_contextual_bindings(&mut result, &inherited);
+        }
+        self.reduce_membership_projection(
+            Some(element),
+            include_implied,
+            result,
+            Some(&mut context.steps),
+        )
+    }
+
+    fn append_contextual_bindings(out: &mut MembershipProjection, source: &MembershipProjection) {
+        out.membership_order
+            .extend(source.membership_order.iter().copied());
+        out.truncated |= source.truncated;
+        out.incomplete |= source.incomplete;
+    }
+
+    fn contextual_own_memberships(
+        &mut self,
+        element: usize,
+        access: LookupAccess,
+        context: &mut MembershipContext,
+    ) -> MembershipProjection {
+        let mut result = MembershipProjection::default();
+        let scope = self.elem_scope.get(&element).copied();
+        let mut count = self.elements[element].owned_relationships.len();
+        if let Some(scope) = scope {
+            count += self.scopes[scope]
+                .names
+                .values()
+                .map(|bindings| bindings.len())
+                .sum::<usize>()
+                + self.scopes[scope]
+                    .effective_names
+                    .values()
+                    .map(|bindings| bindings.len())
+                    .sum::<usize>();
+        }
+        if !context.charge(count) {
+            result.truncated = true;
+            result.incomplete = true;
+            return result;
+        }
+        let mut elements = self.owned_member_elems(element, false);
+        if let Some(scope) = scope {
+            for names in [
+                &self.scopes[scope].names,
+                &self.scopes[scope].effective_names,
+            ] {
+                elements.extend(
+                    names
+                        .values()
+                        .flatten()
+                        .filter(|binding| access.admits(binding.visibility))
+                        .map(|binding| binding.elem),
+                );
+            }
+        }
+        elements.sort_unstable();
+        elements.dedup();
+        for member in elements {
+            if let Some(membership) = self.elements[member].owning_relationship {
+                if self.import_admitted(membership, access) {
+                    result.membership_order.push(membership);
+                }
+            }
+        }
+        if let Some(scope) = scope {
+            self.scope_alias_rels(scope, access, &[], &mut result.membership_order);
+        }
+        result.membership_order.sort_unstable();
+        result.membership_order.dedup();
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn excluded_blocker_is_filtered_before_redefinition_reduction() {
+        let mut m = Model::new();
+        let u=m.add_source("context.sysml", "part def A {part x;} part def P :> A {part y redefines A::x; public import D::*;} part def C {public import P::*;} part def D :> A,C;");
+        assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+        let mut r = ResolvedModel::build(&m);
+        let d = r.resolve_qualified("D").unwrap().0;
+        let p = r.resolve_qualified("P").unwrap().0;
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let y = r.resolve_qualified("P::y").unwrap().0;
+        let p_scope = *r.b.elem_scope.get(&p).unwrap();
+        r.b.ensure_positional_redefinitions();
+        let mut context = MembershipContext::default();
+        for excluded in [vec![], vec![p_scope], vec![], vec![p_scope]] {
+            let family = context.new_type_family();
+            let result =
+                r.b.contextual_inherited_bindings(d, true, &excluded, &[], family, &mut context, 0);
+            let actual: Vec<_> = result
+                .membership_order
+                .iter()
+                .filter_map(|&m| r.b.stored_membership_member(m))
+                .collect();
+            assert_eq!(
+                actual,
+                if excluded.is_empty() {
+                    vec![y]
+                } else {
+                    vec![x]
+                }
+            );
+            assert!(!result.truncated);
+            assert!(context.tracking.is_empty());
+        }
+    }
+    #[test]
+    fn memo_guards_distinguish_external_from_internal_exclusions() {
+        let mut c = MembershipContext::default();
+        c.begin_namespace(&[1]);
+        c.namespace_test(1, true); // caller-dependent
+        c.namespace_test(2, true); // introduced by this traversal
+        c.namespace_test(3, false);
+        let result = c.finish_namespace(vec![1]);
+        assert!(c.reuse_namespace(&result, &[1]));
+        assert!(c.reuse_namespace(&result, &[1, 2, 9]));
+        assert!(!c.reuse_namespace(&result, &[]));
+        assert!(!c.reuse_namespace(&result, &[1, 3]));
+        assert!(c.tracking.is_empty());
+    }
+    #[test]
+    fn namespace_boundaries_reset_type_exclusion_dependencies() {
+        let mut c = MembershipContext::default();
+        let outer = c.new_type_family();
+        let inner = c.new_type_family();
+        c.tracking.push(Tracking {
+            namespaces: HashSet::new(),
+            types: HashSet::from([1]),
+            family: outer,
+            guards: Guards::default(),
+        });
+        c.type_test(inner, 1, false);
+        assert!(c.tracking[0].guards.types.is_empty());
+        c.type_test(outer, 1, true);
+        assert_eq!(c.tracking[0].guards.types.get(&1), Some(&true));
+    }
+    #[test]
+    fn exhausted_context_does_not_cache_a_false_empty_result() {
+        let mut m = Model::new();
+        m.add_source(
+            "budget.kerml",
+            "classifier A {feature x;} classifier D specializes A;",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let d = r.resolve_qualified("D").unwrap().0;
+        r.b.ensure_positional_redefinitions();
+        let mut c = MembershipContext {
+            steps: crate::eval::MAX_STEPS - 1,
+            ..Default::default()
+        };
+        let family = c.new_type_family();
+        let result =
+            r.b.contextual_inherited_bindings(d, true, &[], &[], family, &mut c, 0);
+        assert!(result.truncated);
+        assert!(c.tracking.is_empty());
+        assert!(!c.known.contains_key(&(d, true)));
+        c.steps = 0;
+        let result =
+            r.b.contextual_inherited_bindings(d, true, &[], &[], family, &mut c, 0);
+        assert!(!result.truncated);
+        assert_eq!(result.membership_order.len(), 1);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/membership_evidence.rs b/crates/sysmlv2-model/src/json/membership_evidence.rs
new file mode 100644
index 0000000..baf8fb9
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/membership_evidence.rs
@@ -0,0 +1,525 @@
+//! Bounded identity evidence for reciprocal owned and unowned Membership selectors.
+//! This is shared by required-edge planners; it does not resolve names, invent
+//! owned members, materialize a semantic graph, or certify a complete family.
+use super::{Builder, structural_index::StoredStructure};
+use crate::metaclass::conforms;
+use std::collections::HashSet;
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+/// A reciprocal owned or unowned Membership endpoint from the shared semantic
+/// carrier view. This selector proves one membership identity, not completeness
+/// of the owner's members or applicability of any generated family.
+pub(super) fn member(
+    b: &Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    membership: usize,
+    steps: &mut usize,
+) -> Option<usize> {
+    charge(steps, 1)?;
+    if !raw.ids_unique || !raw.is_current(b) {
+        return None;
+    }
+    let owner_id = b.elements.get(owner)?.id;
+    let relation = b.elements.get(membership)?;
+    if !conforms(relation.ty, "Membership")
+        || super::semantic_ownership::checked_relationship_carrier(b, raw, membership, steps)?
+            != Some(owner)
+    {
+        return None;
+    }
+    for key in [
+        "owningRelatedElement",
+        "membershipOwningNamespace",
+        "owningType",
+        "featureWithValue",
+    ] {
+        if relation
+            .props
+            .get(key)
+            .is_some_and(|v| v.as_reference() != Some(owner_id))
+        {
+            return None;
+        }
+    }
+    let owned = conforms(relation.ty, "OwningMembership");
+    let member = if owned {
+        if relation.children.len() != 1 {
+            return None;
+        }
+        let member = relation.children[0];
+        if b.elements.get(member)?.owning_relationship != Some(membership) {
+            return None;
+        }
+        member
+    } else {
+        raw.element_for_uuid(b, relation.props.get("memberElement")?.as_reference()?)?
+    };
+    let element = b.elements.get(member)?;
+    for key in [
+        "memberElement",
+        "ownedMemberElement",
+        "ownedMemberFeature",
+        "memberFeature",
+        "ownedResultExpression",
+        "value",
+    ] {
+        if relation
+            .props
+            .get(key)
+            .is_some_and(|v| v.as_reference() != Some(element.id))
+        {
+            return None;
+        }
+    }
+    // Check the actual metaclass narrowings; unrelated optional properties are
+    // not assumed to be aliases of a membership that does not declare them.
+    if conforms(relation.ty, "ParameterMembership")
+        && relation
+            .props
+            .get("ownedMemberParameter")
+            .is_some_and(|v| v.as_reference() != Some(element.id))
+    {
+        return None;
+    }
+    let member_ids = [element.id];
+    for (key, expected) in [
+        ("source", &[owner_id][..]),
+        ("target", &[element.id][..]),
+        ("relatedElement", &[owner_id, element.id][..]),
+        (
+            "ownedRelatedElement",
+            if owned { &member_ids[..] } else { &[][..] },
+        ),
+    ] {
+        if let Some(value) = relation.props.get(key) {
+            let values = value.as_array()?;
+            charge(steps, values.len())?;
+            if values.len() != expected.len()
+                || values
+                    .iter()
+                    .zip(expected)
+                    .any(|(v, id)| v.as_reference() != Some(*id))
+            {
+                return None;
+            }
+        }
+    }
+    if owned {
+        for (key, applicable) in [
+            ("owningRelationship", true),
+            ("owningMembership", true),
+            (
+                "owningFeatureMembership",
+                conforms(relation.ty, "FeatureMembership"),
+            ),
+            (
+                "owningParameterMembership",
+                conforms(relation.ty, "ParameterMembership"),
+            ),
+        ] {
+            if applicable
+                && element
+                    .props
+                    .get(key)
+                    .is_some_and(|v| v.as_reference() != Some(relation.id))
+            {
+                return None;
+            }
+        }
+    } else if !relation.children.is_empty() {
+        return None;
+    }
+    Some(member)
+}
+
+/// Complete local FeatureValue selection, including inverse ownership claims.
+/// The outer None means malformed/incomplete evidence; Some(None) proves absence.
+/// Value flags are structurally checked but their semantic applicability belongs
+/// to the caller. This does not inherit values or select defaults.
+pub(super) fn valuation(
+    b: &Builder,
+    raw: &StoredStructure,
+    feature: usize,
+    steps: &mut usize,
+) -> Option<Option<(usize, usize)>> {
+    charge(steps, 1)?;
+    if !raw.ids_unique
+        || !raw.is_current(b)
+        || !conforms(b.elements.get(feature)?.ty, "Feature")
+        || !raw.membership_domains(b, steps)?.owner_complete(feature)
+    {
+        return None;
+    }
+    let relationships = super::semantic_ownership::owned_relationships(b, feature)?;
+    charge(steps, relationships.len())?;
+    let mut seen = HashSet::new();
+    let mut value = None;
+    for relationship in relationships.iter() {
+        if !seen.insert(relationship)
+            || super::semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)?
+                != Some(feature)
+        {
+            return None;
+        }
+        let relation = b.elements.get(relationship)?;
+        if !conforms(relation.ty, "FeatureValue") {
+            continue;
+        }
+        if value.is_some() {
+            return None;
+        }
+        for key in ["isInitial", "isDefault"] {
+            if relation
+                .props
+                .get(key)
+                .is_some_and(|v| v.as_bool().is_none())
+            {
+                return None;
+            }
+        }
+        let expression = member(b, raw, feature, relationship, steps)?;
+        if !conforms(b.elements.get(expression)?.ty, "Expression") {
+            return None;
+        }
+        value = Some((relationship, expression));
+    }
+    Some(value)
+}
+
+/// Exact non-conjugated parameter direction. A membership default needs its
+/// reciprocal member witness; malformed present values never become defaults.
+/// Ordinary FeatureMemberships permit explicit null (no direction); parameter
+/// memberships cannot use null to bypass their required direction.
+/// The caller establishes the owning-type context and excludes conjugation.
+pub(super) fn parameter_direction<'a>(
+    b: &'a Builder,
+    raw: &StoredStructure,
+    feature: usize,
+    steps: &mut usize,
+) -> Option<Option<&'a str>> {
+    charge(steps, 1)?;
+    let element = b.elements.get(feature)?;
+    if !conforms(element.ty, "Feature") {
+        return None;
+    }
+    let membership = element.owning_relationship?;
+    let relation = b.elements.get(membership)?;
+    if !conforms(relation.ty, "FeatureMembership") {
+        return None;
+    }
+    let owner =
+        super::semantic_ownership::checked_relationship_carrier(b, raw, membership, steps)??;
+    if member(b, raw, owner, membership, steps)? != feature {
+        return None;
+    }
+    if let Some(value) = element.props.get("direction") {
+        if value.is_null() && !conforms(relation.ty, "ParameterMembership") {
+            return Some(None);
+        }
+        return match value.as_str() {
+            Some(direction @ ("in" | "out" | "inout")) => Some(Some(direction)),
+            _ => None,
+        };
+    }
+    if element.ty == "TriggerInvocationExpression" {
+        return Some(None);
+    }
+    Some(super::behavior::parameter_direction_default(relation.ty))
+}
+
+/// The first authored Membership outside `excluded_kind` must itself admit the
+/// requested endpoint. A malformed or wrong-kind first member is never skipped.
+/// `reject_owned_kind` lets additive owned-result planning preserve an existing
+/// result rather than generating another one. Invocation typing passes None.
+pub(super) fn first_unowned_member(
+    b: &mut Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded_kind: &str,
+    required_target_kind: &str,
+    reject_owned_kind: Option<&str>,
+    steps: &mut usize,
+) -> Option<usize> {
+    charge(steps, 1)?;
+    if !raw.ids_unique || !raw.is_current(b) || owner >= b.explicit_len() {
+        return None;
+    }
+    let relationships = &b.elements.get(owner)?.owned_relationships;
+    charge(steps, relationships.len())?;
+    let mut seen = HashSet::new();
+    let mut first = None;
+    for &relationship in relationships {
+        let relation = b.elements.get(relationship)?;
+        if relationship >= b.explicit_len()
+            || !conforms(relation.ty, "Relationship")
+            || !seen.insert(relationship)
+            || raw.carrier(b, relationship)? != Some(owner)
+            || reject_owned_kind.is_some_and(|kind| conforms(relation.ty, kind))
+        {
+            return None;
+        }
+        if first.is_none()
+            && conforms(relation.ty, "Membership")
+            && !conforms(relation.ty, excluded_kind)
+        {
+            first = Some(relationship);
+        }
+    }
+    let relation = b.elements.get(first?)?;
+    if conforms(relation.ty, "OwningMembership")
+        || !relation.children.is_empty()
+        || !relation.owned_relationships.is_empty()
+        || relation.owning_relationship.is_some()
+    {
+        return None;
+    }
+    let target_id = relation.props.get("memberElement")?.as_reference()?;
+    let source_id = b.elements[owner].id;
+    for key in ["membershipOwningNamespace", "owningRelatedElement"] {
+        if relation
+            .props
+            .get(key)
+            .is_some_and(|value| value.as_reference() != Some(source_id))
+        {
+            return None;
+        }
+    }
+    for key in ["ownedMemberElement", "ownedMemberFeature"] {
+        if relation.props.get(key).is_some() {
+            return None;
+        }
+    }
+    if relation
+        .props
+        .get("memberFeature")
+        .is_some_and(|value| value.as_reference() != Some(target_id))
+        || relation.props.get("visibility").is_some_and(|value| {
+            !matches!(value.as_str(), Some("public" | "protected" | "private"))
+        })
+    {
+        return None;
+    }
+    for (key, expected) in [
+        ("source", &[source_id][..]),
+        ("target", &[target_id][..]),
+        ("relatedElement", &[source_id, target_id][..]),
+        ("ownedRelatedElement", &[][..]),
+    ] {
+        if let Some(value) = relation.props.get(key) {
+            let values = value.as_array()?;
+            charge(steps, values.len())?;
+            if values.len() != expected.len()
+                || values
+                    .iter()
+                    .zip(expected)
+                    .any(|(value, id)| value.as_reference() != Some(*id))
+            {
+                return None;
+            }
+        }
+    }
+    charge(steps, 1)?;
+    // No ambient lookup cache or whole-model scan participates in a per-owner
+    // membership selector; the endpoint comes from this exact checked snapshot.
+    let target = raw.element_for_uuid(b, target_id)?;
+    conforms(b.elements.get(target)?.ty, required_target_kind).then_some(target)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    fn fixture() -> (ResolvedModel, usize, usize, usize) {
+        let mut model = Model::new();
+        let parsed = model.add_source(
+            "membership-evidence.kerml",
+            "function F {in x; return r;} package P; feature call=F(1);",
+        );
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let function = r.resolve_qualified("F").unwrap().0;
+        let package = r.resolve_qualified("P").unwrap().0;
+        let call =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap();
+        (r, call, function, package)
+    }
+    #[test]
+    fn shared_owned_parameter_selector_preserves_reciprocal_narrowed_aliases() {
+        for (key, on_child) in [
+            ("ownedMemberParameter", false),
+            ("owningFeatureMembership", true),
+            ("owningParameterMembership", true),
+        ] {
+            for bad in 0..4 {
+                let (mut r, function, _, package) = fixture();
+                let membership = r.b.elements[function]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| r.b.elements[rel].ty == "ParameterMembership")
+                    .unwrap();
+                let x = r.b.elements[membership].children[0];
+                let row = if on_child { x } else { membership };
+                let expected = r.b.elements[if on_child { membership } else { x }].id;
+                let wrong = r.b.elements[package].id;
+                let value = match bad {
+                    0 => serde_json::json!({"@id":expected.to_string()}),
+                    1 => serde_json::json!({"@id":wrong.to_string()}),
+                    2 => serde_json::Value::Null,
+                    _ => serde_json::json!([]),
+                };
+                r.b.elements[row].props.insert(key, value);
+                let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+                assert_eq!(
+                    member(&r.b, &raw, function, membership, &mut 0),
+                    (bad == 0).then_some(x),
+                    "{key}, {bad}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn shared_member_selector_refuses_stale_rows_and_exhaustion_without_poisoning_retry() {
+        let (mut r, _, function, _) = fixture();
+        let x = r.resolve_qualified("F::x").unwrap().0;
+        let membership = r.b.elements[x].owning_relationship.unwrap();
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            member(&r.b, &raw, function, membership, &mut exhausted),
+            None
+        );
+        assert_eq!(member(&r.b, &raw, function, membership, &mut 0), Some(x));
+        r.b.elements[membership]
+            .props
+            .insert("memberElement", serde_json::Value::Null);
+        assert_eq!(member(&r.b, &raw, function, membership, &mut 0), None);
+        let fresh = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert_eq!(member(&r.b, &fresh, function, membership, &mut 0), None);
+    }
+
+    #[test]
+    fn local_callee_is_identity_checked_and_budget_retry_is_fresh() {
+        let (mut r, call, function, _) = fixture();
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            first_unowned_member(
+                &mut r.b,
+                &raw,
+                call,
+                "FeatureMembership",
+                "Type",
+                None,
+                &mut 0
+            ),
+            Some(function)
+        );
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            first_unowned_member(
+                &mut r.b,
+                &raw,
+                call,
+                "FeatureMembership",
+                "Type",
+                None,
+                &mut exhausted
+            ),
+            None
+        );
+        assert_eq!(
+            first_unowned_member(
+                &mut r.b,
+                &raw,
+                call,
+                "FeatureMembership",
+                "Type",
+                None,
+                &mut 0
+            ),
+            Some(function)
+        );
+    }
+    #[test]
+    fn wrong_kind_first_membership_is_never_skipped_for_a_later_valid_callee() {
+        let (mut r, call, _, package) = fixture();
+        let first = r.b.elements[call]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| {
+                conforms(r.b.elements[rel].ty, "Membership")
+                    && !conforms(r.b.elements[rel].ty, "FeatureMembership")
+            })
+            .unwrap();
+        let mut later = r.b.elements[first].clone();
+        later.id = uuid::Uuid::from_u128(0x87d46f5c964140528cf7c042c0505155);
+        let later_index = r.b.elements.len();
+        r.b.elements.push(later);
+        r.b.elements[call].owned_relationships.push(later_index);
+        let package_id = r.b.elements[package].id;
+        r.b.elements[first].props.insert(
+            "memberElement",
+            serde_json::json!({"@id":package_id.to_string()}),
+        );
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert_eq!(
+            first_unowned_member(
+                &mut r.b,
+                &raw,
+                call,
+                "FeatureMembership",
+                "Type",
+                None,
+                &mut 0
+            ),
+            None
+        );
+    }
+    #[test]
+    fn contradictory_membership_source_target_and_carrier_refuse_local_edges() {
+        for key in ["source", "target", "membershipOwningNamespace"] {
+            let (mut r, call, _, package) = fixture();
+            let membership = r.b.elements[call]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&rel| {
+                    conforms(r.b.elements[rel].ty, "Membership")
+                        && !conforms(r.b.elements[rel].ty, "FeatureMembership")
+                })
+                .unwrap();
+            let wrong = r.b.elements[package].id;
+            let value = if key == "membershipOwningNamespace" {
+                serde_json::json!({"@id":wrong.to_string()})
+            } else {
+                serde_json::json!([{"@id":wrong.to_string()}])
+            };
+            r.b.elements[membership].props.insert(key, value);
+            let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert_eq!(
+                first_unowned_member(
+                    &mut r.b,
+                    &raw,
+                    call,
+                    "FeatureMembership",
+                    "Type",
+                    None,
+                    &mut 0
+                ),
+                None,
+                "{key}"
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/membership_projection.rs b/crates/sysmlv2-model/src/json/membership_projection.rs
new file mode 100644
index 0000000..04674a5
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/membership_projection.rs
@@ -0,0 +1,406 @@
+//! Shared ordered Feature/membership reduction used by positional planning.
+//! Inputs are provider facts; this algebra does not certify their completeness.
+//! Checked effective-input consumers must validate the same provider graph before
+//! treating the returned sequence as complete. No lookup, publication, or cache.
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) struct Membership {
+    pub(super) relationship: usize,
+    pub(super) member: usize,
+}
+
+#[derive(PartialEq, Eq)]
+pub(super) struct Node {
+    pub(super) owned: Vec<usize>,
+    pub(super) owned_memberships: Vec<Membership>,
+    pub(super) bases: Vec<usize>,
+    pub(super) public_imports: Vec<Membership>,
+    pub(super) protected_imports: Vec<Membership>,
+    pub(super) memberships_complete: bool,
+}
+
+/// Classification facts belong to the caller's provider. These predicates do
+/// not imply that the owner's relationship or inheritance domain is complete.
+pub(super) trait MembershipFacts {
+    fn is_feature(&self, member: usize) -> bool;
+    fn is_feature_membership(&self, relationship: usize) -> bool;
+    fn is_protected(&self, relationship: usize) -> bool;
+}
+
+#[derive(Default)]
+pub(super) struct Reduction {
+    seen: HashSet<usize>,
+    owned_direct: HashSet<usize>,
+    counts: HashMap<usize, usize>,
+    shadow: HashSet<usize>,
+}
+impl Reduction {
+    /// Ordered union of each direct base's complete nonprivate projection.
+    pub(super) fn inheritable(
+        &mut self,
+        node: &Node,
+        exported: &HashMap<usize, Vec<Membership>>,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<Vec<Membership>> {
+        let mut inherited = Vec::new();
+        reset_scratch_set(&mut self.seen);
+        for &base in &node.bases {
+            // Admission belongs to the contributing membership or import,
+            // including import-all contributions of private members.
+            charge(steps, exported[&base].len().saturating_add(1))?;
+            for &membership in &exported[&base] {
+                if self.seen.insert(membership.relationship) {
+                    inherited.push(membership);
+                }
+            }
+        }
+        Some(inherited)
+    }
+    pub(super) fn reduce(
+        &mut self,
+        node: &Node,
+        exported: &HashMap<usize, Vec<Membership>>,
+        redefinitions: &HashMap<usize, Vec<usize>>,
+        traversal: &mut Reachability,
+        facts: &impl MembershipFacts,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<(Vec<usize>, Vec<Membership>)> {
+        let mut inherited = self.inheritable(node, exported, steps)?;
+        reset_scratch_set(&mut self.owned_direct);
+        for feature in &node.owned {
+            charge(
+                steps,
+                redefinitions
+                    .get(feature)
+                    .map_or(0, Vec::len)
+                    .saturating_add(1),
+            )?;
+        }
+        self.owned_direct.extend(
+            node.owned
+                .iter()
+                .flat_map(|f| redefinitions.get(f).into_iter().flatten().copied()),
+        );
+        reset_scratch_map(&mut self.counts);
+        charge(steps, inherited.len())?;
+        for membership in &inherited {
+            if facts.is_feature(membership.member) {
+                *self.counts.entry(membership.member).or_insert(0usize) += 1;
+            }
+        }
+        reset_scratch_set(&mut self.shadow);
+        // Every membership of one Feature has the same closure and
+        // owned-feature comparison, so traverse that Feature only once.
+        for (&feature, &count) in &self.counts {
+            charge(steps, 1)?;
+            if redefinitions.get(&feature).is_none_or(Vec::is_empty) {
+                // The closure is exactly this feature; no traversal or
+                // intermediate collection is necessary.
+                if count > 1 || self.owned_direct.contains(&feature) {
+                    self.shadow.insert(feature);
+                }
+                continue;
+            }
+            let closure = traversal.reachable_budget(feature, redefinitions, steps)?;
+            charge(steps, closure.len().saturating_mul(2))?;
+            // Reflexive closure suppresses another Membership of this
+            // same Feature, but never suppresses its own Membership.
+            self.shadow.extend(
+                closure
+                    .iter()
+                    .copied()
+                    .filter(|&target| target != feature || count > 1),
+            );
+            if closure.iter().any(|t| self.owned_direct.contains(t)) {
+                self.shadow.insert(feature);
+            }
+        }
+        charge(
+            steps,
+            inherited
+                .len()
+                .saturating_mul(2)
+                .saturating_add(node.owned.len()),
+        )?;
+        inherited
+            .retain(|m| !self.counts.contains_key(&m.member) || !self.shadow.contains(&m.member));
+        let surviving = inherited;
+        let mut features = node.owned.clone();
+        features.extend(surviving.iter().filter_map(|membership| {
+            facts
+                .is_feature_membership(membership.relationship)
+                .then_some(membership.member)
+        }));
+        Some((features, surviving))
+    }
+    pub(super) fn export(
+        &mut self,
+        node: &Node,
+        surviving: Vec<Membership>,
+        facts: &impl MembershipFacts,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<Vec<Membership>> {
+        charge(
+            steps,
+            node.owned_memberships
+                .len()
+                .saturating_mul(4)
+                .saturating_add(node.public_imports.len().saturating_mul(2))
+                .saturating_add(node.protected_imports.len().saturating_mul(2))
+                .saturating_add(surviving.len().saturating_mul(2)),
+        )?;
+        let mut visible = Vec::new();
+        for protected in [false, true] {
+            visible.extend(
+                node.owned_memberships
+                    .iter()
+                    .copied()
+                    .filter(|m| facts.is_protected(m.relationship) == protected),
+            );
+            visible.extend(if protected {
+                &node.protected_imports
+            } else {
+                &node.public_imports
+            });
+        }
+        visible.extend(surviving);
+        reset_scratch_set(&mut self.seen);
+        visible.retain(|m| self.seen.insert(m.relationship));
+        Some(visible)
+    }
+}
+
+// A wide node must not make every later tiny node clear a wide hash table.
+// Retain ordinary capacities, but discard an oversized table after that first
+// wide-to-small transition; its one large clear is charged to the wide node.
+pub(super) fn reset_scratch_set<T>(scratch: &mut HashSet<T>) {
+    if scratch.capacity() > scratch.len().max(32).saturating_mul(4) {
+        *scratch = HashSet::new();
+    } else {
+        scratch.clear();
+    }
+}
+
+pub(super) fn reset_scratch_map<K, V>(scratch: &mut HashMap<K, V>) {
+    if scratch.capacity() > scratch.len().max(32).saturating_mul(4) {
+        *scratch = HashMap::new();
+    } else {
+        scratch.clear();
+    }
+}
+
+/// Scratch space for one planning pass. The graph grows while planning, so
+/// every traversal gets fresh marks; only storage is reused, never reachability.
+pub(super) struct Reachability {
+    pub(super) marks: Vec<usize>,
+    sparse: Option<HashSet<usize>>,
+    pub(super) generation: usize,
+    pub(super) todo: Vec<usize>,
+    pub(super) reached: Vec<usize>,
+}
+
+impl Reachability {
+    pub(super) fn new(elements: usize) -> Self {
+        Self {
+            marks: vec![0; elements],
+            sparse: None,
+            generation: 0,
+            todo: Vec::new(),
+            reached: Vec::new(),
+        }
+    }
+
+    /// Small certified slices need marks only for visited identities. This
+    /// reuses the same traversal, without allocating for unrelated graph rows.
+    pub(super) fn sparse() -> Self {
+        Self {
+            marks: Vec::new(),
+            sparse: Some(HashSet::new()),
+            generation: 0,
+            todo: Vec::new(),
+            reached: Vec::new(),
+        }
+    }
+
+    fn begin(&mut self, steps: &mut Option<&mut usize>) -> Option<()> {
+        if let Some(marks) = &mut self.sparse {
+            charge(steps, marks.capacity())?;
+            reset_scratch_set(marks);
+        } else {
+            if self.generation == usize::MAX {
+                charge(steps, self.marks.len())?;
+                self.marks.fill(0);
+                self.generation = 0;
+            }
+            self.generation += 1;
+        }
+        Some(())
+    }
+
+    fn visit(&mut self, element: usize) -> bool {
+        if let Some(marks) = &mut self.sparse {
+            marks.insert(element)
+        } else if self.marks[element] == self.generation {
+            false
+        } else {
+            self.marks[element] = self.generation;
+            true
+        }
+    }
+
+    #[cfg(test)]
+    pub(super) fn reachable(
+        &mut self,
+        source: usize,
+        graph: &HashMap<usize, Vec<usize>>,
+    ) -> &[usize] {
+        self.reachable_budget(source, graph, &mut None)
+            .expect("unbounded traversal cannot exhaust its budget")
+    }
+
+    /// Existential reachability does not need to allocate a complete closure.
+    /// Fresh marks observe graph growth between calls; no answer is cached.
+    pub(super) fn reaches_budget(
+        &mut self,
+        source: usize,
+        target: usize,
+        graph: &HashMap<usize, Vec<usize>>,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        self.begin(steps)?;
+        self.todo.clear();
+        self.todo.push(source);
+        while let Some(e) = self.todo.pop() {
+            charge(steps, 1)?;
+            if e == target {
+                return Some(true);
+            }
+            if !self.visit(e) {
+                continue;
+            }
+            for &next in graph.get(&e).into_iter().flatten() {
+                charge(steps, 1)?;
+                if next == target {
+                    return Some(true);
+                }
+                self.todo.push(next);
+            }
+        }
+        Some(false)
+    }
+
+    pub(super) fn reachable_budget(
+        &mut self,
+        source: usize,
+        graph: &HashMap<usize, Vec<usize>>,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<&[usize]> {
+        charge(steps, 1)?;
+        self.begin(steps)?;
+        self.todo.clear();
+        self.reached.clear();
+        self.todo.push(source);
+        while let Some(e) = self.todo.pop() {
+            charge(steps, 1)?;
+            if self.visit(e) {
+                self.reached.push(e);
+                charge(steps, graph.get(&e).map_or(0, Vec::len))?;
+                self.todo
+                    .extend(graph.get(&e).into_iter().flatten().copied());
+            }
+        }
+        Some(&self.reached)
+    }
+}
+
+pub(super) fn charge(steps: &mut Option<&mut usize>, amount: usize) -> Option<()> {
+    if let Some(steps) = steps {
+        **steps = steps.saturating_add(amount);
+        if **steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+    }
+    Some(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn sparse_wide_to_small_traversal_work_does_not_retain_wide_clear_cost() {
+        let graph = HashMap::from([(0, (1..10_000).collect()), (10_000, vec![10_001])]);
+        let mut dense = Reachability::new(10_002);
+        let mut sparse = Reachability::sparse();
+        let mut steps = 0;
+        assert_eq!(
+            sparse
+                .reachable_budget(0, &graph, &mut Some(&mut steps))
+                .unwrap(),
+            dense.reachable(0, &graph)
+        );
+        for _ in 0..2 {
+            assert_eq!(
+                sparse
+                    .reachable_budget(10_000, &graph, &mut Some(&mut steps))
+                    .unwrap(),
+                dense.reachable(10_000, &graph)
+            );
+        }
+        let small_start = steps;
+        for _ in 0..1_000 {
+            assert_eq!(
+                sparse
+                    .reachable_budget(10_000, &graph, &mut Some(&mut steps))
+                    .unwrap(),
+                &[10_000, 10_001]
+            );
+        }
+        assert!(steps - small_start < 10_000);
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(
+            sparse
+                .reachable_budget(0, &graph, &mut Some(&mut exhausted))
+                .is_none()
+        );
+        assert_eq!(sparse.reachable(0, &graph), dense.reachable(0, &graph));
+    }
+    #[test]
+    fn existential_reachability_matches_complete_closure_through_graph_growth() {
+        let mut graph: HashMap<usize, Vec<usize>> = HashMap::new();
+        let mut traversal = Reachability::new(12);
+        let mut sparse = Reachability::sparse();
+        for round in 0..36 {
+            graph
+                .entry(round % 12)
+                .or_default()
+                .push((round * 7 + 3 + round / 12) % 12);
+            for source in 0..12 {
+                let expected = traversal.reachable(source, &graph).to_vec();
+                assert_eq!(sparse.reachable(source, &graph), expected);
+                for target in 0..12 {
+                    assert_eq!(
+                        traversal.reaches_budget(source, target, &graph, &mut Some(&mut 0)),
+                        Some(expected.contains(&target))
+                    );
+                    assert_eq!(
+                        sparse.reaches_budget(source, target, &graph, &mut Some(&mut 0)),
+                        Some(expected.contains(&target))
+                    );
+                }
+            }
+        }
+        traversal.generation = usize::MAX;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(
+            traversal
+                .reaches_budget(0, 3, &graph, &mut Some(&mut exhausted))
+                .is_none()
+        );
+        assert_eq!(
+            traversal.reaches_budget(0, 3, &graph, &mut Some(&mut 0)),
+            Some(true)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/metadata_associations.rs b/crates/sysmlv2-model/src/json/metadata_associations.rs
new file mode 100644
index 0000000..0c8a939
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/metadata_associations.rs
@@ -0,0 +1,368 @@
+//! Shared positive Annotation association snapshots.
+use super::Builder;
+use crate::layered::LayeredMap;
+use std::collections::BTreeMap;
+
+/// Reference-resolution checkpoints restore this together with endpoint rows.
+#[derive(Clone)]
+pub(super) struct Snapshot {
+    merged: LayeredMap<usize, Vec<usize>>,
+    explicit: BTreeMap<usize, Vec<usize>>,
+    incomplete: bool,
+}
+impl Builder {
+    /// Intrinsic metadata survives removal/retargeting of explicit Annotations,
+    /// even if a source identity eventually contributes through both routes.
+    pub(super) fn record_intrinsic_metadata(&mut self, owner: usize, metadata: usize) {
+        self.metadata_of.entry(owner).or_default().push(metadata);
+        if self.metadata_association_generation.is_some() {
+            self.metadata_association_generation = Some(std::sync::Arc::new(()));
+        }
+        if let Some(intrinsic) = &mut self.metadata_intrinsic {
+            intrinsic.entry(owner).or_default().push(metadata);
+        }
+    }
+    pub(super) fn metadata_snapshot(&self) -> Snapshot {
+        Snapshot {
+            merged: self.metadata_of.clone(),
+            explicit: self.metadata_about.clone(),
+            incomplete: self.metadata_associations_incomplete,
+        }
+    }
+    pub(super) fn restore_metadata_snapshot(&mut self, snapshot: &Snapshot) {
+        self.retain_library_prefix_for(&snapshot.merged);
+        self.metadata_of = snapshot.merged.clone();
+        self.metadata_about = snapshot.explicit.clone();
+        self.metadata_associations_incomplete = snapshot.incomplete;
+        self.metadata_association_generation = Some(std::sync::Arc::new(()));
+        self.reset_lookup_caches();
+        self.semantic_memo = Default::default();
+    }
+    /// The frozen library prefix of the recorded lookup graph reads the
+    /// metadata of library owners only, so it outlives a change confined
+    /// to user rows — every reference-resolution pass restores metadata.
+    fn retain_library_prefix_for(&mut self, next: &LayeredMap<usize, Vec<usize>>) {
+        let boundary = self.lib_boundary;
+        if !self.metadata_of.agrees_on(next, |&owner| owner < boundary) {
+            self.recorded_lookup_prefix = None;
+        }
+    }
+    /// Called only between complete reference-resolution passes or at an
+    /// explicit public mutation boundary. No partially updated association is
+    /// visible to another pending reference in the same pass.
+    pub(super) fn refresh_metadata_associations(&mut self) -> bool {
+        if self.explicit_metadata_annotations.is_empty() {
+            return false;
+        }
+        if self.metadata_intrinsic.is_none() {
+            self.metadata_intrinsic = Some(self.metadata_of.clone());
+        }
+        // A failed fixed-point pass cannot be repaired merely by observing its
+        // restored bootstrap endpoints after ID assignment or binding replay.
+        if self.recorded_lookup_incomplete {
+            return self.replace_metadata_associations(BTreeMap::new(), true);
+        }
+        let mut steps = 0;
+        let raw = super::structural_index::StoredStructure::for_annotations(self, &mut steps);
+        let mut next: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
+        let mut incomplete = true;
+        if let Some(raw) = raw.filter(|raw| raw.ids_unique) {
+            incomplete = raw.annotations_incomplete;
+            for (&target, sources) in &raw.metadata_annotation_sources {
+                steps = steps.saturating_add(sources.len());
+                if steps > crate::eval::MAX_STEPS {
+                    next.clear();
+                    incomplete = true;
+                    break;
+                }
+                // Sources are recorded in relationship order; sort by the
+                // immutable declaration index to combine all annotation forms.
+                let mut sources = sources.clone();
+                sources.sort_unstable();
+                sources.dedup();
+                next.insert(target, sources);
+            }
+        }
+        self.replace_metadata_associations(next, incomplete)
+    }
+    pub(super) fn discard_unstable_metadata_associations(&mut self) {
+        self.replace_metadata_associations(BTreeMap::new(), true);
+    }
+    fn replace_metadata_associations(
+        &mut self,
+        mut next: BTreeMap<usize, Vec<usize>>,
+        incomplete: bool,
+    ) -> bool {
+        // Empty entries retain touched-target history for prepared Facts.
+        // They contribute no metadata, but ensure removal recomputes the old
+        // library target's context even when intrinsic metadata remains there.
+        for &target in self.metadata_about.keys() {
+            next.entry(target).or_default();
+        }
+        if self.metadata_about == next && self.metadata_associations_incomplete == incomplete {
+            return false;
+        }
+        let mut merged = self
+            .metadata_intrinsic
+            .as_ref()
+            .expect("intrinsic snapshot")
+            .clone();
+        for (&target, sources) in &next {
+            let list = merged.entry(target).or_default();
+            list.extend(sources.iter().copied());
+            list.sort_unstable();
+            list.dedup();
+        }
+        self.retain_library_prefix_for(&merged);
+        self.metadata_of = merged;
+        self.metadata_about = next;
+        self.metadata_associations_incomplete = incomplete;
+        self.metadata_association_generation = Some(std::sync::Arc::new(()));
+        // Element rows need not change when this semantic input changes.
+        self.reset_lookup_caches();
+        self.semantic_memo = Default::default();
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    //! Include in json/metadata_associations.rs as child tests module.
+    use crate::{json::ResolvedModel, model::Model};
+    /// Every replay pass restores the metadata snapshot. The frozen library
+    /// prefix of the recorded lookup graph survives those restores while
+    /// library owners' metadata is unchanged; an annotation about a library
+    /// element drops it.
+    #[test]
+    fn replay_keeps_library_lookup_prefix_unless_library_metadata_changes() {
+        let mut base = Model::new();
+        base.add_library_source(
+            "lib.kerml",
+            "standard library package L { metaclass Mark; \
+             class A { feature x; } class B :> A { feature redefines x; } }",
+        );
+        let prepared = base.prepare_library().unwrap();
+        for (source, kept) in [
+            ("class C :> L::B { feature redefines x; }", true),
+            (
+                "class C :> L::B { feature redefines x; } @L::Mark about L::A;",
+                false,
+            ),
+        ] {
+            let mut model = Model::new();
+            std::sync::Arc::clone(&prepared)
+                .install(&mut model)
+                .unwrap();
+            assert!(
+                model
+                    .add_source("user.kerml", source)
+                    .diagnostics
+                    .is_empty()
+            );
+            let r = ResolvedModel::build(&model);
+            assert!(r.b.lib_boundary > 0, "built on the prepared library");
+            assert_eq!(r.b.recorded_lookup_prefix.is_some(), kept, "{source}");
+        }
+    }
+    fn fixture() -> (ResolvedModel, usize, usize, usize) {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source(
+                    "associations.kerml",
+                    "metaclass Mark; #Mark class A; class B; @Mark about A;"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let ann =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "Annotation")
+                .unwrap();
+        (r, a, b, ann)
+    }
+    #[test]
+    fn retarget_missing_and_malformed_remove_only_explicit_contributions() {
+        let (mut r, a, b, ann) = fixture();
+        let original = r.b.metadata_of.get(&a).unwrap().clone();
+        assert_eq!(original.len(), 2);
+        let target = r.b.elements[b].id;
+        r.b.elements[ann].props.insert(
+            "annotatedElement",
+            serde_json::json!({"@id":target.to_string()}),
+        );
+        assert!(r.b.refresh_metadata_associations());
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+        assert_eq!(r.b.metadata_of.get(&b).unwrap(), &original[1..]);
+        assert!(!r.b.metadata_associations_incomplete);
+        let good = r.b.elements[ann].props.clone();
+        for malformed in [false, true] {
+            r.b.elements[ann].props = good.clone();
+            if malformed {
+                r.b.elements[ann]
+                    .props
+                    .insert("source", serde_json::json!([{"@id":target.to_string()}]));
+            } else {
+                r.b.elements[ann]
+                    .props
+                    .insert("annotatedElement", serde_json::json!({"@ref":"Missing"}));
+            }
+            assert!(r.b.refresh_metadata_associations());
+            assert!(r.b.metadata_of.get(&b).is_none_or(|items| items.is_empty()));
+            assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+            assert!(r.b.metadata_associations_incomplete);
+            r.b.elements[ann].props = good.clone();
+            assert!(r.b.refresh_metadata_associations());
+            assert!(!r.b.metadata_associations_incomplete);
+        }
+    }
+    #[test]
+    fn restored_snapshot_and_nonconvergence_preserve_intrinsic_metadata() {
+        let (mut r, a, b, ann) = fixture();
+        let original = r.b.metadata_of.get(&a).unwrap().clone();
+        let snapshot = r.b.metadata_snapshot();
+        let props = r.b.elements[ann].props.clone();
+        let target = r.b.elements[b].id;
+        r.b.elements[ann].props.insert(
+            "annotatedElement",
+            serde_json::json!({"@id":target.to_string()}),
+        );
+        r.b.refresh_metadata_associations();
+        r.b.elements[ann].props = props;
+        r.b.restore_metadata_snapshot(&snapshot);
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original);
+        assert!(r.b.metadata_of.get(&b).is_none_or(|items| items.is_empty()));
+        r.b.discard_unstable_metadata_associations();
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+        assert!(r.b.metadata_associations_incomplete);
+        assert!(r.b.refresh_metadata_associations());
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original);
+    }
+    #[test]
+    fn duplicate_identity_cannot_keep_a_warmed_explicit_association() {
+        let (mut r, a, b, _) = fixture();
+        let original = r.b.metadata_of.get(&a).unwrap().clone();
+        let prior = r.b.elements[b].id;
+        r.b.elements[b].id = r.b.elements[a].id;
+        assert!(r.b.refresh_metadata_associations());
+        assert!(r.b.metadata_associations_incomplete);
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+        r.b.elements[b].id = prior;
+        assert!(r.b.refresh_metadata_associations());
+        assert!(!r.b.metadata_associations_incomplete);
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original);
+    }
+
+    #[test]
+    fn failed_resolution_cannot_be_readmitted_by_final_identity_refresh() {
+        let (mut r, a, _, _) = fixture();
+        let original = r.b.metadata_of.get(&a).unwrap().clone();
+        r.b.discard_unstable_metadata_associations();
+        r.b.recorded_lookup_incomplete = true;
+        assert!(!r.b.refresh_metadata_associations());
+        assert!(r.b.metadata_associations_incomplete);
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+        // This is the same final-ID boundary used by normal model construction.
+        let roots =
+            r.b.unit_starts
+                .iter()
+                .map(|&(root, _)| root)
+                .collect::<Vec<_>>();
+        r.b.assign_user_ids(0, &roots);
+        assert!(r.b.metadata_associations_incomplete);
+        assert_eq!(r.b.metadata_of.get(&a).unwrap(), &original[..1]);
+        assert!(r.b.metadata_about.get(&a).unwrap().is_empty());
+    }
+    #[test]
+    fn same_row_snapshot_uncertainty_cannot_reuse_provider_positive() {
+        let mut model = Model::new();
+        model.add_source(
+            "unaffected.kerml",
+            "class A; class B; metaclass M; @M about B;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let snapshot = r.b.metadata_snapshot();
+        let mut proof = super::super::provider_completeness::ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.discard_unstable_metadata_associations();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.restore_metadata_snapshot(&snapshot);
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+    #[test]
+    fn prepared_facts_refresh_old_and_new_library_targets_on_retarget() {
+        let mut base = Model::new();
+        let library = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Metaobjects {metaclass SemanticMetadata {feature baseType;}} metaclass U; class A; metaclass Tagged :> Metaobjects::SemanticMetadata {:>> baseType=A meta U;} class C; class D; @Tagged about C;";
+        assert!(
+            base.add_library_source("about-library.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        let prepared = base.prepare_library().unwrap();
+        let mut model = Model::new();
+        prepared.install(&mut model).unwrap();
+        model.add_source("user.kerml", "class User;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let d = r.resolve_qualified("D").unwrap().0;
+        assert!(r.b.library_facts.is_some());
+        assert!(
+            crate::check::facts::Facts::new(&mut r.b)
+                .context(c)
+                .contains(&a)
+        );
+        let ann =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "Annotation")
+                .unwrap();
+        let target = r.b.elements[d].id;
+        r.b.elements[ann].props.insert(
+            "annotatedElement",
+            serde_json::json!({"@id":target.to_string()}),
+        );
+        assert!(r.b.refresh_metadata_associations());
+        assert!(r.b.metadata_about.get(&c).unwrap().is_empty());
+        let facts = crate::check::facts::Facts::new(&mut r.b);
+        assert!(!facts.context(c).contains(&a));
+        assert!(facts.context(d).contains(&a));
+    }
+    #[test]
+    fn incomplete_or_multiple_metadata_casts_cannot_choose_first_boolean_binding() {
+        for prefix in [false, true] {
+            for first in [false, true] {
+                let initial = if prefix {
+                    format!("class C {{@M {{flag={first};}}}}")
+                } else {
+                    format!("class C; @M about C {{flag={first};}}")
+                };
+                for other in ["C", "Missing"] {
+                    let mut model = Model::new();
+                    let source = format!(
+                        "metaclass M {{feature flag;}} {initial} @M about {other} {{flag={};}}",
+                        !first
+                    );
+                    let parsed = model.add_source("attributes.kerml", &source);
+                    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+                    let mut r = ResolvedModel::build(&model);
+                    let c = r.resolve_qualified("C").unwrap().0;
+                    let qn = super::super::lib_qn("M");
+                    let mut attr = super::super::lib_qn("flag");
+                    attr.is_global = false;
+                    assert_eq!(
+                        r.b.metadata_attr_verdict(0, &qn, &attr, c, 0),
+                        super::super::Tri::Unknown,
+                        "{source}"
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/model_level_evaluability.rs b/crates/sysmlv2-model/src/json/model_level_evaluability.rs
new file mode 100644
index 0000000..9aa1a7c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/model_level_evaluability.rs
@@ -0,0 +1,559 @@
+//! Bounded evidence for normative model-level eligibility, separate from execution.
+mod adapter;
+use std::collections::{HashMap, HashSet};
+
+/// A proof of the model-level eligibility rule, not a promise that evaluation
+/// succeeds and not a complete model-validity certificate.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ModelLevelEvaluability {
+    Evaluable,
+    NotEvaluable,
+    Unknown(ModelLevelEvaluabilityUnknown),
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ModelLevelEvaluabilityUnknown {
+    InvalidElement,
+    MissingOrMalformedMembership,
+    MissingOrMalformedValuation,
+    IncompleteFeaturing,
+    IncompleteSelfConformance,
+    IncompleteCallee,
+    IncompleteArgumentMapping,
+    UnsupportedExpression,
+    UnsupportedDirectionOrResult,
+    CyclicOwnership,
+    DepthLimit,
+    WorkLimit,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ModelLevelEvaluabilityReport {
+    pub classification: ModelLevelEvaluability,
+    pub steps: usize,
+}
+use ModelLevelEvaluability::{Evaluable as Yes, NotEvaluable as No, Unknown};
+type Evidence<T> = Result<T, ModelLevelEvaluabilityUnknown>;
+type Node = usize;
+fn and(left: ModelLevelEvaluability, right: ModelLevelEvaluability) -> ModelLevelEvaluability {
+    match (left, right) {
+        (No, _) | (_, No) => No,
+        (Yes, Yes) => Yes,
+        (Unknown(reason), _) | (_, Unknown(reason)) => Unknown(reason),
+    }
+}
+fn or(left: ModelLevelEvaluability, right: ModelLevelEvaluability) -> ModelLevelEvaluability {
+    match (left, right) {
+        (Yes, _) | (_, Yes) => Yes,
+        (No, No) => No,
+        (Unknown(reason), _) | (_, Unknown(reason)) => Unknown(reason),
+    }
+}
+struct Budget {
+    used: usize,
+    limit: usize,
+}
+impl Budget {
+    fn charge(&mut self, amount: usize) -> Evidence<()> {
+        self.used = self.used.saturating_add(amount);
+        if self.used > self.limit {
+            Err(ModelLevelEvaluabilityUnknown::WorkLimit)
+        } else {
+            Ok(())
+        }
+    }
+}
+#[derive(Clone, Copy)]
+enum Kind {
+    Leaf,
+    Forbidden,
+    Reference,
+    Invocation,
+    Constructor,
+    General,
+}
+struct ReferenceEvidence {
+    referent: Node,
+    self_conformance: ModelLevelEvaluability,
+    expression: bool,
+    metadata_owner: ModelLevelEvaluability,
+    unfeatured: ModelLevelEvaluability,
+    valuation: Evidence<Option<Node>>,
+}
+struct CallEvidence {
+    function: ModelLevelEvaluability,
+    // This is a COMPLETE argument projection, never a derived Vec whose
+    // missing/unmapped entries have already been discarded.
+    arguments: Evidence<Vec<Node>>,
+}
+struct OwnedFeatureEvidence {
+    input_or_result: ModelLevelEvaluability,
+    no_owned_features: ModelLevelEvaluability,
+    no_valuation: ModelLevelEvaluability,
+    result_expression: Evidence<Option<Node>>,
+}
+struct GeneralEvidence {
+    all_specializations_implied: ModelLevelEvaluability,
+    owned_features: Evidence<Vec<OwnedFeatureEvidence>>,
+}
+/// Every successful collection returned here must account for all source
+/// relationships, including unresolved, external and contradictory entries.
+trait EvidenceProvider {
+    fn kind(&mut self, node: Node, budget: &mut Budget) -> Evidence<Kind>;
+    fn leaf(&mut self, node: Node, budget: &mut Budget) -> Evidence<()>;
+    fn reference(&mut self, node: Node, budget: &mut Budget) -> Evidence<ReferenceEvidence>;
+    fn call(
+        &mut self,
+        node: Node,
+        constructor: bool,
+        budget: &mut Budget,
+    ) -> Evidence<CallEvidence>;
+    fn general(&mut self, node: Node, budget: &mut Budget) -> Evidence<GeneralEvidence>;
+}
+struct Tracking {
+    entry_referents: usize,
+    guards: HashMap<Node, bool>,
+    owned_nodes: HashSet<Node>,
+}
+#[derive(Clone)]
+struct Cached {
+    guards: Vec<(Node, bool)>,
+    owned_nodes: HashSet<Node>,
+    classification: ModelLevelEvaluability,
+}
+struct Proof<P> {
+    provider: P,
+    budget: Budget,
+    max_depth: usize,
+    // Insertion level allows guard propagation without cloning the visited
+    // set at each recursion. Referents are inserted and removed path-locally.
+    visited: HashMap<Node, usize>,
+    active_owned: HashSet<Node>,
+    tracking: Vec<Tracking>,
+    known: HashMap<(Node, usize), Vec<Cached>>,
+}
+impl<P: EvidenceProvider> Proof<P> {
+    fn new(provider: P, work_limit: usize, max_depth: usize) -> Self {
+        Self {
+            provider,
+            budget: Budget {
+                used: 0,
+                limit: work_limit,
+            },
+            max_depth,
+            visited: HashMap::new(),
+            active_owned: HashSet::new(),
+            tracking: Vec::new(),
+            known: HashMap::new(),
+        }
+    }
+    fn report(mut self, node: Node) -> ModelLevelEvaluabilityReport {
+        let classification = self.walk(node, 0);
+        ModelLevelEvaluabilityReport {
+            classification,
+            steps: self.budget.used,
+        }
+    }
+    fn visited_test(&mut self, node: Node) -> Evidence<bool> {
+        self.budget.charge(self.tracking.len())?;
+        let level = self.visited.get(&node).copied();
+        for frame in &mut self.tracking {
+            // A referent inserted inside this frame is constant local state,
+            // not a condition on the frame's caller's visited set.
+            if level.is_none_or(|level| level <= frame.entry_referents) {
+                frame.guards.insert(node, level.is_some());
+            }
+        }
+        Ok(level.is_some())
+    }
+    fn walk(&mut self, node: Node, depth: usize) -> ModelLevelEvaluability {
+        if let Err(reason) = self.budget.charge(1) {
+            return Unknown(reason);
+        }
+        if depth > self.max_depth {
+            return Unknown(ModelLevelEvaluabilityUnknown::DepthLimit);
+        }
+        if let Some(variants) = self.known.get(&(node, depth)) {
+            if let Err(reason) = self.budget.charge(
+                variants
+                    .iter()
+                    .map(|cached| cached.guards.len() + cached.owned_nodes.len() + 1)
+                    .sum(),
+            ) {
+                return Unknown(reason);
+            }
+        }
+        let variants = self.known.get(&(node, depth)).cloned().unwrap_or_default();
+        for cached in variants {
+            if let Err(reason) = self.budget.charge(cached.guards.len()) {
+                return Unknown(reason);
+            }
+            if cached.owned_nodes.is_disjoint(&self.active_owned)
+                && cached
+                    .guards
+                    .iter()
+                    .all(|(n, expected)| self.visited.contains_key(n) == *expected)
+            {
+                if let Err(reason) = self
+                    .budget
+                    .charge(cached.owned_nodes.len().saturating_mul(self.tracking.len()))
+                {
+                    return Unknown(reason);
+                }
+                for frame in &mut self.tracking {
+                    frame.owned_nodes.extend(cached.owned_nodes.iter().copied());
+                }
+                for (n, _) in cached.guards {
+                    if let Err(reason) = self.visited_test(n) {
+                        return Unknown(reason);
+                    }
+                }
+                return cached.classification;
+            }
+        }
+        let kind = match self.provider.kind(node, &mut self.budget) {
+            Ok(kind) => kind,
+            Err(reason) => return Unknown(reason),
+        };
+        // Reference cycles have a normative visited-set rule. Other owning
+        // expression cycles are invalid evidence and cannot become vacuous.
+        let guarded = !matches!(kind, Kind::Reference);
+        if guarded && !self.active_owned.insert(node) {
+            return Unknown(ModelLevelEvaluabilityUnknown::CyclicOwnership);
+        }
+        if let Err(reason) = self.budget.charge(self.tracking.len()) {
+            if guarded {
+                self.active_owned.remove(&node);
+            }
+            return Unknown(reason);
+        }
+        if guarded {
+            for frame in &mut self.tracking {
+                frame.owned_nodes.insert(node);
+            }
+        }
+        self.tracking.push(Tracking {
+            entry_referents: self.visited.len(),
+            guards: HashMap::new(),
+            owned_nodes: if guarded {
+                HashSet::from([node])
+            } else {
+                HashSet::new()
+            },
+        });
+        let mut classification = self.uncached(node, kind, depth);
+        let tracking = self.tracking.pop().expect("balanced eligibility proof");
+        if guarded {
+            self.active_owned.remove(&node);
+        }
+        if self.budget.used > self.budget.limit {
+            classification = Unknown(ModelLevelEvaluabilityUnknown::WorkLimit);
+        }
+        if !matches!(classification, Unknown(_)) {
+            let variants = self.known.entry((node, depth)).or_default();
+            if variants.len() < 8 {
+                variants.push(Cached {
+                    guards: tracking.guards.into_iter().collect(),
+                    owned_nodes: tracking.owned_nodes,
+                    classification,
+                });
+            }
+        }
+        classification
+    }
+    fn uncached(&mut self, node: Node, kind: Kind, depth: usize) -> ModelLevelEvaluability {
+        match kind {
+            Kind::Forbidden => No,
+            Kind::Leaf => self
+                .provider
+                .leaf(node, &mut self.budget)
+                .map_or_else(Unknown, |_| Yes),
+            Kind::Reference => self.reference(node, depth),
+            Kind::Invocation | Kind::Constructor => {
+                let constructor = matches!(kind, Kind::Constructor);
+                let call = match self.provider.call(node, constructor, &mut self.budget) {
+                    Ok(call) => call,
+                    Err(reason) => return Unknown(reason),
+                };
+                let mut result = if constructor { Yes } else { call.function };
+                match call.arguments {
+                    Err(reason) => and(result, Unknown(reason)),
+                    Ok(arguments) => {
+                        for argument in arguments {
+                            result = and(result, self.walk(argument, depth + 1));
+                            if result == No {
+                                break;
+                            }
+                        }
+                        result
+                    }
+                }
+            }
+            Kind::General => {
+                let general = match self.provider.general(node, &mut self.budget) {
+                    Ok(general) => general,
+                    Err(reason) => return Unknown(reason),
+                };
+                let mut result = general.all_specializations_implied;
+                if result == No {
+                    return No;
+                }
+                let features = match general.owned_features {
+                    Ok(features) => features,
+                    Err(reason) => return and(result, Unknown(reason)),
+                };
+                for feature in features {
+                    let plain = and(
+                        feature.input_or_result,
+                        and(feature.no_owned_features, feature.no_valuation),
+                    );
+                    let result_expression = match feature.result_expression {
+                        Ok(Some(child)) if plain != Yes => self.walk(child, depth + 1),
+                        Ok(Some(_)) => Yes,
+                        Ok(None) => No,
+                        Err(reason) => Unknown(reason),
+                    };
+                    result = and(result, or(plain, result_expression));
+                    if result == No {
+                        break;
+                    }
+                }
+                result
+            }
+        }
+    }
+    fn reference(&mut self, node: Node, depth: usize) -> ModelLevelEvaluability {
+        let data = match self.provider.reference(node, &mut self.budget) {
+            Ok(data) => data,
+            Err(reason) => return Unknown(reason),
+        };
+        if data.self_conformance == Yes {
+            return Yes;
+        }
+        match self.visited_test(data.referent) {
+            Err(reason) => return Unknown(reason),
+            Ok(true) => return or(data.self_conformance, No),
+            Ok(false) => {}
+        }
+        self.visited.insert(data.referent, self.visited.len() + 1);
+        // These are OCL alternatives. A failed Expression branch must not
+        // suppress the metadata-owner or unfeatured-valuation alternatives.
+        let mut alternatives = data.metadata_owner;
+        if alternatives != Yes && data.expression {
+            alternatives = or(alternatives, self.walk(data.referent, depth + 1));
+        }
+        if alternatives != Yes && data.unfeatured != No {
+            let valuation = match data.valuation {
+                Ok(None) => Yes,
+                Ok(Some(value)) => self.walk(value, depth + 1),
+                Err(reason) => Unknown(reason),
+            };
+            alternatives = or(alternatives, and(data.unfeatured, valuation));
+        }
+        self.visited.remove(&data.referent);
+        or(alternatives, data.self_conformance)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[derive(Clone)]
+    enum MockNode {
+        Leaf,
+        Forbidden,
+        Reference {
+            referent: Node,
+            recursive: bool,
+            metadata: bool,
+            valuation: Evidence<Option<Node>>,
+            unfeatured: ModelLevelEvaluability,
+        },
+        Call(Evidence<Vec<Node>>, ModelLevelEvaluability),
+        Result(Node),
+    }
+    struct Mock(HashMap<Node, MockNode>);
+    impl EvidenceProvider for Mock {
+        fn kind(&mut self, node: Node, _: &mut Budget) -> Evidence<Kind> {
+            Ok(
+                match self
+                    .0
+                    .get(&node)
+                    .ok_or(ModelLevelEvaluabilityUnknown::InvalidElement)?
+                {
+                    MockNode::Leaf => Kind::Leaf,
+                    MockNode::Forbidden => Kind::Forbidden,
+                    MockNode::Reference { .. } => Kind::Reference,
+                    MockNode::Call(..) => Kind::Invocation,
+                    MockNode::Result(_) => Kind::General,
+                },
+            )
+        }
+        fn leaf(&mut self, _: Node, _: &mut Budget) -> Evidence<()> {
+            Ok(())
+        }
+        fn reference(&mut self, node: Node, _: &mut Budget) -> Evidence<ReferenceEvidence> {
+            let MockNode::Reference {
+                referent,
+                recursive,
+                metadata,
+                valuation,
+                unfeatured,
+            } = self.0[&node].clone()
+            else {
+                panic!()
+            };
+            Ok(ReferenceEvidence {
+                referent,
+                self_conformance: No,
+                expression: recursive,
+                metadata_owner: if metadata { Yes } else { No },
+                unfeatured,
+                valuation,
+            })
+        }
+        fn call(&mut self, node: Node, _: bool, _: &mut Budget) -> Evidence<CallEvidence> {
+            let MockNode::Call(arguments, function) = self.0[&node].clone() else {
+                panic!()
+            };
+            Ok(CallEvidence {
+                function,
+                arguments,
+            })
+        }
+        fn general(&mut self, node: Node, _: &mut Budget) -> Evidence<GeneralEvidence> {
+            let MockNode::Result(child) = self.0[&node] else {
+                panic!()
+            };
+            Ok(GeneralEvidence {
+                all_specializations_implied: Yes,
+                owned_features: Ok(vec![OwnedFeatureEvidence {
+                    input_or_result: No,
+                    no_owned_features: Yes,
+                    no_valuation: Yes,
+                    result_expression: Ok(Some(child)),
+                }]),
+            })
+        }
+    }
+    fn proof(nodes: impl IntoIterator<Item = (Node, MockNode)>) -> Proof<Mock> {
+        Proof::new(Mock(nodes.into_iter().collect()), 10000, 128)
+    }
+    fn reference(referent: Node, valuation: Evidence<Option<Node>>) -> MockNode {
+        MockNode::Reference {
+            referent,
+            recursive: false,
+            metadata: false,
+            valuation,
+            unfeatured: Yes,
+        }
+    }
+    #[test]
+    fn unknown_dependencies_do_not_become_vacuous_positive() {
+        assert_eq!(
+            proof([(
+                0,
+                reference(
+                    9,
+                    Err(ModelLevelEvaluabilityUnknown::MissingOrMalformedValuation)
+                )
+            )])
+            .report(0)
+            .classification,
+            Unknown(ModelLevelEvaluabilityUnknown::MissingOrMalformedValuation)
+        );
+        assert_eq!(
+            proof([(
+                0,
+                MockNode::Call(
+                    Err(ModelLevelEvaluabilityUnknown::IncompleteArgumentMapping),
+                    Yes
+                )
+            )])
+            .report(0)
+            .classification,
+            Unknown(ModelLevelEvaluabilityUnknown::IncompleteArgumentMapping)
+        );
+        assert_eq!(
+            proof([(
+                0,
+                MockNode::Call(
+                    Err(ModelLevelEvaluabilityUnknown::IncompleteArgumentMapping),
+                    No
+                )
+            )])
+            .report(0)
+            .classification,
+            No
+        );
+    }
+    #[test]
+    fn reference_alternatives_are_or_not_expression_else_if() {
+        let root = MockNode::Reference {
+            referent: 1,
+            recursive: true,
+            metadata: false,
+            valuation: Ok(None),
+            unfeatured: Yes,
+        };
+        assert_eq!(
+            proof([(0, root), (1, MockNode::Forbidden)])
+                .report(0)
+                .classification,
+            Yes
+        );
+    }
+    #[test]
+    fn sibling_references_share_no_path_local_visited_state() {
+        let report = proof([
+            (0, MockNode::Call(Ok(vec![1, 2]), Yes)),
+            (1, reference(9, Ok(Some(3)))),
+            (2, reference(9, Ok(Some(3)))),
+            (3, MockNode::Leaf),
+        ])
+        .report(0);
+        assert_eq!(report.classification, Yes);
+        assert_eq!(
+            proof([(0, reference(9, Ok(Some(0))))])
+                .report(0)
+                .classification,
+            No
+        );
+    }
+    #[test]
+    fn completed_cache_is_guarded_by_visited_referents() {
+        let mut proof = proof([(0, reference(9, Ok(None)))]);
+        proof.visited.insert(9, 1);
+        assert_eq!(proof.walk(0, 0), No);
+        proof.visited.remove(&9);
+        assert_eq!(proof.walk(0, 0), Yes);
+        proof.visited.insert(9, 1);
+        assert_eq!(proof.walk(0, 0), No);
+    }
+    #[test]
+    fn ownership_cycle_cannot_reuse_an_unrelated_cached_success() {
+        let mut proof = proof([(0, MockNode::Result(1)), (1, MockNode::Leaf)]);
+        assert_eq!(proof.walk(0, 0), Yes);
+        proof.active_owned.insert(1);
+        assert_eq!(
+            proof.walk(0, 0),
+            Unknown(ModelLevelEvaluabilityUnknown::CyclicOwnership)
+        );
+    }
+    #[test]
+    fn budget_checks_precede_cache_and_do_not_poison_retry() {
+        let mut proof = proof([(0, MockNode::Leaf)]);
+        assert_eq!(proof.walk(0, 0), Yes);
+        proof.budget.used = proof.budget.limit;
+        assert_eq!(
+            proof.walk(0, 0),
+            Unknown(ModelLevelEvaluabilityUnknown::WorkLimit)
+        );
+        proof.budget.used = 0;
+        assert_eq!(proof.walk(0, 0), Yes);
+        assert_eq!(
+            proof.walk(0, 129),
+            Unknown(ModelLevelEvaluabilityUnknown::DepthLimit)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/model_level_evaluability/adapter.rs b/crates/sysmlv2-model/src/json/model_level_evaluability/adapter.rs
new file mode 100644
index 0000000..d713c36
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/model_level_evaluability/adapter.rs
@@ -0,0 +1,1355 @@
+//! Repository adapter. Compatibility derived booleans and execution are untouched.
+#[cfg(test)]
+use super::super::structural_index::Carrier;
+use super::super::{
+    Builder, ElementRef, ResolvedModel,
+    type_relations::{RelationFact, TypeRelations},
+};
+use super::super::{semantic_ownership, structural_index::StoredStructure};
+use super::*;
+use crate::metaclass::conforms;
+use std::sync::Arc;
+use uuid::Uuid;
+/// Forward the report's remaining budget into readers bounded by MAX_STEPS.
+/// This preserves smaller private proof limits before the reader allocates.
+fn structural_read<T>(
+    budget: &mut Budget,
+    read: impl FnOnce(&mut usize) -> Option<T>,
+) -> Evidence<T> {
+    budget.charge(0)?;
+    let limit = budget.limit.min(crate::eval::MAX_STEPS);
+    let offset = crate::eval::MAX_STEPS - limit;
+    let mut steps = offset.saturating_add(budget.used);
+    let result = read(&mut steps);
+    budget.used = steps.saturating_sub(offset);
+    budget.charge(0)?;
+    if steps > crate::eval::MAX_STEPS {
+        return Err(WorkLimit);
+    }
+    result.ok_or(MissingOrMalformedMembership)
+}
+
+use ModelLevelEvaluabilityUnknown::*;
+
+impl ResolvedModel {
+    /// Classify the normative model-level eligibility rule using bounded,
+    /// checked relationship evidence. Unknown is never a compatibility fallback.
+    /// This is distinct from execution and its EvaluationReport: Evaluable
+    /// expressions can still fail with Unbound, DivisionByZero, etc. The query
+    /// does not certify complete model validity or required library ancestry.
+    ///
+    /// The first supported scope covers literal/null/metadata leaves, ordinary
+    /// kernel feature references, and directly provable general-expression
+    /// branches. Complete callee argument mapping, derived featuring/snapshot
+    /// contexts, and inherited input/result direction remain explicit Unknown.
+    /// The legacy `isModelLevelEvaluable` derived boolean is unchanged.
+    pub fn model_level_evaluability(
+        &mut self,
+        expression: ElementRef,
+    ) -> ModelLevelEvaluabilityReport {
+        self.model_level_evaluability_with_budget(expression, 0)
+    }
+    pub(in crate::json) fn model_level_evaluability_with_budget(
+        &mut self,
+        expression: ElementRef,
+        initial: usize,
+    ) -> ModelLevelEvaluabilityReport {
+        let mut proof = Proof::new(
+            RepositoryEvidence::new(self),
+            crate::eval::MAX_STEPS,
+            super::super::MAX_RESOLUTION_DEPTH,
+        );
+        proof.budget.used = initial;
+        proof.report(expression.0)
+    }
+}
+
+/// One complete identity/carrier index per query. No name-based membership or
+/// feature-value fallback is used; malformed graph entries remain visible.
+struct StoredGraph {
+    publication: crate::json::publication::Revision,
+    ids: Arc<crate::layered::IdMap<Uuid, usize>>,
+    structure: Arc<StoredStructure>,
+    ownership: Option<Arc<semantic_ownership::SemanticOwnership>>,
+}
+impl StoredGraph {
+    fn build(model: &mut ResolvedModel, budget: &mut Budget) -> Evidence<Self> {
+        let structure = structural_read(budget, |steps| {
+            StoredStructure::for_query(&mut model.b, steps)
+        })?;
+        if !structure.ids_unique {
+            return Err(InvalidElement);
+        }
+        // The shared getter installs this exact immutable UUID projection.
+        let ids = Arc::clone(model.b.id_index.as_ref().ok_or(InvalidElement)?);
+        let b = &model.b;
+        let (generic_from, generic_to) =
+            match (&model.b.implied, &b.semantic_ownership, b.implied_from) {
+                (None, None, None) => (b.elements.len(), b.elements.len()),
+                (Some(table), Some(view), Some(from))
+                    if table.from == from
+                        && from <= table.owned_results_from
+                        && table.owned_results_from <= b.elements.len()
+                        && view.matches_suffix(b) =>
+                {
+                    (from, table.owned_results_from)
+                }
+                _ => return Err(MissingOrMalformedMembership),
+            };
+        // Reuse the raw immutable topology. Validate the effective carrier
+        // certificate without allocating another whole-model carrier vector.
+        budget.charge(b.elements.len())?;
+        for (index, element) in b.elements.iter().enumerate() {
+            let carrier = if conforms(element.ty, "Relationship") {
+                structural_read(budget, |steps| {
+                    semantic_ownership::checked_relationship_carrier(b, &structure, index, steps)
+                })?
+            } else {
+                // Ordinary generated Features are children, never relationship
+                // carriers. Projection cannot repair malformed raw ownership.
+                if structure.carrier(b, index) != Some(None) {
+                    return Err(MissingOrMalformedMembership);
+                }
+                None
+            };
+            // The old generic prefix consists solely of childless relationships
+            // carried by authored rows. The newer owned-result tail has a
+            // different certified shape, so do not relax or apply this prefix
+            // certificate merely because both families share an ownership view.
+            if (generic_from..generic_to).contains(&index)
+                && (carrier.is_none_or(|owner| owner >= generic_from)
+                    || !conforms(element.ty, "Relationship")
+                    || element.owning_relationship.is_some()
+                    || !element.children.is_empty()
+                    || !element.owned_relationships.is_empty())
+            {
+                return Err(MissingOrMalformedMembership);
+            }
+        }
+        Ok(Self {
+            publication: b.publication.revision(),
+            ids,
+            structure,
+            ownership: b.semantic_ownership.clone(),
+        })
+    }
+    fn current(&self, b: &Builder) -> bool {
+        self.publication.same_as(&b.publication.revision())
+            && self.structure.is_current(b)
+            && match (&self.ownership, &b.semantic_ownership) {
+                (None, None) => true,
+                (Some(stored), Some(current)) => Arc::ptr_eq(stored, current),
+                _ => false,
+            }
+    }
+    fn relationships(
+        &self,
+        b: &Builder,
+        owner: usize,
+        budget: &mut Budget,
+    ) -> Evidence<Vec<usize>> {
+        if !self.current(b) {
+            return Err(MissingOrMalformedMembership);
+        }
+        b.elements.get(owner).ok_or(InvalidElement)?;
+        let relationships = semantic_ownership::owned_relationships(b, owner)
+            .ok_or(MissingOrMalformedMembership)?;
+        budget.charge(relationships.len())?;
+        for relationship in relationships.iter() {
+            if structural_read(budget, |steps| {
+                semantic_ownership::checked_relationship_carrier(
+                    b,
+                    &self.structure,
+                    relationship,
+                    steps,
+                )
+            })? != Some(owner)
+            {
+                return Err(MissingOrMalformedMembership);
+            }
+        }
+        Ok(relationships.iter().collect())
+    }
+    fn member(
+        &self,
+        b: &Builder,
+        owner: usize,
+        membership: usize,
+        budget: &mut Budget,
+    ) -> Evidence<usize> {
+        if !self.current(b) {
+            return Err(MissingOrMalformedMembership);
+        }
+        structural_read(budget, |steps| {
+            super::super::membership_evidence::member(b, &self.structure, owner, membership, steps)
+        })
+    }
+    fn features(
+        &self,
+        b: &Builder,
+        owner: usize,
+        budget: &mut Budget,
+    ) -> Evidence<Vec<(usize, usize)>> {
+        if !semantic_ownership::owned_feature_projection_complete(b, owner) {
+            return Err(UnsupportedExpression);
+        }
+        if !structural_read(budget, |steps| self.structure.membership_domains(b, steps))?
+            .owner_complete(owner)
+        {
+            return Err(MissingOrMalformedMembership);
+        }
+        let mut features = Vec::new();
+        for rel in self.relationships(b, owner, budget)? {
+            if !conforms(b.elements[rel].ty, "FeatureMembership") {
+                continue;
+            }
+            let feature = self.member(b, owner, rel, budget)?;
+            if !conforms(b.elements[feature].ty, "Feature") {
+                return Err(MissingOrMalformedMembership);
+            }
+            features.push((rel, feature));
+        }
+        Ok(features)
+    }
+    fn first_member(
+        &self,
+        b: &Builder,
+        owner: usize,
+        excluded_kind: &str,
+        kind: Option<&str>,
+        budget: &mut Budget,
+    ) -> Evidence<usize> {
+        for rel in self.relationships(b, owner, budget)? {
+            let ty = b.elements[rel].ty;
+            if conforms(ty, "Membership") && !conforms(ty, excluded_kind) {
+                let member = self.member(b, owner, rel, budget)?;
+                if kind.is_some_and(|kind| !conforms(b.elements[member].ty, kind)) {
+                    return Err(MissingOrMalformedMembership);
+                }
+                return Ok(member);
+            }
+        }
+        Err(MissingOrMalformedMembership)
+    }
+    fn valuation(
+        &self,
+        b: &Builder,
+        feature: usize,
+        budget: &mut Budget,
+    ) -> Evidence<Option<usize>> {
+        if !self.current(b) {
+            return Err(MissingOrMalformedValuation);
+        }
+        structural_read(budget, |steps| {
+            super::super::membership_evidence::valuation(b, &self.structure, feature, steps)
+                .map(|v| v.map(|(_, expression)| expression))
+        })
+        .map_err(|reason| {
+            if reason == WorkLimit {
+                reason
+            } else {
+                MissingOrMalformedValuation
+            }
+        })
+    }
+}
+struct RepositoryEvidence<'a> {
+    model: &'a mut ResolvedModel,
+    graph: Option<StoredGraph>,
+    relations: TypeRelations,
+    self_target: Option<Option<usize>>,
+}
+impl<'a> RepositoryEvidence<'a> {
+    fn new(model: &'a mut ResolvedModel) -> Self {
+        Self {
+            model,
+            graph: None,
+            relations: TypeRelations::default(),
+            self_target: None,
+        }
+    }
+    fn prepare(&mut self, budget: &mut Budget) -> Evidence<()> {
+        if let Some(graph) = &self.graph {
+            // Rebuilding only topology would retain stale TypeRelations/core
+            // memo facts. An interrupted proof must instead be retried fresh.
+            if !graph.current(&self.model.b) {
+                return Err(MissingOrMalformedMembership);
+            }
+        } else {
+            self.graph = Some(StoredGraph::build(self.model, budget)?);
+        }
+        budget.charge(1)
+    }
+    fn self_conformance(&mut self, referent: usize, budget: &mut Budget) -> ModelLevelEvaluability {
+        if self.self_target.is_none() {
+            if let Err(reason) = budget.charge(self.model.b.lib_qnames.len()) {
+                return Unknown(reason);
+            }
+            let mut target = None;
+            let mut ambiguous = false;
+            for (id, name) in &self.model.b.lib_qnames {
+                if name.as_slice() == ["Base", "Anything", "self"] {
+                    match self
+                        .graph
+                        .as_ref()
+                        .and_then(|graph| graph.ids.get(id))
+                        .copied()
+                    {
+                        Some(element)
+                            if element < self.model.b.lib_boundary
+                                && conforms(self.model.b.elements[element].ty, "Feature") =>
+                        {
+                            if target.is_some_and(|old| old != element) {
+                                ambiguous = true;
+                            }
+                            target = Some(element);
+                        }
+                        _ => ambiguous = true,
+                    }
+                }
+            }
+            self.self_target = Some(if ambiguous { None } else { target });
+        }
+        let Some(Some(target)) = self.self_target else {
+            return Unknown(IncompleteSelfConformance);
+        };
+        match structural_read(budget, |steps| {
+            Some(
+                self.relations
+                    .specializes(&mut self.model.b, referent, target, steps),
+            )
+        }) {
+            Ok(RelationFact::Yes) => Yes,
+            Ok(RelationFact::No) => No,
+            Ok(RelationFact::Unknown) => Unknown(IncompleteSelfConformance),
+            Err(reason) => Unknown(reason),
+        }
+    }
+}
+impl EvidenceProvider for RepositoryEvidence<'_> {
+    fn kind(&mut self, node: usize, budget: &mut Budget) -> Evidence<Kind> {
+        budget.charge(1)?;
+        let e = self.model.b.elements.get(node).ok_or(InvalidElement)?;
+        if !conforms(e.ty, "Expression") {
+            return Err(InvalidElement);
+        }
+        if conforms(e.ty, "CalculationUsage") || conforms(e.ty, "ConstraintUsage") {
+            return Ok(Kind::Forbidden);
+        }
+        if conforms(e.ty, "LiteralExpression")
+            || matches!(e.ty, "NullExpression" | "MetadataAccessExpression")
+        {
+            return Ok(Kind::Leaf);
+        }
+        if e.ty == "FeatureReferenceExpression" {
+            return Ok(Kind::Reference);
+        }
+        if conforms(e.ty, "ConstructorExpression") {
+            return Ok(Kind::Constructor);
+        }
+        if conforms(e.ty, "InvocationExpression") {
+            return Ok(Kind::Invocation);
+        }
+        if matches!(e.ty, "Expression" | "BooleanExpression") {
+            return Ok(Kind::General);
+        }
+        Err(UnsupportedExpression)
+    }
+    fn leaf(&mut self, node: usize, budget: &mut Budget) -> Evidence<()> {
+        if self.model.b.elements[node].ty == "MetadataAccessExpression" {
+            self.prepare(budget)?;
+            self.graph.as_ref().unwrap().first_member(
+                &self.model.b,
+                node,
+                "FeatureMembership",
+                None,
+                budget,
+            )?;
+        }
+        Ok(())
+    }
+    fn reference(&mut self, node: usize, budget: &mut Budget) -> Evidence<ReferenceEvidence> {
+        self.prepare(budget)?;
+        let referent = self.graph.as_ref().unwrap().first_member(
+            &self.model.b,
+            node,
+            "ParameterMembership",
+            Some("Feature"),
+            budget,
+        )?;
+        let self_conformance = self.self_conformance(referent, budget);
+        let metadata_owner = match structural_read(budget, |steps| {
+            self.relations
+                .owning_type(&mut self.model.b, referent, steps)
+        }) {
+            Ok(Some(owner))
+                if conforms(self.model.b.elements[owner].ty, "Metaclass")
+                    || conforms(self.model.b.elements[owner].ty, "MetadataFeature") =>
+            {
+                Yes
+            }
+            Ok(_) => No,
+            Err(reason) => Unknown(reason),
+        };
+        let unfeatured = match structural_read(budget, |steps| {
+            self.relations
+                .audited_featuring_domain(&mut self.model.b, &[referent], steps)
+        }) {
+            Ok(true) => match structural_read(budget, |steps| {
+                self.relations
+                    .featuring_types(&mut self.model.b, referent, steps)
+            }) {
+                Ok(types) if types.is_empty() => Yes,
+                Ok(_) => No,
+                Err(WorkLimit) => Unknown(WorkLimit),
+                Err(_) => Unknown(IncompleteFeaturing),
+            },
+            Err(WorkLimit) => Unknown(WorkLimit),
+            _ => Unknown(IncompleteFeaturing),
+        };
+        let valuation = self
+            .graph
+            .as_ref()
+            .unwrap()
+            .valuation(&self.model.b, referent, budget);
+        Ok(ReferenceEvidence {
+            referent,
+            self_conformance,
+            expression: conforms(self.model.b.elements[referent].ty, "Expression"),
+            metadata_owner,
+            unfeatured,
+            valuation,
+        })
+    }
+    fn call(
+        &mut self,
+        node: usize,
+        constructor: bool,
+        budget: &mut Budget,
+    ) -> Evidence<CallEvidence> {
+        let mut numeric_callee = None;
+        let supplied =
+            if constructor && self.model.b.graph_format == crate::model::GraphFormat::CanonicalV3 {
+                let mut issue = IncompleteArgumentMapping;
+                let mapping = structural_read(budget, |steps| {
+                    let report = self
+                        .model
+                        .constructor_binding_report_with_budget(ElementRef(node), *steps);
+                    *steps = report.steps;
+                    match report.arguments {
+                        Ok(arguments) => {
+                            Some(arguments.bindings.into_iter().map(|b| b.value.0).collect())
+                        }
+                        Err(super::super::ConstructorBindingIssue::InvalidRelationship) => {
+                            issue = MissingOrMalformedValuation;
+                            None
+                        }
+                        Err(_) => None,
+                    }
+                })
+                .map_err(|reason| if reason == WorkLimit { reason } else { issue });
+                Some(mapping)
+            } else if !constructor
+                && self
+                    .model
+                    .b
+                    .elements
+                    .get(node)
+                    .is_some_and(|e| matches!(e.ty, "InvocationExpression" | "OperatorExpression"))
+            {
+                let mut issue = IncompleteArgumentMapping;
+                let mapping = structural_read(budget, |steps| {
+                    let report = self
+                        .model
+                        .invocation_binding_report_with_budget(ElementRef(node), *steps);
+                    *steps = report.steps;
+                    match report.arguments {
+                        Ok(arguments) => {
+                            if self.model.b.elements[node].ty == "OperatorExpression" {
+                                numeric_callee = Some(arguments.callee);
+                            }
+                            Some(arguments.bindings.into_iter().map(|b| b.value.0).collect())
+                        }
+                        Err(super::super::InvocationBindingIssue::InvalidRelationship) => {
+                            issue = MissingOrMalformedValuation;
+                            None
+                        }
+                        Err(_) => None,
+                    }
+                })
+                .map_err(|reason| if reason == WorkLimit { reason } else { issue });
+                Some(mapping)
+            } else {
+                None
+            };
+        self.prepare(budget)?;
+        // Operator/trigger overrides need a unique designated-name resolver;
+        // the older ordered compatibility lookup is not complete evidence.
+        if (conforms(self.model.b.elements[node].ty, "OperatorExpression")
+            && numeric_callee.is_none())
+            || self.model.b.elements[node].ty == "TriggerInvocationExpression"
+        {
+            return Err(IncompleteCallee);
+        }
+        if numeric_callee.is_none() {
+            self.graph
+                .as_ref()
+                .unwrap()
+                .first_member(
+                    &self.model.b,
+                    node,
+                    "FeatureMembership",
+                    Some(if constructor { "Type" } else { "Function" }),
+                    budget,
+                )
+                .map_err(|reason| {
+                    if reason == WorkLimit {
+                        reason
+                    } else {
+                        IncompleteCallee
+                    }
+                })?;
+        }
+        // InstantiatedType membership is not Expression.function evidence.
+        // The latter redefines Step.behavior and follows the effective Feature
+        // typing graph. Missing required invocation typing, inherited types,
+        // or conflicting explicit typing must not turn a user callee into a
+        // decisive negative. The constructor rule has no function conjunct.
+        let function = if constructor {
+            Yes
+        } else if let Some(callee) = numeric_callee {
+            budget.charge(self.model.b.elements.len())?;
+            if self
+                .model
+                .function_is_model_level_evaluable(&super::super::Reference::Element(callee))
+            {
+                Yes
+            } else {
+                Unknown(IncompleteCallee)
+            }
+        } else {
+            Unknown(IncompleteCallee)
+        };
+        // Inspect every owned parameter value before the mapping boundary;
+        // neither excess arguments nor absent FeatureValue members disappear.
+        // Complete call mapping remains a shared-provider prerequisite: no
+        // private positional fallback or execution-only mapper is introduced.
+        let graph = self.graph.as_ref().unwrap();
+        let mut arguments = supplied.unwrap_or(Err(IncompleteArgumentMapping));
+        for (membership, parameter) in graph.features(&self.model.b, node, budget)? {
+            if !conforms(self.model.b.elements[membership].ty, "ParameterMembership")
+                || conforms(
+                    self.model.b.elements[membership].ty,
+                    "ReturnParameterMembership",
+                )
+            {
+                continue;
+            }
+            if let Err(reason) = graph
+                .valuation(&self.model.b, parameter, budget)
+                .and_then(|value| value.ok_or(MissingOrMalformedValuation))
+            {
+                arguments = Err(reason);
+                break;
+            }
+        }
+        Ok(CallEvidence {
+            function,
+            arguments,
+        })
+    }
+    fn general(&mut self, node: usize, budget: &mut Budget) -> Evidence<GeneralEvidence> {
+        self.prepare(budget)?;
+        let graph = self.graph.as_ref().unwrap();
+        let mut all_implied = Yes;
+        for rel in graph.relationships(&self.model.b, node, budget)? {
+            let relation = &self.model.b.elements[rel];
+            if !conforms(relation.ty, "Specialization") {
+                continue;
+            }
+            let implied = match relation.props.get("isImplied") {
+                None => No,
+                Some(value) => match value.as_bool() {
+                    Some(true) => Yes,
+                    Some(false) => No,
+                    None => Unknown(UnsupportedExpression),
+                },
+            };
+            all_implied = and(all_implied, implied);
+        }
+        if all_implied == No {
+            return Ok(GeneralEvidence {
+                all_specializations_implied: No,
+                owned_features: Ok(Vec::new()),
+            });
+        }
+        let source = graph.features(&self.model.b, node, budget)?;
+        let returns = source
+            .iter()
+            .filter(|(membership, _)| {
+                conforms(
+                    self.model.b.elements[*membership].ty,
+                    "ReturnParameterMembership",
+                )
+            })
+            .count();
+        let mut features = Vec::new();
+        for (membership, feature) in source {
+            // directionOf uses the stored direction when this Feature is
+            // reciprocally owned by the receiver, before inherited conjugation.
+            let owned_input = structural_read(budget, |steps| {
+                super::super::membership_evidence::parameter_direction(
+                    &self.model.b,
+                    &graph.structure,
+                    feature,
+                    steps,
+                )
+            });
+            let owned_input = match owned_input {
+                Ok(direction) => direction == Some("in"),
+                Err(WorkLimit) => return Err(WorkLimit),
+                Err(_) => false,
+            };
+            let input_or_result = if owned_input
+                || (returns == 1
+                    && conforms(
+                        self.model.b.elements[membership].ty,
+                        "ReturnParameterMembership",
+                    )) {
+                Yes
+            } else {
+                Unknown(UnsupportedDirectionOrResult)
+            };
+            let no_owned_features = match graph.features(&self.model.b, feature, budget) {
+                Ok(features) if features.is_empty() => Yes,
+                Ok(_) => No,
+                Err(reason) => Unknown(reason),
+            };
+            let no_valuation = match graph.valuation(&self.model.b, feature, budget) {
+                Ok(None) => Yes,
+                Ok(Some(_)) => No,
+                Err(reason) => Unknown(reason),
+            };
+            let result_expression = if conforms(
+                self.model.b.elements[membership].ty,
+                "ResultExpressionMembership",
+            ) {
+                if conforms(self.model.b.elements[feature].ty, "Expression") {
+                    Ok(Some(feature))
+                } else {
+                    Err(MissingOrMalformedMembership)
+                }
+            } else {
+                Ok(None)
+            };
+            features.push(OwnedFeatureEvidence {
+                input_or_result,
+                no_owned_features,
+                no_valuation,
+                result_expression,
+            });
+        }
+        Ok(GeneralEvidence {
+            all_specializations_implied: all_implied,
+            owned_features: Ok(features),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+    fn fixture() -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_library_source(
+            "functions.kerml",
+            "package DataFunctions {function '+' {in a; in b; return result;}}",
+        );
+        model.add_source(
+            "proof.kerml",
+            "feature target=1; feature read=target; feature call=DataFunctions::'+'(1,2);",
+        );
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+    fn value(r: &mut ResolvedModel, feature: &str) -> (usize, usize, usize) {
+        let owner = r.resolve_qualified(feature).unwrap().0;
+        let rel = r.b.elements[owner]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "FeatureValue"))
+            .unwrap();
+        (owner, rel, r.b.elements[rel].children[0])
+    }
+    #[test]
+    fn owned_general_inputs_use_exact_in_direction_and_complete_valuations() {
+        for (declaration, expected) in [
+            ("in a;", Yes),
+            ("inout a;", Unknown(UnsupportedDirectionOrResult)),
+            ("out a;", Unknown(UnsupportedDirectionOrResult)),
+            ("in a=1;", No),
+            ("in a {feature nested;}", No),
+        ] {
+            let mut m = Model::new();
+            let parsed = m.add_source(
+                "general.kerml",
+                &format!("expr e {{{declaration} return r;}}"),
+            );
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            let mut r = ResolvedModel::build(&m);
+            let e = r.resolve_qualified("e").unwrap();
+            assert_eq!(
+                r.model_level_evaluability(e).classification,
+                expected,
+                "{declaration}"
+            );
+        }
+        for key in ["direction", "owningType", "owningFeatureMembership"] {
+            let mut m = Model::new();
+            m.add_source("general.kerml", "expr e {in a; return r;}");
+            let mut r = ResolvedModel::build(&m);
+            let e = r.resolve_qualified("e").unwrap();
+            let a = r.resolve_qualified("e::a").unwrap().0;
+            let membership = r.b.elements[a].owning_relationship.unwrap();
+            let row = if key == "owningType" { membership } else { a };
+            r.b.elements[row].props.insert(key, serde_json::Value::Null);
+            assert!(
+                matches!(r.model_level_evaluability(e).classification, Unknown(_)),
+                "{key}"
+            );
+        }
+    }
+    #[test]
+    fn checked_arguments_can_prove_negative_without_inventing_function_eligibility() {
+        let mut m = Model::new();
+        m.add_library_source("library.kerml", "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}");
+        m.add_source(
+            "named.kerml",
+            "function F {in a; return r;} feature call=F(a=1);",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let (_, _, call) = value(&mut r, "call");
+        let call = ElementRef(call);
+        let binding = r
+            .invocation_binding_report(call)
+            .arguments
+            .unwrap()
+            .bindings
+            .remove(0);
+        assert!(matches!(
+            r.model_level_evaluability(call).classification,
+            Unknown(_)
+        ));
+        r.b.elements[binding.value.0].ty = "CalculationUsage";
+        assert_eq!(r.model_level_evaluability(call).classification, No);
+    }
+    #[test]
+    fn instantiated_user_function_does_not_certify_expression_function() {
+        for conflicting_typing in [false, true] {
+            let mut model = Model::new();
+            model.add_library_source(
+                "functions.kerml",
+                "package DataFunctions {function '+' {in a; in b; return result;}}",
+            );
+            model.add_source(
+                "proof.kerml",
+                "function User {return result;} feature call=User();",
+            );
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let (_, _, call) = value(&mut r, "call");
+            if conflicting_typing {
+                let target = r.resolve_qualified("DataFunctions::'+'").unwrap().0;
+                let relation =
+                    r.b.new_relationship("FeatureTyping", call, "different-function");
+                let source_id = r.b.elements[call].id;
+                let target_id = r.b.elements[target].id;
+                r.b.set(
+                    relation,
+                    "typedFeature",
+                    super::super::super::id_ref(source_id),
+                );
+                r.b.set(relation, "type", super::super::super::id_ref(target_id));
+            }
+            assert!(matches!(
+                r.model_level_evaluability(ElementRef(call)).classification,
+                Unknown(_)
+            ));
+        }
+    }
+
+    #[test]
+    fn missing_valuation_child_cannot_become_an_absent_valuation() {
+        let mut r = fixture();
+        let (_, _, read) = value(&mut r, "read");
+        let (_, rel, _) = value(&mut r, "target");
+        r.b.elements[rel].children.make_mut().clear();
+        assert!(matches!(
+            r.model_level_evaluability(ElementRef(read)).classification,
+            Unknown(_)
+        ));
+    }
+    #[test]
+    fn contradictory_valuation_target_and_duplicate_values_are_unknown() {
+        for duplicate in [false, true] {
+            let mut r = fixture();
+            let (_, _, read) = value(&mut r, "read");
+            let (owner, rel, _) = value(&mut r, "target");
+            if duplicate {
+                r.b.new_relationship("FeatureValue", owner, "extra");
+            } else {
+                let wrong = r.b.elements[owner].id;
+                r.b.set(
+                    rel,
+                    "ownedMemberElement",
+                    super::super::super::id_ref(wrong),
+                );
+            }
+            assert!(matches!(
+                r.model_level_evaluability(ElementRef(read)).classification,
+                Unknown(_)
+            ));
+        }
+    }
+    #[test]
+    fn broken_argument_member_remains_visible_as_unknown() {
+        let mut r = fixture();
+        let (_, _, call) = value(&mut r, "call");
+        let parameter = r.b.elements[call]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| r.b.elements[rel].ty == "ParameterMembership")
+            .map(|rel| r.b.elements[rel].children[0])
+            .unwrap();
+        let valuation = r.b.elements[parameter]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "FeatureValue"))
+            .unwrap();
+        r.b.elements[valuation].children.make_mut().clear();
+        assert!(matches!(
+            r.model_level_evaluability(ElementRef(call)).classification,
+            Unknown(_)
+        ));
+    }
+    #[test]
+    fn contradictory_generic_relationship_arrays_cannot_hide_behind_named_slots() {
+        for key in ["source", "target", "ownedRelatedElement", "relatedElement"] {
+            let mut r = fixture();
+            let (_, _, read) = value(&mut r, "read");
+            let (_, valuation, _) = value(&mut r, "target");
+            let wrong = r.b.elements[read].id;
+            r.b.elements[valuation]
+                .props
+                .insert(key, serde_json::json!([{"@id":wrong.to_string()}]));
+            assert!(
+                matches!(
+                    r.model_level_evaluability(ElementRef(read)).classification,
+                    Unknown(_)
+                ),
+                "{key}"
+            );
+        }
+    }
+
+    #[test]
+    fn foreign_stored_carrier_cannot_prove_an_unfeatured_reference() {
+        let mut r = fixture();
+        let (_, _, read) = value(&mut r, "read");
+        let target = r.resolve_qualified("target").unwrap().0;
+        let membership = r.b.elements[target].owning_relationship.unwrap();
+        let wrong = r.b.elements[read].id;
+        r.b.set(
+            membership,
+            "owningRelatedElement",
+            super::super::super::id_ref(wrong),
+        );
+        assert!(matches!(
+            r.model_level_evaluability(ElementRef(read)).classification,
+            Unknown(_)
+        ));
+    }
+    #[test]
+    fn trusted_implied_carriers_validate_present_aliases_without_authored_flag_exemptions() {
+        let mut model = Model::new();
+        model.add_library_source("bases.kerml",
+            "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+        model.add_source(
+            "source.kerml",
+            "class A; feature target=1; feature read=target;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap();
+        let generated = r.implied_relationships(a)[0];
+        let owner_id = r.element_id(a);
+        r.b.elements[generated.0].props.insert(
+            "owningRelatedElement",
+            super::super::super::id_ref(owner_id),
+        );
+        let mut budget = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        let graph = StoredGraph::build(&mut r, &mut budget).unwrap();
+        assert!(graph.current(&r.b));
+        assert_eq!(
+            graph.structure.raw_carrier(&r.b, generated.0),
+            Some(Carrier::Missing)
+        );
+        let (_, _, read) = value(&mut r, "read");
+        assert_eq!(
+            r.model_level_evaluability(ElementRef(read)).classification,
+            Yes
+        );
+        let wrong = r.b.elements[read].id;
+        r.b.elements[generated.0]
+            .props
+            .insert("owningRelatedElement", super::super::super::id_ref(wrong));
+        assert!(
+            StoredGraph::build(
+                &mut r,
+                &mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                }
+            )
+            .is_err()
+        );
+        r.b.elements[generated.0].props.insert(
+            "owningRelatedElement",
+            super::super::super::id_ref(owner_id),
+        );
+        let (_, valuation, _) = value(&mut r, "target");
+        r.b.elements[valuation]
+            .props
+            .insert("isImplied", serde_json::json!(true));
+        r.b.elements[valuation]
+            .props
+            .insert("owningRelatedElement", super::super::super::id_ref(wrong));
+        assert!(matches!(
+            r.model_level_evaluability(ElementRef(read)).classification,
+            Unknown(_)
+        ));
+    }
+    #[test]
+    fn relation_readers_obey_the_report_remaining_budget_and_retry_fresh() {
+        let mut r = fixture();
+        let feature = r.resolve_qualified("target").unwrap().0;
+        let mut relations = TypeRelations::default();
+        let mut empty = Budget { used: 0, limit: 0 };
+        assert_eq!(
+            structural_read(&mut empty, |steps| relations
+                .owning_type(&mut r.b, feature, steps)),
+            Err(WorkLimit)
+        );
+        let mut fresh = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        assert_eq!(
+            structural_read(&mut fresh, |steps| relations
+                .owning_type(&mut r.b, feature, steps)),
+            Ok(None)
+        );
+        let mut empty_again = Budget { used: 0, limit: 0 };
+        assert_eq!(
+            structural_read(&mut empty_again, |steps| Some(
+                relations.specializes(&mut r.b, feature, feature, steps)
+            )),
+            Err(WorkLimit)
+        );
+        let mut fresh_again = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        assert_eq!(
+            structural_read(&mut fresh_again, |steps| Some(
+                relations.specializes(&mut r.b, feature, feature, steps)
+            )),
+            Ok(RelationFact::Yes)
+        );
+    }
+    #[test]
+    fn reports_share_raw_identity_and_carrier_index_without_duplicate_allocations() {
+        let mut r = fixture();
+        let mut budget = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        let first = StoredGraph::build(&mut r, &mut budget).unwrap();
+        let second = StoredGraph::build(
+            &mut r,
+            &mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            },
+        )
+        .unwrap();
+        assert!(Arc::ptr_eq(&first.ids, &second.ids));
+        assert!(Arc::ptr_eq(&first.structure, &second.structure));
+        assert!(Arc::ptr_eq(&first.ids, r.b.id_index.as_ref().unwrap()));
+        assert!(first.current(&r.b));
+    }
+    #[test]
+    fn same_length_row_mutation_refuses_the_old_proof_and_fresh_query_retries() {
+        let mut r = fixture();
+        let (_, valuation, _) = value(&mut r, "target");
+        let owner = r.resolve_qualified("target").unwrap().0;
+        let mut proof = RepositoryEvidence::new(&mut r);
+        proof
+            .prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            })
+            .unwrap();
+        let original = proof.model.b.elements[valuation].props.clone();
+        proof.model.b.elements[valuation]
+            .props
+            .insert("isImplied", serde_json::json!(false));
+        assert_eq!(
+            proof.prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS
+            }),
+            Err(MissingOrMalformedMembership)
+        );
+        assert_eq!(
+            proof.graph.as_ref().unwrap().relationships(
+                &proof.model.b,
+                owner,
+                &mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                }
+            ),
+            Err(MissingOrMalformedMembership)
+        );
+        proof.model.b.elements[valuation].props = original;
+        assert_eq!(
+            proof.prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS
+            }),
+            Err(MissingOrMalformedMembership)
+        );
+        drop(proof);
+        let mut fresh = RepositoryEvidence::new(&mut r);
+        assert!(
+            fresh
+                .prepare(&mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                })
+                .is_ok()
+        );
+    }
+    #[test]
+    fn shared_graph_respects_cold_warm_small_budget_and_fresh_retry() {
+        let mut r = fixture();
+        r.b.stored_structure = None;
+        r.b.id_index = None;
+        assert!(matches!(
+            StoredGraph::build(&mut r, &mut Budget { used: 0, limit: 0 }),
+            Err(WorkLimit)
+        ));
+        assert!(r.b.stored_structure.is_none());
+        let good = StoredGraph::build(
+            &mut r,
+            &mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            },
+        )
+        .unwrap();
+        assert!(matches!(
+            StoredGraph::build(&mut r, &mut Budget { used: 0, limit: 1 }),
+            Err(WorkLimit)
+        ));
+        let retry = StoredGraph::build(
+            &mut r,
+            &mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            },
+        )
+        .unwrap();
+        assert!(Arc::ptr_eq(&good.structure, &retry.structure));
+    }
+    #[test]
+    fn mid_report_generic_materialization_requires_fresh_query() {
+        let mut model = Model::new();
+        model.add_library_source("bases.kerml","standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+        model.add_source(
+            "query.kerml",
+            "class A; feature target=1; feature read=target;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap();
+        let mut proof = RepositoryEvidence::new(&mut r);
+        proof
+            .prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            })
+            .unwrap();
+        assert!(!proof.model.implied_relationships(a).is_empty());
+        assert_eq!(
+            proof.prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS
+            }),
+            Err(MissingOrMalformedMembership)
+        );
+        drop(proof);
+        assert!(
+            StoredGraph::build(
+                &mut r,
+                &mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                }
+            )
+            .is_ok()
+        );
+    }
+
+    #[test]
+    fn generated_result_carriers_and_members_share_the_semantic_view() {
+        let mut r = fixture();
+        let (_, _, expression) = value(&mut r, "read");
+        r.ensure_implied();
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expression)
+                .unwrap();
+        let mut budget = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        let graph = StoredGraph::build(&mut r, &mut budget).unwrap();
+        let rows = graph.relationships(&r.b, expression, &mut budget).unwrap();
+        assert_eq!(
+            rows.iter().filter(|&&row| row == result.membership).count(),
+            1
+        );
+        let bindings: Vec<_> = rows
+            .iter()
+            .copied()
+            .filter(|&row| r.b.elements[row].ty == "OwningMembership")
+            .collect();
+        assert_eq!(bindings.len(), 1);
+        let binding = graph
+            .member(&r.b, expression, bindings[0], &mut budget)
+            .unwrap();
+        assert_eq!(r.b.elements[binding].ty, "BindingConnector");
+        assert_eq!(
+            graph.member(&r.b, expression, result.membership, &mut budget),
+            Ok(result.feature)
+        );
+        assert_eq!(
+            graph.features(&r.b, expression, &mut budget),
+            Err(UnsupportedExpression),
+            "local result/binding does not certify complete connector ancestry or featuring"
+        );
+        assert!(
+            graph
+                .features(&r.b, result.feature, &mut budget)
+                .unwrap()
+                .is_empty()
+        );
+        r.b.elements[result.membership].owning_relationship = Some(result.membership);
+        assert!(
+            StoredGraph::build(&mut r, &mut budget).is_err(),
+            "a generated relationship cannot acquire contradictory child ownership"
+        );
+    }
+
+    #[test]
+    fn small_adapter_budget_does_not_poison_a_fresh_query() {
+        let mut r = fixture();
+        r.ensure_implied();
+        let mut exhausted = Budget { used: 0, limit: 1 };
+        assert!(matches!(
+            StoredGraph::build(&mut r, &mut exhausted),
+            Err(WorkLimit)
+        ));
+        assert!(exhausted.used > exhausted.limit);
+        let mut fresh = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        assert!(StoredGraph::build(&mut r, &mut fresh).is_ok());
+        let mut warm_tiny = Budget { used: 0, limit: 1 };
+        assert!(matches!(
+            StoredGraph::build(&mut r, &mut warm_tiny),
+            Err(WorkLimit)
+        ));
+    }
+
+    #[test]
+    fn authored_carrier_failure_is_not_repaired_by_the_generated_view() {
+        let mut r = fixture();
+        let (_, _, expression) = value(&mut r, "read");
+        r.ensure_implied();
+        let authored = r.b.elements[expression].owned_relationships[0];
+        let wrong = r.b.elements[expression].id;
+        // It is already carried by the expression. A contradictory generic
+        // source alias is checked by member(), never overwritten by projection.
+        let member =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expression)
+                .unwrap()
+                .feature;
+        let wrong_owner = r.b.elements[member].id;
+        r.b.elements[authored].props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":wrong_owner.to_string()}),
+        );
+        r.b.elements[authored]
+            .props
+            .insert("isImplied", serde_json::json!(true));
+        assert!(
+            StoredGraph::build(
+                &mut r,
+                &mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                }
+            )
+            .is_err()
+        );
+        r.b.elements[authored].props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":wrong.to_string()}),
+        );
+        assert!(
+            StoredGraph::build(
+                &mut r,
+                &mut Budget {
+                    used: 0,
+                    limit: crate::eval::MAX_STEPS
+                }
+            )
+            .is_ok()
+        );
+    }
+
+    #[test]
+    fn replacing_a_result_tail_invalidates_query_local_carrier_evidence() {
+        let mut r = fixture();
+        let (_, _, expression) = value(&mut r, "read");
+        r.ensure_implied();
+        let mut budget = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        let old = StoredGraph::build(&mut r, &mut budget).unwrap();
+        r.discard_owned_result_tail();
+        r.ensure_implied();
+        assert!(!old.current(&r.b));
+        assert_eq!(
+            old.relationships(&r.b, expression, &mut budget),
+            Err(MissingOrMalformedMembership)
+        );
+        let fresh = StoredGraph::build(&mut r, &mut budget).unwrap();
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expression)
+                .unwrap();
+        assert_eq!(
+            fresh.member(&r.b, expression, result.membership, &mut budget),
+            Ok(result.feature)
+        );
+    }
+
+    #[test]
+    fn repository_evidence_refuses_mid_report_publication_instead_of_reusing_proofs() {
+        let mut r = fixture();
+        let mut provider = RepositoryEvidence::new(&mut r);
+        let mut budget = Budget {
+            used: 0,
+            limit: crate::eval::MAX_STEPS,
+        };
+        provider.prepare(&mut budget).unwrap();
+        provider.model.ensure_implied();
+        assert_eq!(
+            provider.prepare(&mut budget),
+            Err(MissingOrMalformedMembership)
+        );
+        // A new report gets a new graph and all new relation memos.
+        let mut fresh = RepositoryEvidence::new(provider.model);
+        fresh
+            .prepare(&mut Budget {
+                used: 0,
+                limit: crate::eval::MAX_STEPS,
+            })
+            .unwrap();
+    }
+    #[test]
+    fn generic_prefix_cannot_acquire_owned_children_or_nested_rows() {
+        for child_array in [true, false] {
+            let mut model = Model::new();
+            model.add_library_source("generic.kerml", "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+            model.add_source(
+                "source.kerml",
+                "class A; class B specializes A; feature target=1; feature read=target;",
+            );
+            let mut r = ResolvedModel::build(&model);
+            let a = r.resolve_qualified("A").unwrap();
+            let generated = r.implied_relationships(a)[0];
+            if child_array {
+                r.b.elements[generated.0].children.push(a.0);
+            } else {
+                // Relocate an authored relationship consistently: the raw
+                // carrier remains unique and agrees with its scalar alias.
+                // Only the generic parent's childless-shape proof rejects it.
+                let b = r.resolve_qualified("B").unwrap().0;
+                let nested = r.b.elements[b]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| conforms(r.b.elements[rel].ty, "Subclassification"))
+                    .unwrap();
+                r.b.elements[b]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&rel| rel != nested);
+                r.b.elements[generated.0].owned_relationships.push(nested);
+                let owner_id = r.b.elements[generated.0].id;
+                r.b.elements[nested].props.insert(
+                    "owningRelatedElement",
+                    serde_json::json!({"@id": owner_id.to_string()}),
+                );
+                let mut steps = 0;
+                let raw = StoredStructure::for_query(&mut r.b, &mut steps).unwrap();
+                assert_eq!(raw.carrier(&r.b, nested), Some(Some(generated.0)));
+                assert_eq!(
+                    semantic_ownership::checked_relationship_carrier(
+                        &r.b, &raw, nested, &mut steps
+                    ),
+                    Some(Some(generated.0))
+                );
+            }
+            assert!(matches!(
+                StoredGraph::build(
+                    &mut r,
+                    &mut Budget {
+                        used: 0,
+                        limit: crate::eval::MAX_STEPS
+                    }
+                ),
+                Err(MissingOrMalformedMembership)
+            ));
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/named_argument_index_tests.rs b/crates/sysmlv2-model/src/json/named_argument_index_tests.rs
new file mode 100644
index 0000000..fb3aa66
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/named_argument_index_tests.rs
@@ -0,0 +1,249 @@
+//! Named argument redefinitions retain callee-context identity across replay.
+use super::{ElementRef, ResolvedModel};
+use crate::{libcache::LibraryCache, model::Model, prepared::PreparedLibrary};
+use std::{collections::HashMap, sync::Arc};
+use uuid::Uuid;
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("arguments-library.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("arguments-library.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(
+                model
+                    .add_source("arguments-user.kerml", user)
+                    .diagnostics
+                    .is_empty()
+            );
+            ResolvedModel::build(&model)
+        })
+        .collect()
+}
+fn argument(r: &mut ResolvedModel, name: &str) -> usize {
+    let owner = r.resolve_qualified(name).unwrap().0;
+    let value = r.b.elements[owner]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&r0| r.b.elements[r0].ty == "FeatureValue")
+        .unwrap();
+    let expression = r.b.elements[value].children[0];
+    let membership = r.b.elements[expression]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&r0| r.b.elements[r0].ty == "ParameterMembership")
+        .unwrap();
+    r.b.elements[membership].children[0]
+}
+fn assert_target(r: &mut ResolvedModel, argument: usize, target: Option<usize>) {
+    let recorded: Vec<_> =
+        r.b.spec_targets
+            .iter()
+            .enumerate()
+            .filter(|(_, entry)| entry.0 == argument && entry.1 == "Redefinition")
+            .map(|(index, _)| index)
+            .collect();
+    assert_eq!(recorded.len(), 1);
+    assert!(
+        r.b.spec_resolved.get(recorded[0]).is_some(),
+        "even a cached miss records an explicit outcome"
+    );
+    let expected: Vec<_> = target.into_iter().collect();
+    assert_eq!(r.b.indexed_redefinition_targets(argument), expected);
+    assert_eq!(r.b.redefinition_target_elems(argument), expected);
+    assert_eq!(
+        r.b.explicit_specialization_elems(argument),
+        expected
+            .iter()
+            .map(|&e| ("Redefinition", e))
+            .collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn named_argument_targets_keep_callee_context_through_replay_and_id_changes() {
+    let library = "package Functions {function F {in x; return r;} feature sample=F(x=1); feature x; feature missing=Missing(x=2);}";
+    let user = "function F {in x; return r;} alias invoke for F; feature byName=F(x=1); feature byAlias=invoke(x=2); class Point {feature x;} feature constructed=new Point(x=3); class Holder {feature fnMember:F;} feature h:Holder; feature chained=h.fnMember(x=4); feature x; feature missing=Missing(x=5); feature z; feature wrong=F(z=6); feature forward=late.fnMember(x=7); class Later {feature fnMember:F;} feature late:Later;";
+    for mut r in models(library, user) {
+        let f_x = r.resolve_qualified("F::x").unwrap().0;
+        let point_x = r.resolve_qualified("Point::x").unwrap().0;
+        let lib_x = r.resolve_qualified("Functions::F::x").unwrap().0;
+        for (name, expected) in [
+            ("byName", Some(f_x)),
+            ("byAlias", Some(f_x)),
+            ("chained", Some(f_x)),
+            ("forward", Some(f_x)),
+            ("constructed", Some(point_x)),
+            ("Functions::sample", Some(lib_x)),
+            ("missing", None),
+            ("wrong", None),
+            ("Functions::missing", None),
+        ] {
+            let parameter = argument(&mut r, name);
+            assert_target(&mut r, parameter, expected);
+        }
+        // Fixed identities for arguments-user.kerml: specialization indexing
+        // must preserve the argument subtree identities.
+        for (name, parameter_id, membership_id, literal_id) in [
+            (
+                "byName",
+                "19f667c2-50d4-5a3d-9fa8-0cb9c0869a00",
+                "1c34a7a0-3e12-50cc-af2c-cfced1081b58",
+                "f8b4a5e5-5ddb-557a-8d86-aaccb7980448",
+            ),
+            (
+                "byAlias",
+                "3f059e88-8e71-5720-b68f-f7c49ec73c9c",
+                "c7fb9497-9683-5dd0-885f-16fe34d1e519",
+                "5ff653a0-e0ab-5fbe-adc8-ea9d87e8807c",
+            ),
+            (
+                "constructed",
+                "b935e88c-28ec-50a6-9b98-0d1ea858abf5",
+                "e2c650c1-e361-54d3-96f7-0c4a4a02abc1",
+                "bb69e901-31af-5470-a9da-ea74d48f5d10",
+            ),
+            (
+                "chained",
+                "743949fb-acc8-5d50-9b20-5534dd82a62a",
+                "7f4618ac-2696-5ccd-8aa7-a3fc5dbefd85",
+                "b2c8557a-0391-538d-b00c-86592aec62f7",
+            ),
+            (
+                "missing",
+                "d95d365e-3029-5b1b-bdf4-915364f0a177",
+                "8264348b-cbce-5728-b8e0-6303a5ea5ac9",
+                "6a8b52c0-2825-5ce0-ac80-24493c3dea43",
+            ),
+            (
+                "wrong",
+                "2ea929c2-e8ac-5c2f-8710-23e31fbe7c4d",
+                "11fbe8a7-26ab-5bd8-9380-8440d1b2bbc3",
+                "b6eb3a88-402a-5b37-a4fa-b1766fce5f52",
+            ),
+        ] {
+            let parameter = argument(&mut r, name);
+            let membership = r.b.elements[parameter].owning_relationship.unwrap();
+            let value = r.b.elements[parameter]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&rel| r.b.elements[rel].ty == "FeatureValue")
+                .unwrap();
+            let literal = r.b.elements[value].children[0];
+            assert_eq!(
+                r.b.elements[parameter].id.to_string(),
+                parameter_id,
+                "{name}"
+            );
+            assert_eq!(
+                r.b.elements[membership].id.to_string(),
+                membership_id,
+                "{name}"
+            );
+            assert_eq!(r.b.elements[literal].id.to_string(), literal_id, "{name}");
+        }
+        let parameter = argument(&mut r, "byName");
+        r.override_ids(&HashMap::from([(
+            r.element_id(ElementRef(f_x)),
+            Uuid::new_v4(),
+        )]));
+        assert_target(&mut r, parameter, Some(f_x));
+    }
+}
+
+#[test]
+fn ambiguous_callee_parameter_does_not_bind_a_lexical_namesake() {
+    for mut r in models(
+        "package L;",
+        "function F {in x; in x; return r;} feature x; feature call=F(x=1);",
+    ) {
+        let parameter = argument(&mut r, "call");
+        assert_target(&mut r, parameter, None);
+    }
+}
+
+#[test]
+fn declaration_header_missing_outcome_cannot_capture_a_foreign_lexical_namesake() {
+    for mut r in models(
+        "package L;",
+        "class A {feature x;} class C {feature y redefines x;} feature x;",
+    ) {
+        let y = r.resolve_qualified("C::y").unwrap().0;
+        let lexical_x = r.resolve_qualified("x").unwrap().0;
+        let index =
+            r.b.spec_targets
+                .iter()
+                .position(|entry| entry.0 == y && entry.1 == "Redefinition")
+                .unwrap();
+        assert_eq!(r.b.spec_resolved.get(index), Some(&None));
+        let (_, _, scope, qn) = r.b.spec_targets[index].clone();
+        assert_eq!(
+            r.b.resolve(scope, &qn, 0),
+            Some(lexical_x),
+            "ordinary fallback finds a different target than the original header context"
+        );
+        assert_target(&mut r, y, None);
+    }
+}
+
+#[test]
+fn source_spelled_callee_identity_rebinds_named_argument_context() {
+    const ID: &str = "88888888-8888-4888-8888-888888888888";
+    let source = format!(
+        "function Actual {{in x; return r;}} function '{ID}' {{in x; return r;}} feature call='{ID}'(x=1);"
+    );
+    for mut r in models("package L;", &source) {
+        let actual = r.resolve_qualified("Actual").unwrap();
+        let actual_x = r.resolve_qualified("Actual::x").unwrap().0;
+        let spelled_x = r.resolve_qualified(&format!("'{ID}'::x")).unwrap().0;
+        let parameter = argument(&mut r, "call");
+        assert_target(&mut r, parameter, Some(spelled_x));
+        let call = r.resolve_qualified("call").unwrap();
+        let expression = r.members_via(call, "FeatureValue")[0];
+        let callee_membership = r
+            .owned_relationships(expression)
+            .into_iter()
+            .find(|&edge| r.element_type(edge) == "Membership")
+            .unwrap();
+        r.override_ids(&HashMap::from([(
+            r.element_id(actual),
+            ID.parse().unwrap(),
+        )]));
+        let mut hints = HashMap::from([(
+            (r.element_id(callee_membership), "memberElement".into()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        assert_target(&mut r, parameter, Some(actual_x));
+        // A second source rebind must not resurrect the lexical namesake.
+        r.bind_id_spelled_references_with(&mut hints);
+        assert_target(&mut r, parameter, Some(actual_x));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/naming.rs b/crates/sysmlv2-model/src/json/naming.rs
index 771eed9..354ff15 100644
--- a/crates/sysmlv2-model/src/json/naming.rs
+++ b/crates/sysmlv2-model/src/json/naming.rs
@@ -11,13 +11,16 @@
 //! / `effectiveShortName()`: `if declaredShortName <> null or declaredName
 //! <> null then declaredName else namingFeature().effectiveName()` — a
 //! feature that declares either name declares both): the feature
-//! it explicitly redefines, else — for the memberships whose owned
+//! it explicitly redefines, else a positional redefinition target read from
+//! its owner's heritage, else — for memberships whose owned
 //! feature implicitly redefines a library feature (a binary connector's
 //! two ends, a flow's payload, a return parameter, a subject, an objective,
 //! a view rendering, a transition's accepter, an invocation's positional
 //! arguments) — the positional name the pilot implementation computes
-//! from that implied redefinition, else the feature it references, else
-//! the last link of its feature chain. The naming feature's name is
+//! from that implied redefinition, else the feature selected by a SysML
+//! reference naming rule. Specialized SysML reference rules take precedence
+//! over redefinition. Anonymous feature chains do not confer names. The
+//! naming feature's name is
 //! itself effective, so a chain of unnamed redefinitions resolves to the
 //! first named ancestor. A naming feature outside the model (a library
 //! feature when no library is loaded) is named through
@@ -34,6 +37,50 @@ use super::{ElementRef, ResolvedModel};
 use crate::metaclass::conforms;
 use crate::properties::Atom;
 
+/// SysML reference forms whose naming rule uses the referenced feature's
+/// `featureTarget`. This does not give the anonymous chain itself a name.
+pub(crate) fn reference_names_feature_target(ty: &str, membership: Option<&str>) -> bool {
+    conforms(ty, "PerformActionUsage")
+        || (conforms(ty, "ConstraintUsage")
+            && membership == Some("RequirementConstraintMembership"))
+}
+
+/// Reference-based SysML naming takes precedence over the generic
+/// redefinition rule. Variants name through the reference itself.
+pub(crate) fn reference_names_feature(ty: &str, membership: Option<&str>) -> bool {
+    reference_names_feature_target(ty, membership) || membership == Some("VariantMembership")
+}
+
+impl super::Builder {
+    /// A generic reference spelling is retained as a replay locator, but it
+    /// contributes no semantic name to a recursive namespace import. Keep
+    /// specialized reference naming, explicit redefinitions and positional
+    /// members out of this bounded absence proof.
+    pub(super) fn reference_locator_has_no_semantic_name(&self, e: usize) -> bool {
+        let element = &self.elements[e];
+        let membership = element.owning_relationship.map(|r| self.elements[r].ty);
+        self.effective_name(e).is_none()
+            && self.effective_hint.contains_key(&e)
+            && !reference_names_feature(element.ty, membership)
+            && !matches!(
+                membership,
+                Some(
+                    "ParameterMembership"
+                        | "EndFeatureMembership"
+                        | "ReturnParameterMembership"
+                        | "SubjectMembership"
+                        | "ObjectiveMembership"
+                        | "ViewRenderingMembership"
+                        | "TransitionFeatureMembership"
+                )
+            )
+            && !element
+                .owned_relationships
+                .iter()
+                .any(|&r| self.elements[r].ty == "Redefinition")
+    }
+}
+
 /// The feature that names an unnamed one, once found.
 enum Naming {
     /// A feature of the model.
@@ -91,6 +138,7 @@ impl ResolvedModel {
     }
 
     fn ensure_name_memo(&mut self) {
+        self.sync_semantic_publication();
         let n = self.b.elements.len();
         if self.name_memo.len() != n {
             self.name_memo = vec![None; n];
@@ -118,52 +166,78 @@ impl ResolvedModel {
         }
     }
 
-    /// The naming feature of an unnamed element, in the pilot's
-    /// precedence: the first explicitly redefined feature that resolved,
-    /// the implied positional redefinition, then — unless the
+    /// The naming feature of an unnamed element: a specialized SysML
+    /// reference rule takes precedence; otherwise the first explicitly
+    /// redefined feature, the positional target from its owner's heritage,
+    /// the library-role fallback, then — unless the
     /// element is an actor or stakeholder parameter, whose reference
     /// subsets the library collection and carries no name — the referenced
-    /// feature, then the chain's last link. Only explicit relationships
-    /// count; the implied library specializations name nothing.
+    /// feature selected by the applicable SysML naming rule. Redefinitions
+    /// confer names; other implied library specializations do not.
     fn naming_feature(&mut self, e: usize) -> Option<Naming> {
         self.ensure_by_id();
         let rels: Vec<usize> = self.b.elements[e].owned_relationships.to_vec();
+        let owning_ty = self.b.elements[e]
+            .owning_relationship
+            .map(|r| self.b.elements[r].ty);
+        // Specialized SysML naming overrides Feature::namingFeature, even
+        // when a written redefinition is unresolved or has another name.
+        let named_reference = reference_names_feature(self.b.elements[e].ty, owning_ty)
+            .then(|| {
+                rels.iter()
+                    .copied()
+                    .find(|&r| self.b.elements[r].ty == "ReferenceSubsetting")
+            })
+            .flatten();
         let mut reference: Option<Atom> = None;
-        let mut last_chain: Option<Atom> = None;
         for r in rels {
+            if named_reference.is_some() && Some(r) != named_reference {
+                continue;
+            }
             match self.b.elements[r].ty {
                 "Redefinition" => {
-                    if let Some(target) = self.b.elements[r].props.get("redefinedFeature").cloned()
-                    {
-                        if let Some(naming) = self.naming_target(&target) {
-                            return Some(naming);
-                        }
-                    }
+                    let target = self.b.elements[r].props.get("redefinedFeature").cloned()?;
+                    return self.naming_target(&target);
                 }
-                "ReferenceSubsetting" => {
-                    if reference.is_none() {
-                        reference = self.b.elements[r].props.get("referencedFeature").cloned();
-                    }
-                }
-                "FeatureChaining" => {
-                    last_chain = self.b.elements[r].props.get("chainingFeature").cloned();
+                "ReferenceSubsetting" if named_reference == Some(r) && reference.is_none() => {
+                    reference = self.b.elements[r].props.get("referencedFeature").cloned();
                 }
                 _ => {}
             }
         }
+        // Use the actual positional target before the library-role fallback.
+        // A specializing requirement's subject may redefine a user subject
+        // whose name (and short name) differs from the library's `subj`.
+        if named_reference.is_none() {
+            if let Some(target) = self.positional_redefinition_targets(ElementRef(e)).first() {
+                return Some(Naming::Feature(target.0));
+            }
+        }
         if let Some(n) = self.implied_member_name(e) {
             return Some(Naming::Positional(n));
         }
-        let owning_ty = self.b.elements[e]
-            .owning_relationship
-            .map(|r| self.b.elements[r].ty);
         if matches!(owning_ty, Some("ActorMembership" | "StakeholderMembership")) {
             return None;
         }
-        if let Some(naming) = reference.and_then(|t| self.naming_target(&t)) {
-            return Some(naming);
+        let target = reference?;
+        let naming = self.naming_target(&target)?;
+        if reference_names_feature_target(self.b.elements[e].ty, owning_ty) {
+            if let Naming::Feature(t) = naming {
+                if let Some(last) = self.b.elements[t]
+                    .owned_relationships
+                    .iter()
+                    .rev()
+                    .find_map(|&r| {
+                        (self.b.elements[r].ty == "FeatureChaining")
+                            .then(|| self.b.elements[r].props.get("chainingFeature").cloned())
+                            .flatten()
+                    })
+                {
+                    return self.naming_target(&last);
+                }
+            }
         }
-        last_chain.and_then(|t| self.naming_target(&t))
+        Some(naming)
     }
 
     /// A resolved naming target: a model element (whatever its own names
diff --git a/crates/sysmlv2-model/src/json/operations.rs b/crates/sysmlv2-model/src/json/operations.rs
new file mode 100644
index 0000000..4ff086f
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations.rs
@@ -0,0 +1,874 @@
+//! Checked normative operation invocation, separate from AST scalar evaluation.
+use super::{
+    DerivedValue, ElementRef, Reference, ResolvedModel,
+    type_relations::{SupertypesFailure, TypeRelations},
+};
+use crate::{
+    metaclass::conforms,
+    metamodel::{self, OperationSpec, ParameterSpec},
+};
+pub(in crate::json) mod namespaces;
+
+use std::{
+    collections::{HashMap, HashSet},
+    sync::OnceLock,
+};
+
+/// Reviewed parameter roles for an executable family. The raw XMI catalog is
+/// unchanged: absent source directions are not retroactively filled in.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct OperationExecutionSignature {
+    pub declaration: &'static str,
+    /// Input declaration IDs in invocation argument order (not XMI order).
+    pub inputs: &'static [&'static str],
+    pub result: &'static str,
+}
+
+/// An audited signature does not imply every receiver override is executable.
+/// Invocation resolves the effective declaration and refuses unimplemented
+/// overrides, even when a less-specific declaration has an implementation.
+pub fn operation_execution_signature(id: &str) -> Option<&'static OperationExecutionSignature> {
+    SIGNATURES
+        .iter()
+        .find(|signature| signature.declaration == id)
+}
+static SIGNATURES: &[OperationExecutionSignature] = &[
+    OperationExecutionSignature {
+        declaration: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean",
+        inputs: &[
+            "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-excluded",
+            "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-isRecursive",
+            "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-includeAll",
+        ],
+        result: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        inputs: &[
+            "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludedNamespaces",
+            "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludedTypes",
+            "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludeImplied",
+        ],
+        result: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean",
+        inputs: &[
+            "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludedNamespaces",
+            "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludedTypes",
+            "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludeImplied",
+        ],
+        result: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean",
+        inputs: &[
+            "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludedNamespaces",
+            "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludedTypes",
+            "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludeImplied",
+        ],
+        result: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-resolve_String",
+        inputs: &["Root-Namespaces-Namespace-resolve_String-qualifiedName"],
+        result: "Root-Namespaces-Namespace-resolve_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-resolveLocal_String",
+        inputs: &["Root-Namespaces-Namespace-resolveLocal_String-name"],
+        result: "Root-Namespaces-Namespace-resolveLocal_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-resolveGlobal_String",
+        inputs: &["Root-Namespaces-Namespace-resolveGlobal_String-qualifiedName"],
+        result: "Root-Namespaces-Namespace-resolveGlobal_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-resolveVisible_String",
+        inputs: &["Root-Namespaces-Namespace-resolveVisible_String-name"],
+        result: "Root-Namespaces-Namespace-resolveVisible_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-NamespaceImport-importedMemberships_Namespace",
+        inputs: &["Root-Namespaces-NamespaceImport-importedMemberships_Namespace-excluded"],
+        result: "Root-Namespaces-NamespaceImport-importedMemberships_Namespace-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-MembershipImport-importedMemberships_Namespace",
+        inputs: &["Root-Namespaces-MembershipImport-importedMemberships_Namespace-excluded"],
+        result: "Root-Namespaces-MembershipImport-importedMemberships_Namespace-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-qualificationOf_String",
+        inputs: &["Root-Namespaces-Namespace-qualificationOf_String-qualifiedName"],
+        result: "Root-Namespaces-Namespace-qualificationOf_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-unqualifiedNameOf_String",
+        inputs: &["Root-Namespaces-Namespace-unqualifiedNameOf_String-qualifiedName"],
+        result: "Root-Namespaces-Namespace-unqualifiedNameOf_String-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace",
+        inputs: &[
+            "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-visibility",
+            "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-excluded",
+        ],
+        result: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+        inputs: &[
+            "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-excluded",
+            "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-isRecursive",
+            "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-includeAll",
+        ],
+        result: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-importedMemberships_Namespace",
+        inputs: &["Root-Namespaces-Namespace-importedMemberships_Namespace-excluded"],
+        result: "Root-Namespaces-Namespace-importedMemberships_Namespace-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-visibilityOf_Membership",
+        inputs: &["Root-Namespaces-Namespace-visibilityOf_Membership-mem"],
+        result: "Root-Namespaces-Namespace-visibilityOf_Membership-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Namespaces-Namespace-namesOf_Element",
+        inputs: &["Root-Namespaces-Namespace-namesOf_Element-element"],
+        result: "Root-Namespaces-Namespace-namesOf_Element-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Packages-Package-importedMemberships_Namespace",
+        inputs: &["Kernel-Packages-Package-importedMemberships_Namespace-excluded"],
+        result: "Kernel-Packages-Package-importedMemberships_Namespace-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Elements-Element-effectiveName_",
+        inputs: &[],
+        result: "Root-Elements-Element-effectiveName_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Root-Elements-Element-effectiveShortName_",
+        inputs: &[],
+        result: "Root-Elements-Element-effectiveShortName_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Features-Feature-effectiveName_",
+        inputs: &[],
+        result: "Core-Features-Feature-effectiveName_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Features-Feature-effectiveShortName_",
+        inputs: &[],
+        result: "Core-Features-Feature-effectiveShortName_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Types-Type-supertypes_Boolean",
+        inputs: &["Core-Types-Type-supertypes_Boolean-excludeImplied"],
+        result: "Core-Types-Type-supertypes_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Core-Features-Feature-supertypes_Boolean",
+        inputs: &["Core-Features-Feature-supertypes_Boolean-excludeImplied"],
+        result: "Core-Features-Feature-supertypes_Boolean-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Behaviors-ParameterMembership-parameterDirection_",
+        inputs: &[],
+        result: "Kernel-Behaviors-ParameterMembership-parameterDirection_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Expressions-LiteralExpression-evaluate_Element",
+        inputs: &["Kernel-Expressions-LiteralExpression-evaluate_Element-target"],
+        result: "Kernel-Expressions-LiteralExpression-evaluate_Element-result",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature",
+        inputs: &["Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-visited"],
+        result: "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature",
+        inputs: &[
+            "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature-visited",
+        ],
+        result: "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Expressions-NullExpression-evaluate_Element",
+        inputs: &["Kernel-Expressions-NullExpression-evaluate_Element-target"],
+        result: "Kernel-Expressions-NullExpression-evaluate_Element-result",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature",
+        inputs: &["Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature-visited"],
+        result: "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Functions-Expression-evaluate_Element",
+        inputs: &["Kernel-Functions-Expression-evaluate_Element-target"],
+        result: "Kernel-Functions-Expression-evaluate_Element-result",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Functions-Expression-modelLevelEvaluable_Feature",
+        inputs: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature-visited"],
+        result: "Kernel-Functions-Expression-modelLevelEvaluable_Feature-",
+    },
+    OperationExecutionSignature {
+        declaration: "Kernel-Functions-ReturnParameterMembership-parameterDirection_",
+        inputs: &[],
+        result: "Kernel-Functions-ReturnParameterMembership-parameterDirection_-",
+    },
+    OperationExecutionSignature {
+        declaration: "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature",
+        inputs: &["Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature-visited"],
+        result: "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature-",
+    },
+    OperationExecutionSignature {
+        declaration: "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature",
+        inputs: &["Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature-visited"],
+        result: "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature-",
+    },
+];
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum OperationArgumentIssue {
+    WrongShape,
+    InvalidSyntax,
+    InvalidEnumValue,
+    NullNotAllowed,
+    InvalidElement,
+    UnverifiedReference,
+    WrongMetaclass {
+        expected: &'static str,
+        actual: &'static str,
+    },
+    DuplicateIdentity,
+    Multiplicity,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum OperationError {
+    UnknownOperation,
+    InvalidReceiver,
+    WrongReceiver {
+        expected: &'static str,
+        actual: &'static str,
+    },
+    AmbiguousRedefinition,
+    Unsupported {
+        effective: &'static str,
+    },
+    /// The operation exists but this input configuration is not yet checked.
+    UnsupportedConfiguration {
+        effective: &'static str,
+        parameter: &'static str,
+    },
+    /// Required graph evidence or unambiguous collection ordering is unavailable.
+    Incomplete {
+        effective: &'static str,
+    },
+    WorkLimit {
+        effective: &'static str,
+    },
+    ArgumentCount {
+        expected: usize,
+        actual: usize,
+    },
+    InvalidArgument {
+        index: usize,
+        parameter: &'static str,
+        issue: OperationArgumentIssue,
+    },
+}
+impl std::fmt::Display for OperationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::UnknownOperation => f.write_str("unknown operation declaration identity"),
+            Self::InvalidReceiver => f.write_str("invalid operation receiver"),
+            Self::WrongReceiver { expected, actual } => {
+                write!(f, "operation requires {expected}, got {actual}")
+            }
+            Self::AmbiguousRedefinition => {
+                f.write_str("operation has incomparable applicable redefinitions")
+            }
+            Self::Unsupported { effective } => {
+                write!(f, "operation body is not implemented: {effective}")
+            }
+            Self::UnsupportedConfiguration {
+                effective,
+                parameter,
+            } => write!(f, "unsupported configuration of {effective}: {parameter}"),
+            Self::Incomplete { effective } => {
+                write!(f, "incomplete operation evidence: {effective}")
+            }
+            Self::WorkLimit { effective } => write!(f, "operation work limit reached: {effective}"),
+            Self::ArgumentCount { expected, actual } => {
+                write!(f, "operation requires {expected} arguments, got {actual}")
+            }
+            Self::InvalidArgument {
+                index,
+                parameter,
+                issue,
+            } => write!(f, "invalid argument {index} for {parameter}: {issue:?}"),
+        }
+    }
+}
+impl std::error::Error for OperationError {}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct OperationResult {
+    pub requested: &'static str,
+    pub effective: &'static str,
+    pub value: DerivedValue,
+}
+
+/// Build the normative redefinition closure once, independently of model state.
+/// Dispatch by identity, not coincidental operation spelling or class depth.
+struct Dispatch {
+    descendants: HashMap<&'static str, Vec<&'static OperationSpec>>,
+    ancestors: HashMap<&'static str, HashSet<&'static str>>,
+}
+impl Dispatch {
+    fn catalog() -> &'static Self {
+        static DISPATCH: OnceLock<Dispatch> = OnceLock::new();
+        DISPATCH.get_or_init(|| {
+            let mut ancestors = HashMap::new();
+            for operation in metamodel::operations() {
+                let mut found = HashSet::new();
+                let mut stack = operation.redefines.to_vec();
+                while let Some(id) = stack.pop() {
+                    if found.insert(id) {
+                        if let Some(parent) = metamodel::operation(id) {
+                            stack.extend_from_slice(parent.redefines);
+                        }
+                    }
+                }
+                ancestors.insert(operation.id, found);
+            }
+            let mut descendants: HashMap<_, Vec<_>> = HashMap::new();
+            for operation in metamodel::operations() {
+                descendants.entry(operation.id).or_default().push(operation);
+                for &ancestor in &ancestors[operation.id] {
+                    descendants.entry(ancestor).or_default().push(operation);
+                }
+            }
+            Self {
+                descendants,
+                ancestors,
+            }
+        })
+    }
+    fn effective(
+        &self,
+        requested: &'static OperationSpec,
+        receiver: &str,
+    ) -> Result<&'static OperationSpec, OperationError> {
+        let applicable: Vec<_> = self.descendants[requested.id]
+            .iter()
+            .copied()
+            .filter(|operation| conforms(receiver, operation.declaring_metaclass))
+            .collect();
+        let mut surviving = applicable.iter().copied().filter(|operation| {
+            !applicable.iter().any(|other| {
+                other.id != operation.id && self.ancestors[other.id].contains(operation.id)
+            })
+        });
+        let effective = surviving
+            .next()
+            .ok_or(OperationError::AmbiguousRedefinition)?;
+        if surviving.next().is_some() {
+            return Err(OperationError::AmbiguousRedefinition);
+        }
+        Ok(effective)
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Handler {
+    Namespace(namespaces::Body),
+    DeclaredName { key: &'static str, feature: bool },
+    In,
+    Out,
+    SelfSequence,
+    EmptySequence,
+    True,
+    False,
+    ExplicitSupertypes,
+}
+fn handler(id: &str) -> Option<Handler> {
+    use Handler::*;
+    Some(match id {
+        "Root-Namespaces-Namespace-resolve_String" => Namespace(namespaces::Body::Resolve),
+        "Root-Namespaces-Namespace-resolveLocal_String" => {
+            Namespace(namespaces::Body::ResolveLocal)
+        }
+        "Root-Namespaces-Namespace-resolveGlobal_String" => {
+            Namespace(namespaces::Body::ResolveGlobal)
+        }
+        "Root-Namespaces-Namespace-qualificationOf_String" => {
+            Namespace(namespaces::Body::Qualification)
+        }
+        "Root-Namespaces-Namespace-unqualifiedNameOf_String" => {
+            Namespace(namespaces::Body::Unqualified)
+        }
+        "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace" => {
+            Namespace(namespaces::Body::Memberships)
+        }
+        "Root-Namespaces-NamespaceImport-importedMemberships_Namespace"
+        | "Root-Namespaces-MembershipImport-importedMemberships_Namespace" => {
+            Namespace(namespaces::Body::Import)
+        }
+        "Root-Namespaces-Namespace-resolveVisible_String" => {
+            Namespace(namespaces::Body::ResolveVisible)
+        }
+        "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean"
+        | "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean" => {
+            Namespace(namespaces::Body::Visible)
+        }
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean" => {
+            Namespace(namespaces::Body::Inherited)
+        }
+        "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean" => {
+            Namespace(namespaces::Body::Inheritable)
+        }
+        "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean" => {
+            Namespace(namespaces::Body::NonPrivate)
+        }
+        "Root-Namespaces-Namespace-importedMemberships_Namespace" => {
+            Namespace(namespaces::Body::Imported)
+        }
+        "Root-Namespaces-Namespace-visibilityOf_Membership" => {
+            Namespace(namespaces::Body::Visibility)
+        }
+        "Root-Namespaces-Namespace-namesOf_Element" => Namespace(namespaces::Body::Names),
+        "Kernel-Packages-Package-importedMemberships_Namespace" => {
+            Namespace(namespaces::Body::Imported)
+        }
+        "Root-Elements-Element-effectiveName_" => DeclaredName {
+            key: "declaredName",
+            feature: false,
+        },
+        "Root-Elements-Element-effectiveShortName_" => DeclaredName {
+            key: "declaredShortName",
+            feature: false,
+        },
+        "Core-Features-Feature-effectiveName_" => DeclaredName {
+            key: "declaredName",
+            feature: true,
+        },
+        "Core-Features-Feature-effectiveShortName_" => DeclaredName {
+            key: "declaredShortName",
+            feature: true,
+        },
+
+        "Core-Types-Type-supertypes_Boolean" | "Core-Features-Feature-supertypes_Boolean" => {
+            ExplicitSupertypes
+        }
+        "Kernel-Behaviors-ParameterMembership-parameterDirection_" => In,
+        "Kernel-Functions-ReturnParameterMembership-parameterDirection_" => Out,
+        "Kernel-Expressions-LiteralExpression-evaluate_Element" => SelfSequence,
+        "Kernel-Expressions-NullExpression-evaluate_Element" => EmptySequence,
+        "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature"
+        | "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature"
+        | "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature" => True,
+        "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature"
+        | "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature" => False,
+        _ => return None,
+    })
+}
+fn declared_name(
+    r: &ResolvedModel,
+    receiver: ElementRef,
+    effective: &'static str,
+    key: &'static str,
+    feature: bool,
+    steps: &mut usize,
+) -> Result<DerivedValue, OperationError> {
+    *steps = steps.saturating_add(4);
+    let props = &r.b.elements[receiver.0].props;
+    let mut declares = false;
+    for name in ["declaredName", "declaredShortName"] {
+        if let Some(value) = props.get(name) {
+            if value.as_str().is_some() {
+                declares = true;
+            } else if !value.is_null() {
+                return Err(OperationError::Incomplete { effective });
+            }
+        }
+    }
+    if feature && !declares {
+        return Err(OperationError::Incomplete { effective });
+    }
+    let value = props.get(key).and_then(|v| v.as_str());
+    *steps = steps.saturating_add(value.map_or(0, str::len));
+    if *steps > crate::eval::MAX_STEPS {
+        return Err(OperationError::WorkLimit { effective });
+    }
+    Ok(value.map_or(DerivedValue::Null, |value| {
+        DerivedValue::Str(value.to_owned())
+    }))
+}
+/// Reuse declared-name bodies under a caller's cumulative allowance. Namespace
+/// queries cannot restart an independent allowance for every Membership name.
+fn checked_name(
+    r: &ResolvedModel,
+    receiver: ElementRef,
+    declaration: &'static str,
+    steps: &mut usize,
+) -> Result<DerivedValue, OperationError> {
+    *steps = steps.saturating_add(metamodel::operations().len().saturating_mul(4));
+    if *steps > crate::eval::MAX_STEPS {
+        return Err(OperationError::WorkLimit {
+            effective: declaration,
+        });
+    }
+    let requested = metamodel::operation(declaration).expect("declared name operation");
+    let effective = Dispatch::catalog().effective(requested, r.element_type(receiver))?;
+    match handler(effective.id) {
+        Some(Handler::DeclaredName { key, feature }) => {
+            declared_name(r, receiver, effective.id, key, feature, steps)
+        }
+        _ => Err(OperationError::Incomplete {
+            effective: effective.id,
+        }),
+    }
+}
+
+impl ResolvedModel {
+    /// Invoke a supported normative operation by its declaration identity.
+    /// Virtual redefinitions are resolved before execution; unsupported and
+    /// incomparable overrides never fall back to a base implementation.
+    ///
+    /// Arguments follow the audited signature's input order. Collection-valued
+    /// parameters require Elements/References even when empty; scalar element
+    /// parameters require Element/Reference. In-model references are checked
+    /// against parameter metaclasses and multiplicities. External/unresolved
+    /// references cannot establish the checked argument contract.
+    ///
+    /// Literal evaluate returns a References sequence containing the literal ELEMENT;
+    /// NullExpression evaluate returns an empty sequence. These operations do
+    /// not evaluate to Rust scalar values, create result features, materialize
+    /// implied relationships, initialize semantic caches, or hydrate libraries.
+    /// supertypes admits excludeImplied=true and either flag for a conjugated
+    /// receiver, using the shared
+    /// checked stored endpoint/carrier provider. Missing endpoints, malformed
+    /// aliases and duplicate projection/append ordering return Incomplete;
+    /// ordinary excludeImplied=false returns UnsupportedConfiguration. Graph reads may
+    /// initialize identity indexes; constant handlers do not mutate the model.
+    /// Effective-name handlers read Element declarations and the declared-name
+    /// branch of Feature overrides. Undeclared Feature names remain Incomplete
+    /// until the virtual naming-feature dependencies can be certified.
+    pub fn invoke_operation(
+        &mut self,
+        receiver: ElementRef,
+        declaration: &str,
+        arguments: &[DerivedValue],
+    ) -> Result<OperationResult, OperationError> {
+        let requested =
+            metamodel::operation(declaration).ok_or(OperationError::UnknownOperation)?;
+        let element = self
+            .b
+            .elements
+            .get(receiver.0)
+            .ok_or(OperationError::InvalidReceiver)?;
+        if !conforms(element.ty, requested.declaring_metaclass) {
+            return Err(OperationError::WrongReceiver {
+                expected: requested.declaring_metaclass,
+                actual: element.ty,
+            });
+        }
+        let effective = Dispatch::catalog().effective(requested, element.ty)?;
+        let handler = handler(effective.id).ok_or(OperationError::Unsupported {
+            effective: effective.id,
+        })?;
+        let signature = operation_execution_signature(effective.id).expect("implemented signature");
+        if arguments.len() != signature.inputs.len() {
+            return Err(OperationError::ArgumentCount {
+                expected: signature.inputs.len(),
+                actual: arguments.len(),
+            });
+        }
+        let mut steps = 0usize;
+        for (index, (argument, &parameter)) in arguments.iter().zip(signature.inputs).enumerate() {
+            // Bound validation before walking or allocating identity sets for
+            // collection arguments, even when the selected body ignores them.
+            let amount = match argument {
+                DerivedValue::Elements(v) => v.len().saturating_mul(4),
+                DerivedValue::References(v) => v.len().saturating_mul(4),
+                DerivedValue::Strings(v) => v.len(),
+                DerivedValue::Str(v) => v.len(),
+                _ => 1,
+            };
+            steps = steps.saturating_add(amount).saturating_add(1);
+            if steps > crate::eval::MAX_STEPS {
+                return Err(OperationError::WorkLimit {
+                    effective: effective.id,
+                });
+            }
+            let spec = effective
+                .parameters
+                .iter()
+                .find(|spec| spec.id == parameter)
+                .expect("audited parameter identity");
+            self.operation_argument(argument, spec).map_err(|issue| {
+                OperationError::InvalidArgument {
+                    index,
+                    parameter,
+                    issue,
+                }
+            })?;
+        }
+        let value = match handler {
+            Handler::Namespace(body) => namespaces::invoke(
+                self,
+                receiver,
+                effective.id,
+                signature,
+                arguments,
+                body,
+                steps,
+            )?,
+            Handler::DeclaredName { key, feature } => {
+                declared_name(self, receiver, effective.id, key, feature, &mut steps)?
+            }
+
+            Handler::In => DerivedValue::Str("in".to_owned()),
+            Handler::Out => DerivedValue::Str("out".to_owned()),
+            Handler::SelfSequence => DerivedValue::References(vec![Reference::Element(receiver)]),
+            Handler::EmptySequence => DerivedValue::References(Vec::new()),
+            Handler::True => DerivedValue::Bool(true),
+            Handler::False => DerivedValue::Bool(false),
+            Handler::ExplicitSupertypes => {
+                let exclude_implied = matches!(arguments.first(), Some(DerivedValue::Bool(true)));
+                let targets = TypeRelations::default()
+                    .checked_supertypes(&mut self.b, receiver.0, exclude_implied, &mut steps)
+                    .map_err(|failure| {
+                        if steps > crate::eval::MAX_STEPS {
+                            OperationError::WorkLimit {
+                                effective: effective.id,
+                            }
+                        } else {
+                            match failure {
+                                SupertypesFailure::Incomplete => OperationError::Incomplete {
+                                    effective: effective.id,
+                                },
+                                SupertypesFailure::UnsupportedConfiguration => {
+                                    OperationError::UnsupportedConfiguration {
+                                        effective: effective.id,
+                                        parameter: signature.inputs[0],
+                                    }
+                                }
+                            }
+                        }
+                    })?;
+                DerivedValue::References(
+                    targets
+                        .into_iter()
+                        .map(|target| Reference::Element(ElementRef(target)))
+                        .collect(),
+                )
+            }
+        };
+        Ok(OperationResult {
+            requested: requested.id,
+            effective: effective.id,
+            value,
+        })
+    }
+    fn operation_argument(
+        &self,
+        value: &DerivedValue,
+        parameter: &ParameterSpec,
+    ) -> Result<(), OperationArgumentIssue> {
+        use OperationArgumentIssue::*;
+        if parameter.target == "String" || parameter.target == "VisibilityKind" {
+            return match value {
+                DerivedValue::Str(value) => {
+                    if parameter.target == "VisibilityKind"
+                        && !matches!(value.as_str(), "public" | "protected" | "private")
+                    {
+                        Err(InvalidEnumValue)
+                    } else {
+                        Ok(())
+                    }
+                }
+                DerivedValue::Null if parameter.lower == 0 => Ok(()),
+                DerivedValue::Null => Err(NullNotAllowed),
+                _ => Err(WrongShape),
+            };
+        }
+        if parameter.target == "Boolean" {
+            return match value {
+                DerivedValue::Bool(_) => Ok(()),
+                DerivedValue::Null if parameter.lower == 0 => Ok(()),
+                DerivedValue::Null => Err(NullNotAllowed),
+                _ => Err(WrongShape),
+            };
+        }
+        let mut seen = HashSet::new();
+        let mut count = 0;
+        let mut check = |element: ElementRef| {
+            let element_data = self.b.elements.get(element.0).ok_or(InvalidElement)?;
+            if !conforms(element_data.ty, parameter.target) {
+                return Err(WrongMetaclass {
+                    expected: parameter.target,
+                    actual: element_data.ty,
+                });
+            }
+            // Session handles are row indices, not semantic identities: an
+            // invalid payload/remap can give distinct rows the same UUID.
+            // Enforce this argument's uniqueness without scanning the model.
+            if parameter.unique && !seen.insert(element_data.id) {
+                return Err(DuplicateIdentity);
+            }
+            count += 1;
+            Ok(())
+        };
+        let mut reference = |reference: &Reference| match reference {
+            Reference::Element(element) => check(*element),
+            Reference::External(_) | Reference::Unresolved(_) => Err(UnverifiedReference),
+        };
+        if parameter.upper == Some(1) {
+            match value {
+                DerivedValue::Element(element) => reference(&Reference::Element(*element))?,
+                DerivedValue::Reference(value) => reference(value)?,
+                DerivedValue::Null if parameter.lower == 0 => {}
+                DerivedValue::Null => return Err(NullNotAllowed),
+                _ => return Err(WrongShape),
+            }
+        } else {
+            match value {
+                DerivedValue::Elements(elements) => {
+                    for &element in elements {
+                        reference(&Reference::Element(element))?;
+                    }
+                }
+                DerivedValue::References(elements) => {
+                    for element in elements {
+                        reference(element)?;
+                    }
+                }
+                _ => return Err(WrongShape),
+            }
+        }
+        if count < parameter.lower || parameter.upper.is_some_and(|upper| count > upper) {
+            return Err(Multiplicity);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn audited_roles_preserve_raw_catalog_and_exact_implementation_count() {
+        assert_eq!(metamodel::operations().len(), 103);
+        assert_eq!(
+            metamodel::operations()
+                .iter()
+                .map(|o| o.name)
+                .collect::<HashSet<_>>()
+                .len(),
+            69
+        );
+        assert_eq!(
+            metamodel::operations()
+                .iter()
+                .filter(|o| handler(o.id).is_some())
+                .count(),
+            33
+        );
+        assert_eq!(SIGNATURES.len(), 35); // thirty-three bodies and two virtual base signatures
+        for signature in SIGNATURES {
+            let operation = metamodel::operation(signature.declaration).unwrap();
+            let ids: HashSet<_> = signature
+                .inputs
+                .iter()
+                .copied()
+                .chain([signature.result])
+                .collect();
+            assert_eq!(ids.len(), operation.parameters.len());
+            assert!(
+                operation
+                    .parameters
+                    .iter()
+                    .all(|p| p.direction.is_none() && ids.contains(p.id))
+            );
+        }
+        for (receiver, effective) in [
+            (
+                "LiteralInteger",
+                "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature",
+            ),
+            (
+                "MetadataAccessExpression",
+                "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature",
+            ),
+            (
+                "ConstructorExpression",
+                "Kernel-Expressions-ConstructorExpression-modelLevelEvaluable_Feature",
+            ),
+        ] {
+            assert_eq!(
+                Dispatch::catalog()
+                    .effective(
+                        metamodel::operation(
+                            "Kernel-Functions-Expression-modelLevelEvaluable_Feature"
+                        )
+                        .unwrap(),
+                        receiver
+                    )
+                    .unwrap()
+                    .id,
+                effective
+            );
+        }
+    }
+    #[test]
+    fn incomparable_redefinitions_refuse_instead_of_choosing_declaration_order() {
+        static BASE: OperationSpec = OperationSpec {
+            id: "base",
+            declaring_metaclass: "Element",
+            name: "op",
+            redefines: &[],
+            parameters: &[],
+        };
+        static LEFT: OperationSpec = OperationSpec {
+            id: "left",
+            declaring_metaclass: "Connector",
+            name: "op",
+            redefines: &["base"],
+            parameters: &[],
+        };
+        static RIGHT: OperationSpec = OperationSpec {
+            id: "right",
+            declaring_metaclass: "Usage",
+            name: "op",
+            redefines: &["base"],
+            parameters: &[],
+        };
+        assert!(conforms("BindingConnectorAsUsage", "Connector"));
+        assert!(conforms("BindingConnectorAsUsage", "Usage"));
+        let dispatch = Dispatch {
+            descendants: HashMap::from([("base", vec![&BASE, &LEFT, &RIGHT])]),
+            ancestors: HashMap::from([
+                ("base", HashSet::new()),
+                ("left", HashSet::from(["base"])),
+                ("right", HashSet::from(["base"])),
+            ]),
+        };
+        assert!(matches!(
+            dispatch.effective(&BASE, "BindingConnectorAsUsage"),
+            Err(OperationError::AmbiguousRedefinition)
+        ));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces.rs b/crates/sysmlv2-model/src/json/operations/namespaces.rs
new file mode 100644
index 0000000..26c58f2
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces.rs
@@ -0,0 +1,941 @@
+//! Checked Namespace bodies with bounded, reciprocal import membership evidence.
+//! Import traversal reuses complete membership evidence for ordinary Type contexts.
+//! Filtered visibility and general metadata predicates
+//! remain explicitly qualified.
+use super::{OperationArgumentIssue, OperationError, OperationExecutionSignature};
+use crate::{
+    json::{
+        DerivedValue, ElementRef, PropertyError, Reference, ResolvedModel, membership_evidence,
+        semantic::certified_types::Stamp, semantic_ownership, structural_index::StoredStructure,
+    },
+    metaclass::conforms,
+};
+use std::collections::HashSet;
+pub(in crate::json) mod imports;
+mod resolution;
+use sysmlv2_syntax::{
+    ast::Dialect,
+    lexer::{tokenize, unescape},
+    name::spell_path,
+    parser::is_reserved,
+    token::TokenKind,
+};
+
+#[derive(Clone, Copy)]
+pub(super) enum Body {
+    Qualification,
+    Unqualified,
+    Memberships,
+    Visible,
+    Inherited,
+    Inheritable,
+    NonPrivate,
+    Imported,
+    Visibility,
+    Names,
+    Import,
+    ResolveVisible,
+    Resolve,
+    ResolveLocal,
+    ResolveGlobal,
+}
+fn charge(steps: &mut usize, n: usize, effective: &'static str) -> Result<(), OperationError> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(OperationError::WorkLimit { effective })
+    } else {
+        Ok(())
+    }
+}
+fn syntax(
+    source: &str,
+    effective: &'static str,
+    signature: &OperationExecutionSignature,
+    qualification: bool,
+    mut steps: usize,
+) -> Result<DerivedValue, OperationError> {
+    let (global, mut names) = qualified_names(source, effective, signature, &mut steps)?;
+    if !qualification {
+        return Ok(DerivedValue::Str(names.pop().expect("at least one name")));
+    }
+    names.pop();
+    if names.is_empty() {
+        return Ok(if global {
+            DerivedValue::Str("$".into())
+        } else {
+            DerivedValue::Null
+        });
+    }
+    let prefix = spell_path(Some(Dialect::Kerml), names);
+    Ok(DerivedValue::Str(if global {
+        format!("$::{prefix}")
+    } else {
+        prefix
+    }))
+}
+fn qualified_names(
+    source: &str,
+    effective: &'static str,
+    signature: &OperationExecutionSignature,
+    steps: &mut usize,
+) -> Result<(bool, Vec<String>), OperationError> {
+    // Bound tokenization, decoding, and re-spelling before allocating. The
+    // existing lexer is the authority for quoted-name escapes and trivia.
+    charge(
+        steps,
+        source.len().saturating_mul(8).saturating_add(1),
+        effective,
+    )?;
+    let invalid = || OperationError::InvalidArgument {
+        index: 0,
+        parameter: signature.inputs[0],
+        issue: OperationArgumentIssue::InvalidSyntax,
+    };
+    let (tokens, diagnostics) = tokenize(source);
+    if !diagnostics.is_empty() {
+        return Err(invalid());
+    }
+    let mut tokens = tokens.iter().filter(|t| !t.kind.is_trivia()).peekable();
+    let global = tokens.peek().is_some_and(|t| t.kind == TokenKind::Dollar);
+    if global {
+        tokens.next();
+        if tokens
+            .next()
+            .is_none_or(|t| t.kind != TokenKind::ColonColon)
+        {
+            return Err(invalid());
+        }
+    }
+    let mut names = Vec::new();
+    loop {
+        let token = tokens.next().ok_or_else(invalid)?;
+        let name = match token.kind {
+            TokenKind::Ident if !is_reserved(Dialect::Kerml, token.text(source)) => {
+                token.text(source).to_owned()
+            }
+            TokenKind::UnrestrictedName => unescape(token.text(source)),
+            _ => return Err(invalid()),
+        };
+        names.push(name);
+        match tokens.next().map(|t| t.kind) {
+            Some(TokenKind::ColonColon) => {}
+            Some(TokenKind::Eof) if tokens.next().is_none() => break,
+            _ => return Err(invalid()),
+        }
+    }
+    Ok((global, names))
+}
+
+#[derive(Clone)]
+pub(in crate::json) struct Membership {
+    pub(in crate::json) relationship: usize,
+    pub(in crate::json) member: usize,
+    pub(in crate::json) visibility: &'static str,
+}
+fn visibility(r: &ResolvedModel, relationship: usize) -> Option<&'static str> {
+    visibility_builder(&r.b, relationship)
+}
+fn visibility_builder(b: &crate::json::Builder, relationship: usize) -> Option<&'static str> {
+    match b.elements[relationship].props.get("visibility") {
+        None => Some(if conforms(b.elements[relationship].ty, "Import") {
+            "private"
+        } else {
+            "public"
+        }),
+        Some(v) => match v.as_str()? {
+            "public" => Some("public"),
+            "protected" => Some("protected"),
+            "private" => Some("private"),
+            _ => None,
+        },
+    }
+}
+pub(in crate::json) fn memberships_builder(
+    b: &crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Vec<Membership>, OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    if !matches!(
+        b.elements[owner].ty,
+        "Namespace" | "Package" | "LibraryPackage"
+    ) && !crate::json::type_features::supported_root(b.elements[owner].ty)
+    {
+        return Err(incomplete());
+    }
+    let domains = raw.membership_domains(b, steps).ok_or_else(incomplete)?;
+    if !domains.owner_complete(owner)
+        || raw.metadata_annotation_targets.contains(&owner)
+        || b.metadata_of.get(&owner).is_some_and(|v| !v.is_empty())
+    {
+        return Err(incomplete());
+    }
+    let relationships = semantic_ownership::owned_relationships(b, owner).ok_or_else(incomplete)?;
+    charge(steps, relationships.len().saturating_mul(2), effective)?;
+    let mut seen = HashSet::new();
+    let mut result = Vec::new();
+    for relationship in relationships.iter() {
+        if !seen.insert(relationship)
+            || semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)
+                != Some(Some(owner))
+        {
+            return Err(incomplete());
+        }
+        if !conforms(b.elements[relationship].ty, "Membership") {
+            continue;
+        }
+        let member = membership_evidence::member(b, raw, owner, relationship, steps)
+            .ok_or_else(incomplete)?;
+        result.push(Membership {
+            relationship,
+            member,
+            visibility: visibility_builder(b, relationship).ok_or_else(incomplete)?,
+        });
+    }
+    Ok(result)
+}
+fn member_names(
+    r: &mut ResolvedModel,
+    membership: &Membership,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Vec<String>, OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    charge(steps, 4, effective)?;
+    let owned = conforms(r.b.elements[membership.relationship].ty, "OwningMembership");
+    let mut names = Vec::new();
+    let source = &r.b.elements[if owned {
+        membership.member
+    } else {
+        membership.relationship
+    }];
+    for key in if owned {
+        ["declaredName", "declaredShortName"]
+    } else {
+        ["memberName", "memberShortName"]
+    } {
+        if let Some(value) = source.props.get(key).and_then(|v| v.as_str()) {
+            charge(steps, value.len().saturating_mul(3), effective)?;
+        }
+    }
+    for (key, operation) in [
+        (
+            "memberShortName",
+            "Root-Elements-Element-effectiveShortName_",
+        ),
+        ("memberName", "Root-Elements-Element-effectiveName_"),
+    ] {
+        let value = if owned {
+            super::checked_name(r, ElementRef(membership.member), operation, steps)?
+        } else {
+            match r.b.elements[membership.relationship].props.get(key) {
+                None => DerivedValue::Null,
+                Some(v) if v.is_null() => DerivedValue::Null,
+                Some(v) => DerivedValue::Str(v.as_str().ok_or_else(incomplete)?.to_owned()),
+            }
+        };
+        match value {
+            DerivedValue::Null => {}
+            DerivedValue::Str(name) => {
+                charge(steps, name.len().saturating_add(1), effective)?;
+                if !names.contains(&name) {
+                    names.push(name);
+                }
+            }
+            _ => return Err(incomplete()),
+        }
+    }
+    Ok(names)
+}
+
+// A nested Type query may initialize retained semantic or positional evidence.
+// Discard the whole successful attempt in that case and reacquire its evidence;
+// never return a value computed across two publication states. The one retry
+// shares the original allowance and leaves ordinary Namespace reads cold.
+fn with_stable_evidence<T>(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    steps: &mut usize,
+    effective: &'static str,
+    mut query: impl FnMut(&mut ResolvedModel, &StoredStructure, &mut usize) -> Result<T, OperationError>,
+) -> Result<(std::sync::Arc<StoredStructure>, Stamp, T), OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    if r.b.positional_planning {
+        return Err(incomplete());
+    }
+    if conforms(r.b.elements[receiver.0].ty, "Type")
+        && !r.b.ensure_positional_redefinitions_with_budget(steps)
+    {
+        return Err(incomplete());
+    }
+    for _ in 0..2 {
+        let raw = StoredStructure::for_query(&mut r.b, steps).ok_or_else(incomplete)?;
+        if !raw.ids_unique || raw.annotations_incomplete || r.b.metadata_associations_incomplete {
+            return Err(incomplete());
+        }
+        let stamp = Stamp::capture(r);
+        let value = query(r, &raw, steps)?;
+        charge(steps, 0, effective)?;
+        if stamp.current(r) {
+            return Ok((raw, stamp, value));
+        }
+    }
+    Err(incomplete())
+}
+fn prepare(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    steps: &mut usize,
+    effective: &'static str,
+    excluded: &[usize],
+) -> Result<(std::sync::Arc<StoredStructure>, Stamp, imports::Sequence), OperationError> {
+    with_stable_evidence(r, receiver, steps, effective, |r, raw, steps| {
+        imports::sequence(r, raw, receiver.0, excluded, steps, effective)
+    })
+}
+#[derive(Default)]
+pub(in crate::json) struct NamespaceRow {
+    cached: Option<(ElementRef, Stamp, imports::Sequence)>,
+}
+impl NamespaceRow {
+    /// One checked export row shares the complete domain and its work allowance
+    /// across membership, member, and importedMembership property reads.
+    pub(in crate::json) fn property(
+        &mut self,
+        r: &mut ResolvedModel,
+        receiver: ElementRef,
+        declaration: &'static str,
+        steps: &mut usize,
+    ) -> Result<DerivedValue, PropertyError> {
+        let body = match declaration {
+            "Root-Namespaces-Namespace-importedMembership" => 0,
+            "Root-Namespaces-Namespace-membership" => 1,
+            "Root-Namespaces-Namespace-member" => 2,
+            _ => return Err(PropertyError::NotComputed),
+        };
+        let result = (|| {
+            charge(steps, 1, declaration)?;
+            if !self
+                .cached
+                .as_ref()
+                .is_some_and(|(owner, stamp, _)| *owner == receiver && stamp.current(r))
+            {
+                self.cached = None;
+                let (_, stamp, owned) = prepare(r, receiver, steps, declaration, &[])?;
+                self.cached = Some((receiver, stamp, owned));
+            }
+            let (_, stamp, owned) = self.cached.as_ref().expect("complete row");
+            let selected = if body == 0 {
+                &owned.imported
+            } else {
+                &owned.all
+            };
+            charge(steps, selected.len().saturating_mul(2), declaration)?;
+            let mut result = Vec::new();
+            let mut seen = HashSet::new();
+            {
+                for membership in selected {
+                    let target = if body != 2 {
+                        membership.relationship
+                    } else {
+                        membership.member
+                    };
+                    if seen.insert(target) {
+                        result.push(Reference::Element(ElementRef(target)));
+                    }
+                }
+            }
+            if !stamp.current(r) {
+                return Err(OperationError::Incomplete {
+                    effective: declaration,
+                });
+            }
+            Ok(DerivedValue::References(result))
+        })();
+        result.map_err(|_| PropertyError::NotComputed)
+    }
+}
+fn argument_element(argument: &DerivedValue) -> usize {
+    match argument {
+        DerivedValue::Element(e) | DerivedValue::Reference(Reference::Element(e)) => e.0,
+        _ => unreachable!("validated scalar element argument"),
+    }
+}
+pub(super) fn invoke(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    effective: &'static str,
+    signature: &OperationExecutionSignature,
+    arguments: &[DerivedValue],
+    body: Body,
+    mut steps: usize,
+) -> Result<DerivedValue, OperationError> {
+    if matches!(body, Body::Qualification | Body::Unqualified) {
+        let DerivedValue::Str(source) = &arguments[0] else {
+            unreachable!("validated string argument")
+        };
+        return syntax(
+            source,
+            effective,
+            signature,
+            matches!(body, Body::Qualification),
+            steps,
+        );
+    }
+    let incomplete = || OperationError::Incomplete { effective };
+    let result = (|| {
+        if matches!(
+            body,
+            Body::Resolve | Body::ResolveLocal | Body::ResolveGlobal
+        ) {
+            return resolution::invoke(
+                r, receiver, effective, signature, arguments, body, &mut steps,
+            );
+        }
+        if matches!(body, Body::Inherited | Body::Inheritable | Body::NonPrivate) {
+            // Exclusions select from the already complete shared provider.
+            let excluded_namespaces = imports::exclusions(&arguments[0]);
+            let excluded = imports::exclusions(&arguments[1]);
+            charge(&mut steps, excluded.len(), effective)?;
+            let sequence =
+                r.b.checked_type_membership_operation(
+                    receiver.0,
+                    &excluded_namespaces,
+                    &excluded,
+                    matches!(arguments[2], DerivedValue::Bool(true)),
+                    &mut steps,
+                )
+                .map_err(|_| incomplete())?;
+            let selected = match body {
+                Body::Inherited => sequence.inherited,
+                Body::Inheritable => sequence.inheritable,
+                Body::NonPrivate => sequence.non_private,
+                _ => unreachable!(),
+            };
+            charge(&mut steps, selected.len(), effective)?;
+            return Ok(DerivedValue::References(
+                selected
+                    .into_iter()
+                    .map(|m| Reference::Element(ElementRef(m.relationship)))
+                    .collect(),
+            ));
+        }
+        let excluded = match body {
+            Body::Imported | Body::Visible | Body::Import => imports::exclusions(&arguments[0]),
+            Body::Memberships => imports::exclusions(&arguments[1]),
+            _ => Vec::new(),
+        };
+        if matches!(body, Body::Import) {
+            return imports::invoke_import(r, receiver, &excluded, &mut steps, effective);
+        }
+        let (_, _, value) =
+            with_stable_evidence(r, receiver, &mut steps, effective, |r, raw, steps| {
+                let sequence = imports::sequence(r, raw, receiver.0, &excluded, steps, effective)?;
+                let owned = sequence.all;
+                let value = match body {
+                    Body::Imported => imports::references(sequence.imported),
+                    Body::Memberships => {
+                        let requested = match &arguments[0] {
+                            DerivedValue::Null => None,
+                            DerivedValue::Str(v) => Some(v.as_str()),
+                            _ => unreachable!("validated visibility"),
+                        };
+                        imports::references(imports::memberships_of_visibility(
+                            r, raw, receiver.0, &excluded, requested, steps, effective, 0,
+                        )?)
+                    }
+                    Body::Visibility => {
+                        let mem = argument_element(&arguments[0]);
+                        let value = owned
+                            .iter()
+                            .find(|m| m.relationship == mem)
+                            .map_or("private", |m| m.visibility);
+                        DerivedValue::Str(value.into())
+                    }
+                    Body::ResolveVisible => {
+                        let DerivedValue::Str(name) = &arguments[0] else {
+                            unreachable!("validated name")
+                        };
+                        charge(steps, name.len(), effective)?;
+                        let visible = imports::visible(
+                            r,
+                            raw,
+                            receiver.0,
+                            &[],
+                            false,
+                            false,
+                            steps,
+                            effective,
+                            0,
+                        )?;
+                        let mut result = DerivedValue::Null;
+                        for membership in visible {
+                            if member_names(r, &membership, steps, effective)?
+                                .iter()
+                                .any(|n| n == name)
+                            {
+                                result = DerivedValue::Reference(Reference::Element(ElementRef(
+                                    membership.relationship,
+                                )));
+                                break;
+                            }
+                        }
+                        result
+                    }
+                    Body::Names => {
+                        let member = argument_element(&arguments[0]);
+                        let mut names = Vec::new();
+                        let mut seen = HashSet::new();
+                        for membership in owned.iter().filter(|m| m.member == member) {
+                            for name in member_names(r, membership, steps, effective)? {
+                                if seen.insert(name.clone()) {
+                                    names.push(name);
+                                }
+                            }
+                        }
+                        DerivedValue::Strings(names)
+                    }
+                    Body::Visible => {
+                        let recursive = matches!(arguments[1], DerivedValue::Bool(true));
+                        let all = matches!(arguments[2], DerivedValue::Bool(true));
+                        imports::references(imports::visible(
+                            r, raw, receiver.0, &excluded, recursive, all, steps, effective, 0,
+                        )?)
+                    }
+                    Body::Inherited
+                    | Body::Inheritable
+                    | Body::NonPrivate
+                    | Body::Qualification
+                    | Body::Unqualified
+                    | Body::Import
+                    | Body::Resolve
+                    | Body::ResolveLocal
+                    | Body::ResolveGlobal => unreachable!(),
+                };
+                Ok(value)
+            })?;
+        Ok(value)
+    })();
+    if steps > crate::eval::MAX_STEPS {
+        Err(OperationError::WorkLimit { effective })
+    } else {
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        let unit = model.add_source("namespace-operations.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&model)
+    }
+    fn invoke(
+        r: &mut ResolvedModel,
+        receiver: &str,
+        operation: &str,
+        args: &[DerivedValue],
+    ) -> Result<DerivedValue, OperationError> {
+        let receiver = r.resolve_qualified(receiver).unwrap();
+        r.invoke_operation(
+            receiver,
+            &format!("Root-Namespaces-Namespace-{operation}"),
+            args,
+        )
+        .map(|result| result.value)
+    }
+    fn empty() -> DerivedValue {
+        DerivedValue::Elements(vec![])
+    }
+    #[test]
+    fn collection_validation_and_body_share_the_operation_budget() {
+        let mut r = fixture("package P;");
+        let p = r.resolve_qualified("P").unwrap();
+        let oversized = DerivedValue::Elements(vec![p; crate::eval::MAX_STEPS / 4 + 1]);
+        assert!(matches!(
+            invoke(&mut r, "P", "importedMemberships_Namespace", &[oversized]),
+            Err(OperationError::WorkLimit { .. })
+        ));
+        let source = "a".repeat(crate::eval::MAX_STEPS / 9 + 1);
+        assert!(matches!(
+            invoke(
+                &mut r,
+                "P",
+                "qualificationOf_String",
+                &[DerivedValue::Str(source)]
+            ),
+            Err(OperationError::WorkLimit { .. })
+        ));
+        assert_eq!(
+            invoke(
+                &mut r,
+                "P",
+                "unqualifiedNameOf_String",
+                &[DerivedValue::Str("a::b".into())]
+            )
+            .unwrap(),
+            DerivedValue::Str("b".into())
+        );
+    }
+    #[test]
+    fn namespace_properties_share_complete_domain_and_refuse_inverse_orphans() {
+        let mut r = fixture("package P { class A; alias Alias for A; } class Other;");
+        let p = r.resolve_qualified("P").unwrap();
+        let a = r.resolve_qualified("P::A").unwrap();
+        let other = r.resolve_qualified("Other").unwrap();
+        let declarations = [
+            "Root-Namespaces-Namespace-importedMembership",
+            "Root-Namespaces-Namespace-membership",
+            "Root-Namespaces-Namespace-member",
+        ];
+        let mut row = NamespaceRow::default();
+        let mut steps = 0;
+        assert!(row.property(&mut r, p, declarations[0], &mut steps).is_ok());
+        let cold = steps;
+        let members = row
+            .property(&mut r, p, declarations[2], &mut steps)
+            .unwrap();
+        assert_eq!(
+            members,
+            DerivedValue::References(vec![Reference::Element(a)])
+        );
+        assert!(
+            steps - cold <= 5,
+            "the completed row domain should be reused"
+        );
+        assert!(r.property(other, "importedMembership").is_err());
+        for name in ["importedMembership", "membership", "member"] {
+            assert!(r.property(p, name).is_ok(), "{name}");
+        }
+        let membership = r.b.elements[a.0].owning_relationship.unwrap();
+        r.b.elements[p.0]
+            .owned_relationships
+            .make_mut()
+            .retain(|&rel| rel != membership);
+        for declaration in declarations {
+            assert!(row.property(&mut r, p, declaration, &mut steps).is_err());
+        }
+        for name in ["importedMembership", "membership", "member"] {
+            assert!(r.property(p, name).is_err(), "{name}");
+        }
+    }
+    #[test]
+    fn sibling_namespace_queries_share_raw_import_absence_with_cumulative_work() {
+        let count = 1000;
+        let source: String = (0..count).map(|i| format!("package P{i};")).collect();
+        let mut r = fixture(&source);
+        let packages: Vec<_> = (0..count)
+            .map(|i| r.resolve_qualified(&format!("P{i}")).unwrap())
+            .collect();
+        let declaration = "Root-Namespaces-Namespace-importedMembership";
+        let mut cold = 0;
+        assert!(
+            NamespaceRow::default()
+                .property(&mut r, packages[0], declaration, &mut cold)
+                .is_ok()
+        );
+        let raw = r.b.stored_structure.as_ref().unwrap().clone();
+        assert!(!raw.has_authored_import);
+        assert!(cold >= r.b.elements.len());
+        let initial = crate::eval::MAX_STEPS - count * 16;
+        let mut steps = initial;
+        for package in packages {
+            assert!(
+                NamespaceRow::default()
+                    .property(&mut r, package, declaration, &mut steps)
+                    .is_ok()
+            );
+            assert!(std::sync::Arc::ptr_eq(
+                &raw,
+                r.b.stored_structure.as_ref().unwrap()
+            ));
+        }
+        assert!(steps - initial <= count * 16);
+    }
+
+    #[test]
+    fn orphan_import_presence_survives_forward_omission_and_stored_implied_flag() {
+        let mut r = fixture("package P; package Q { private import P::*; }");
+        let q = r.resolve_qualified("Q").unwrap();
+        let import = r.b.elements[q.0].owned_relationships[0];
+        let original_type = r.b.elements[import].ty;
+        assert!(conforms(original_type, "Import"));
+        r.b.elements[q.0].owned_relationships.make_mut().clear();
+        r.b.elements[import]
+            .props
+            .insert("isImplied", serde_json::json!(true));
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_ok());
+        assert!(invoke(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_err());
+        assert!(r.b.stored_structure.as_ref().unwrap().has_authored_import);
+        // Same-size row edits must invalidate the immutable presence fact.
+        r.b.elements[import].ty = "Dependency";
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_ok());
+        assert!(!r.b.stored_structure.as_ref().unwrap().has_authored_import);
+        r.b.elements[import].ty = original_type;
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_ok());
+        assert!(invoke(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_err());
+    }
+
+    #[test]
+    fn namespace_row_and_nested_name_work_use_the_callers_allowance() {
+        let mut r = fixture("package P { class A; }");
+        let p = r.resolve_qualified("P").unwrap();
+        let a = r.resolve_qualified("P::A").unwrap();
+        let mut row = NamespaceRow::default();
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(
+            row.property(&mut r, p, "Root-Namespaces-Namespace-member", &mut steps)
+                .is_err()
+        );
+        let mut retry = 0;
+        assert!(
+            row.property(&mut r, p, "Root-Namespaces-Namespace-member", &mut retry)
+                .is_ok()
+        );
+        let m = Membership {
+            relationship: r.b.elements[a.0].owning_relationship.unwrap(),
+            member: a.0,
+            visibility: "public",
+        };
+        let mut steps = crate::eval::MAX_STEPS - 5;
+        assert!(matches!(
+            member_names(
+                &mut r,
+                &m,
+                &mut steps,
+                "Root-Namespaces-Namespace-namesOf_Element"
+            ),
+            Err(OperationError::WorkLimit { .. })
+        ));
+        let mut steps = 0;
+        assert_eq!(
+            member_names(
+                &mut r,
+                &m,
+                &mut steps,
+                "Root-Namespaces-Namespace-namesOf_Element"
+            )
+            .unwrap(),
+            vec!["A".to_owned()]
+        );
+    }
+    #[test]
+    fn qualified_name_syntax_uses_lexer_and_reference_spelling() {
+        let mut r = fixture("package P;");
+        for (source, prefix, name) in [
+            ("a", None, "a"),
+            ("a::b", Some("a"), "b"),
+            ("$::a", Some("$"), "a"),
+            ("$::a::b", Some("$::a"), "b"),
+            ("'a::b'::'c\\'d'", Some("'a::b'"), "c'd"),
+            ("'function'::'a\\nb'", Some("'function'"), "a\nb"),
+            ("'Ω' :: '雪'", Some("'Ω'"), "雪"),
+            ("a // note\n :: b", Some("a"), "b"),
+        ] {
+            let args = [DerivedValue::Str(source.into())];
+            assert_eq!(
+                invoke(&mut r, "P", "qualificationOf_String", &args).unwrap(),
+                prefix.map_or(DerivedValue::Null, |s| DerivedValue::Str(s.into()))
+            );
+            assert_eq!(
+                invoke(&mut r, "P", "unqualifiedNameOf_String", &args).unwrap(),
+                DerivedValue::Str(name.into())
+            );
+        }
+        for source in [
+            "",
+            "a::",
+            "a b",
+            "::a",
+            "$a",
+            "$::",
+            "a::*",
+            "function",
+            "a::function",
+            "'bad\\q'",
+            "'unclosed",
+            "a /* comment */ :: b",
+        ] {
+            assert!(
+                matches!(
+                    invoke(
+                        &mut r,
+                        "P",
+                        "qualificationOf_String",
+                        &[DerivedValue::Str(source.into())]
+                    ),
+                    Err(OperationError::InvalidArgument {
+                        issue: OperationArgumentIssue::InvalidSyntax,
+                        ..
+                    })
+                ),
+                "{source}"
+            );
+        }
+        let p = r.resolve_qualified("P").unwrap();
+        assert!(matches!(
+            invoke(
+                &mut r,
+                "P",
+                "qualificationOf_String",
+                &[DerivedValue::Element(p)]
+            ),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::WrongShape,
+                ..
+            })
+        ));
+        let large = "a".repeat(crate::eval::MAX_STEPS / 8 + 1);
+        assert!(matches!(
+            invoke(
+                &mut r,
+                "P",
+                "qualificationOf_String",
+                &[DerivedValue::Str(large)]
+            ),
+            Err(OperationError::WorkLimit { .. })
+        ));
+    }
+    #[test]
+    fn namespace_memberships_preserve_alias_identity_names_and_relative_visibility() {
+        let mut r = fixture(
+            "package P { class <a> A; alias Alias for A; private class Hidden; package Q { class B; } } package Other { class O; }",
+        );
+        let a = r.resolve_qualified("P::A").unwrap();
+        let hidden = r.resolve_qualified("P::Hidden").unwrap();
+        let outside = r.resolve_qualified("Other::O").unwrap();
+        let other_membership = r.b.elements[outside.0].owning_relationship.unwrap();
+        let hidden_membership = r.b.elements[hidden.0].owning_relationship.unwrap();
+        assert_eq!(
+            invoke(&mut r, "P", "namesOf_Element", &[DerivedValue::Element(a)]).unwrap(),
+            DerivedValue::Strings(vec!["a".into(), "A".into(), "Alias".into()])
+        );
+        assert_eq!(
+            invoke(
+                &mut r,
+                "P",
+                "namesOf_Element",
+                &[DerivedValue::Element(outside)]
+            )
+            .unwrap(),
+            DerivedValue::Strings(vec![])
+        );
+        assert_eq!(
+            invoke(
+                &mut r,
+                "P",
+                "visibilityOf_Membership",
+                &[DerivedValue::Element(ElementRef(other_membership))]
+            )
+            .unwrap(),
+            DerivedValue::Str("private".into())
+        );
+        assert_eq!(
+            invoke(
+                &mut r,
+                "P",
+                "membershipsOfVisibility_VisibilityKind_Namespace",
+                &[DerivedValue::Str("private".into()), empty()]
+            )
+            .unwrap(),
+            DerivedValue::References(vec![Reference::Element(ElementRef(hidden_membership))])
+        );
+        let p = r.resolve_qualified("P").unwrap();
+        let members = invoke(
+            &mut r,
+            "P",
+            "membershipsOfVisibility_VisibilityKind_Namespace",
+            &[DerivedValue::Null, DerivedValue::Elements(vec![p])],
+        )
+        .unwrap();
+        assert!(matches!(members, DerivedValue::References(ref members) if members.len() == 4));
+        assert_eq!(
+            invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).unwrap(),
+            DerivedValue::References(vec![])
+        );
+        assert!(matches!(
+            invoke(
+                &mut r,
+                "P",
+                "membershipsOfVisibility_VisibilityKind_Namespace",
+                &[DerivedValue::Str("sideways".into()), empty()]
+            ),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::InvalidEnumValue,
+                ..
+            })
+        ));
+    }
+    #[test]
+    fn visible_recursion_respects_ownership_visibility_and_type_overrides() {
+        let mut r = fixture(
+            "package P { public package Q { package B; } private package R { package C; } } class A;",
+        );
+        for (recursive, all, count) in [
+            (false, false, 1),
+            (true, false, 2),
+            (false, true, 2),
+            (true, true, 4),
+        ] {
+            let result = invoke(
+                &mut r,
+                "P",
+                "visibleMemberships_Namespace_Boolean_Boolean",
+                &[
+                    empty(),
+                    DerivedValue::Bool(recursive),
+                    DerivedValue::Bool(all),
+                ],
+            )
+            .unwrap();
+            assert!(
+                matches!(result, DerivedValue::References(ref result) if result.len() == count)
+            );
+        }
+        assert!(matches!(
+            invoke(
+                &mut r,
+                "A",
+                "visibleMemberships_Namespace_Boolean_Boolean",
+                &[
+                    empty(),
+                    DerivedValue::Bool(false),
+                    DerivedValue::Bool(false)
+                ]
+            ),
+            Err(OperationError::Incomplete {
+                effective: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean"
+            })
+        ));
+    }
+    #[test]
+    fn unrelated_imports_do_not_poison_local_inverse_membership_proofs() {
+        let mut r = fixture("package P { class A; } package Q { private import P::*; }");
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_ok());
+        assert!(invoke(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_ok());
+        let mut r = fixture("package P { class A; }");
+        let before = r.b.elements.len();
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_ok());
+        assert_eq!(r.b.elements.len(), before);
+        assert!(r.b.implied.is_none());
+        let a = r.resolve_qualified("P::A").unwrap();
+        let p = r.resolve_qualified("P").unwrap();
+        let membership = r.b.elements[a.0].owning_relationship.unwrap();
+        r.b.elements[p.0]
+            .owned_relationships
+            .make_mut()
+            .retain(|&rel| rel != membership);
+        assert!(invoke(&mut r, "P", "importedMemberships_Namespace", &[empty()]).is_err());
+    }
+}
+
+#[cfg(test)]
+mod type_memberships;
+
+#[cfg(test)]
+mod recursive_features;
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces/imports.rs b/crates/sysmlv2-model/src/json/operations/namespaces/imports.rs
new file mode 100644
index 0000000..ce702e1
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces/imports.rs
@@ -0,0 +1,992 @@
+//! One checked Namespace membership composition for operation and property reads.
+use super::*;
+use std::collections::HashMap;
+
+pub(super) struct Sequence {
+    pub imported: Vec<Membership>,
+    pub all: Vec<Membership>,
+}
+
+pub(super) fn references(members: Vec<Membership>) -> DerivedValue {
+    DerivedValue::References(
+        members
+            .into_iter()
+            .map(|m| Reference::Element(ElementRef(m.relationship)))
+            .collect(),
+    )
+}
+pub(super) fn exclusions(value: &DerivedValue) -> Vec<usize> {
+    match value {
+        DerivedValue::Elements(values) => values.iter().map(|e| e.0).collect(),
+        DerivedValue::References(values) => values
+            .iter()
+            .map(|r| match r {
+                Reference::Element(e) => e.0,
+                _ => unreachable!("validated local Namespace"),
+            })
+            .collect(),
+        _ => unreachable!("validated Namespace collection"),
+    }
+}
+// Depth counts namespace import and containment edges, not helper dispatch
+// within the same namespace. Every public selector starts at its owner at zero.
+fn depth_limit(depth: usize, effective: &'static str) -> Result<(), OperationError> {
+    if depth > crate::json::MAX_RESOLUTION_DEPTH {
+        Err(OperationError::Incomplete { effective })
+    } else {
+        Ok(())
+    }
+}
+#[derive(Clone, Copy)]
+enum Traversal {
+    CheckedTypes,
+    PackagesOnly,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn memberships_of_visibility(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    requested: Option<&str>,
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+) -> Result<Vec<Membership>, OperationError> {
+    memberships_of_visibility_builder(
+        &mut r.b,
+        raw,
+        owner,
+        excluded,
+        requested,
+        steps,
+        effective,
+        depth,
+        Traversal::CheckedTypes,
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub(super) fn visible(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    recursive: bool,
+    all: bool,
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+) -> Result<Vec<Membership>, OperationError> {
+    visible_builder(
+        &mut r.b,
+        raw,
+        owner,
+        excluded,
+        recursive,
+        all,
+        steps,
+        effective,
+        depth,
+        Traversal::CheckedTypes,
+    )
+}
+/// Visibility-specific imports for the shared Type certificate. The restricted
+/// traversal prevents recursive Type proof dependencies; non-Type namespace
+/// providers still use exactly the operation engine's import/visibility algebra.
+type TypeImports = (
+    Vec<crate::json::membership_projection::Membership>,
+    Vec<crate::json::membership_projection::Membership>,
+);
+pub(in crate::json) fn type_imports(
+    b: &mut crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    steps: &mut usize,
+) -> Result<TypeImports, OperationError> {
+    const EFFECTIVE: &str = "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean";
+    let mut result = (Vec::new(), Vec::new());
+    for (access, members) in [("public", &mut result.0), ("protected", &mut result.1)] {
+        let imported = imported_builder(
+            b,
+            raw,
+            owner,
+            excluded,
+            Some(access),
+            steps,
+            EFFECTIVE,
+            0,
+            Traversal::PackagesOnly,
+        )?;
+        charge(steps, imported.len(), EFFECTIVE)?;
+        members.extend(imported.into_iter().map(|m| {
+            crate::json::membership_projection::Membership {
+                relationship: m.relationship,
+                member: m.member,
+            }
+        }));
+    }
+    Ok(result)
+}
+fn owned(
+    b: &crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Vec<Membership>, OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    if !raw
+        .import_domains(b, steps)
+        .ok_or_else(incomplete)?
+        .owner_complete(owner)
+    {
+        return Err(incomplete());
+    }
+    let result = memberships_builder(b, raw, owner, steps, effective)?;
+    Ok(result)
+}
+fn unique(members: impl IntoIterator<Item = Membership>) -> Vec<Membership> {
+    let mut seen = HashSet::new();
+    members
+        .into_iter()
+        .filter(|m| seen.insert(m.relationship))
+        .collect()
+}
+#[allow(clippy::too_many_arguments)]
+fn import_builder(
+    b: &mut crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    relationship: usize,
+    excluded: &[usize],
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+    policy: Traversal,
+) -> Result<Vec<Membership>, OperationError> {
+    depth_limit(depth, effective)?;
+    charge(steps, excluded.len().saturating_add(12), effective)?;
+    let incomplete = || OperationError::Incomplete { effective };
+    let target =
+        crate::json::import_memberships::checked_import_target(b, raw, owner, relationship, steps)
+            .ok_or_else(incomplete)?;
+    let recursive = target.recursive;
+    let all = target.all;
+    let imported_element = target.element;
+    let mut result = target.membership.map_or_else(Vec::new, |membership| {
+        vec![Membership {
+            relationship: membership,
+            member: imported_element,
+            visibility: visibility_builder(b, membership)
+                .expect("checked imported Membership visibility"),
+        }]
+    });
+    if (target.membership.is_none() || recursive)
+        && conforms(b.elements[imported_element].ty, "Namespace")
+        && !excluded.contains(&imported_element)
+    {
+        result.extend(visible_builder(
+            b,
+            raw,
+            imported_element,
+            excluded,
+            recursive,
+            all,
+            steps,
+            effective,
+            depth + 1,
+            policy,
+        )?);
+    }
+    Ok(unique(result))
+}
+#[allow(clippy::too_many_arguments)]
+fn imported_builder(
+    b: &mut crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    requested: Option<&str>,
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+    policy: Traversal,
+) -> Result<Vec<Membership>, OperationError> {
+    depth_limit(depth, effective)?;
+    let incomplete = || OperationError::Incomplete { effective };
+    let relationships = semantic_ownership::owned_relationships(b, owner).ok_or_else(incomplete)?;
+    charge(
+        steps,
+        relationships.len().saturating_add(excluded.len()),
+        effective,
+    )?;
+    let relationships: Vec<_> = relationships
+        .iter()
+        .filter(|&rel| conforms(b.elements[rel].ty, "Import"))
+        .collect();
+    let mut excluded = excluded.to_vec();
+    excluded.push(owner);
+    let mut result = Vec::new();
+    for rel in relationships {
+        let access = visibility_builder(b, rel).ok_or_else(incomplete)?;
+        if requested.is_some_and(|v| v != access) {
+            continue;
+        }
+        let imported = import_builder(
+            b, raw, owner, rel, &excluded, steps, effective, depth, policy,
+        )?;
+        charge(steps, imported.len(), effective)?;
+        result.extend(imported.into_iter().map(|mut m| {
+            m.visibility = access;
+            m
+        }));
+    }
+    Ok(unique(result))
+}
+#[allow(clippy::too_many_arguments)]
+fn memberships_of_visibility_builder(
+    b: &mut crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    requested: Option<&str>,
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+    policy: Traversal,
+) -> Result<Vec<Membership>, OperationError> {
+    depth_limit(depth, effective)?;
+    let mut result = owned(b, raw, owner, steps, effective)?;
+    if result
+        .iter()
+        .any(|m| conforms(b.elements[m.relationship].ty, "ElementFilterMembership"))
+    {
+        // Visibility-specific unions and Package's filtered imported collection
+        // have distinct normative bodies. Do not silently choose a filter
+        // evaluation policy for this contextual visible-import path.
+        return Err(OperationError::Incomplete { effective });
+    }
+    result.retain(|m| requested.is_none_or(|v| v == m.visibility));
+    result.extend(imported_builder(
+        b, raw, owner, excluded, requested, steps, effective, depth, policy,
+    )?);
+    charge(steps, result.len(), effective)?;
+    Ok(unique(result))
+}
+#[allow(clippy::too_many_arguments)]
+fn visible_builder(
+    b: &mut crate::json::Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    recursive: bool,
+    all: bool,
+    steps: &mut usize,
+    effective: &'static str,
+    depth: usize,
+    policy: Traversal,
+) -> Result<Vec<Membership>, OperationError> {
+    depth_limit(depth, effective)?;
+    if matches!(policy, Traversal::PackagesOnly)
+        && !matches!(
+            b.elements[owner].ty,
+            "Namespace" | "Package" | "LibraryPackage"
+        )
+    {
+        return Err(OperationError::Incomplete { effective });
+    }
+    let mut result = memberships_of_visibility_builder(
+        b,
+        raw,
+        owner,
+        excluded,
+        if all { None } else { Some("public") },
+        steps,
+        effective,
+        depth,
+        policy,
+    )?;
+    if recursive {
+        let children = owned(b, raw, owner, steps, effective)?;
+        charge(
+            steps,
+            excluded.len().saturating_add(children.len()),
+            effective,
+        )?;
+        let mut excluded = excluded.to_vec();
+        excluded.push(owner);
+        for m in children {
+            if conforms(b.elements[m.relationship].ty, "OwningMembership")
+                && conforms(b.elements[m.member].ty, "Namespace")
+                && (all || m.visibility == "public")
+            {
+                result.extend(visible_builder(
+                    b,
+                    raw,
+                    m.member,
+                    &excluded,
+                    true,
+                    all,
+                    steps,
+                    effective,
+                    depth + 1,
+                    policy,
+                )?);
+            }
+        }
+    }
+    // Type visibility uses the same complete Membership reduction. Namespace
+    // exclusions affect import contributions, never the inheritance graph.
+    if conforms(b.elements[owner].ty, "Type") {
+        charge(steps, excluded.len().saturating_add(1), effective)?;
+        let mut inherited_excluded = excluded.to_vec();
+        inherited_excluded.push(owner);
+        let inherited = b
+            .checked_type_memberships_for_visibility(owner, &inherited_excluded, recursive, steps)
+            .map_err(|_| OperationError::Incomplete { effective })?
+            .inherited;
+        charge(steps, inherited.len(), effective)?;
+        for m in inherited {
+            let visibility = visibility_builder(b, m.relationship)
+                .ok_or(OperationError::Incomplete { effective })?;
+            if all || visibility == "public" {
+                result.push(Membership {
+                    relationship: m.relationship,
+                    member: m.member,
+                    visibility,
+                });
+            }
+        }
+    }
+    charge(steps, result.len(), effective)?;
+    Ok(unique(result))
+}
+pub(super) fn sequence(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    owner: usize,
+    excluded: &[usize],
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Sequence, OperationError> {
+    let owned = owned(&r.b, raw, owner, steps, effective)?;
+    let mut imported = imported_builder(
+        &mut r.b,
+        raw,
+        owner,
+        excluded,
+        None,
+        steps,
+        effective,
+        0,
+        Traversal::CheckedTypes,
+    )?;
+    // The admitted filter proof either leaves an unfiltered collection intact
+    // or proves every candidate excluded. Universal exclusion commutes with
+    // collision pruning and needs no irrelevant effective-name certificate.
+    filter_memberships(r, raw, owner, &owned, &mut imported, steps, effective)?;
+    // Namespace's documented distinguishability exclusion applies to its
+    // importedMembership collection, not visibility-specific import unions.
+    if !imported.is_empty() {
+        let mut by_name: HashMap<String, Vec<(usize, &'static str)>> = HashMap::new();
+        let mut seen = HashSet::new();
+        let mut named = HashSet::new();
+        for m in owned.iter().chain(&imported) {
+            charge(steps, 1, effective)?;
+            if !seen.insert(m.relationship) {
+                continue;
+            }
+            for name in member_names(r, m, steps, effective)? {
+                named.insert(m.relationship);
+                by_name
+                    .entry(name)
+                    .or_default()
+                    .push((m.relationship, r.b.elements[m.member].ty));
+            }
+        }
+        let mut colliding = HashSet::new();
+        for group in by_name.values() {
+            charge(steps, group.len().saturating_mul(group.len()), effective)?;
+            for &(a, ta) in group {
+                if group
+                    .iter()
+                    .any(|&(b, tb)| a != b && (conforms(ta, tb) || conforms(tb, ta)))
+                {
+                    colliding.insert(a);
+                }
+            }
+        }
+        charge(steps, imported.len().saturating_add(owned.len()), effective)?;
+        let own: HashSet<_> = owned
+            .iter()
+            .map(|m| m.relationship)
+            .filter(|m| named.contains(m))
+            .collect();
+        imported.retain(|m| !colliding.contains(&m.relationship) && !own.contains(&m.relationship));
+    }
+    let mut all = unique(owned.into_iter().chain(imported.iter().cloned()));
+    if conforms(r.b.elements[owner].ty, "Type") {
+        let inherited =
+            r.b.checked_type_memberships_for_visibility(owner, excluded, false, steps)
+                .map_err(|_| OperationError::Incomplete { effective })?
+                .inherited;
+        charge(steps, inherited.len(), effective)?;
+        for m in inherited {
+            all.push(Membership {
+                relationship: m.relationship,
+                member: m.member,
+                visibility: visibility(r, m.relationship)
+                    .ok_or(OperationError::Incomplete { effective })?,
+            });
+        }
+        all = unique(all);
+    }
+    Ok(Sequence { imported, all })
+}
+
+fn filter_memberships(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    owner: usize,
+    owned: &[Membership],
+    imported: &mut Vec<Membership>,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<(), OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    // ElementFilterMembership defines no filtering for a general Namespace;
+    // this composition is specifically Package::importedMemberships.
+    if !conforms(r.b.elements[owner].ty, "Package") {
+        return Ok(());
+    }
+    charge(steps, owned.len().saturating_mul(5), effective)?;
+    for m in owned
+        .iter()
+        .filter(|m| conforms(r.b.elements[m.relationship].ty, "ElementFilterMembership"))
+    {
+        let relation = &r.b.elements[m.relationship];
+        let condition = &r.b.elements[m.member];
+        if relation
+            .props
+            .get("condition")
+            .is_some_and(|v| v.as_reference() != Some(condition.id))
+            || condition
+                .props
+                .get("owningFilter")
+                .is_some_and(|v| v.as_reference() != Some(relation.id))
+            || condition
+                .props
+                .get("conditionedPackage")
+                .is_some_and(|v| v.as_reference() != Some(r.b.elements[owner].id))
+        {
+            return Err(incomplete());
+        }
+    }
+    charge(steps, owned.len(), effective)?;
+    let conditions: Vec<_> = owned
+        .iter()
+        .filter(|m| conforms(r.b.elements[m.relationship].ty, "ElementFilterMembership"))
+        .map(|m| m.member)
+        .collect();
+    charge(steps, conditions.len(), effective)?;
+    if conditions.is_empty() || imported.is_empty() {
+        return Ok(());
+    }
+    for &condition in &conditions {
+        // ElementFilterMembership.condition is typed Expression; a Boolean
+        // literal is Boolean-valued without being a BooleanExpression metaclass.
+        if !conforms(r.b.elements[condition].ty, "Expression") {
+            return Err(incomplete());
+        }
+        if r.b.elements[condition].ty == "LiteralBoolean"
+            && r.b.elements[condition]
+                .props
+                .get("value")
+                .and_then(|v| v.as_bool())
+                == Some(false)
+        {
+            let report = r.model_level_evaluability_with_budget(ElementRef(condition), *steps);
+            *steps = report.steps;
+            if report.classification != crate::json::ModelLevelEvaluability::Evaluable {
+                return Err(incomplete());
+            }
+            imported.clear();
+            return Ok(());
+        }
+    }
+    // includeAsMember requires at least one owned metadata occurrence for each
+    // condition. Complete absence proves exclusion without evaluating a
+    // condition in a fabricated metadata context.
+    for m in imported.iter() {
+        charge(steps, 1, effective)?;
+        if raw.metadata_annotation_targets.contains(&m.member)
+            || r.b
+                .metadata_of
+                .get(&m.member)
+                .is_some_and(|v| !v.is_empty())
+        {
+            return Err(incomplete());
+        }
+    }
+    imported.clear();
+    Ok(())
+}
+
+pub(super) fn invoke_import(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    excluded: &[usize],
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<DerivedValue, OperationError> {
+    let (_, _, result) =
+        super::with_stable_evidence(r, receiver, steps, effective, |r, raw, steps| {
+            let incomplete = || OperationError::Incomplete { effective };
+            let owner =
+                semantic_ownership::checked_relationship_carrier(&r.b, raw, receiver.0, steps)
+                    .flatten()
+                    .ok_or_else(incomplete)?;
+            if !raw
+                .import_domains(&r.b, steps)
+                .ok_or_else(incomplete)?
+                .owner_complete(owner)
+            {
+                return Err(incomplete());
+            }
+            import_builder(
+                &mut r.b,
+                raw,
+                owner,
+                receiver.0,
+                excluded,
+                steps,
+                effective,
+                0,
+                Traversal::CheckedTypes,
+            )
+        })?;
+    Ok(references(result))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+    use serde_json::json;
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        let unit = m.add_source("checked-imports.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&m)
+    }
+    fn call(
+        r: &mut ResolvedModel,
+        name: &str,
+        operation: &str,
+        arguments: &[DerivedValue],
+    ) -> Result<DerivedValue, OperationError> {
+        let e = r.resolve_qualified(name).unwrap();
+        r.invoke_operation(
+            e,
+            &format!("Root-Namespaces-Namespace-{operation}"),
+            arguments,
+        )
+        .map(|v| v.value)
+    }
+    fn empty() -> DerivedValue {
+        DerivedValue::Elements(vec![])
+    }
+    fn imported(r: &mut ResolvedModel, name: &str) -> DerivedValue {
+        call(r, name, "importedMemberships_Namespace", &[empty()]).unwrap()
+    }
+    fn refs(value: DerivedValue) -> Vec<ElementRef> {
+        let DerivedValue::References(v) = value else {
+            panic!("expected references")
+        };
+        v.into_iter()
+            .map(|v| match v {
+                Reference::Element(e) => e,
+                _ => panic!("external"),
+            })
+            .collect()
+    }
+    #[test]
+    fn namespace_imports_preserve_alias_identity_and_contextual_visibility() {
+        let mut r = fixture(
+            "package P { class A; alias Alias for A; private class Hidden; } package Q { protected import P::Alias; private import P::*; }",
+        );
+        let p = r.resolve_qualified("P").unwrap();
+        let a = r.resolve_qualified("P::A").unwrap();
+        let alias = r.b.elements[p.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&x| r.b.elements[x].ty == "Membership")
+            .unwrap();
+        let a_mem = r.b.elements[a.0].owning_relationship.unwrap();
+        assert_eq!(
+            refs(imported(&mut r, "Q")),
+            [ElementRef(alias), ElementRef(a_mem)]
+        );
+        assert_eq!(
+            call(
+                &mut r,
+                "Q",
+                "visibilityOf_Membership",
+                &[DerivedValue::Element(ElementRef(alias))]
+            )
+            .unwrap(),
+            DerivedValue::Str("protected".into())
+        );
+        assert_eq!(
+            call(&mut r, "Q", "namesOf_Element", &[DerivedValue::Element(a)]).unwrap(),
+            DerivedValue::Strings(vec!["Alias".into(), "A".into()])
+        );
+        assert_eq!(
+            refs(
+                call(
+                    &mut r,
+                    "Q",
+                    "membershipsOfVisibility_VisibilityKind_Namespace",
+                    &[DerivedValue::Str("private".into()), empty()]
+                )
+                .unwrap()
+            ),
+            [ElementRef(a_mem), ElementRef(alias)]
+        );
+        assert!(
+            refs(
+                call(
+                    &mut r,
+                    "Q",
+                    "visibleMemberships_Namespace_Boolean_Boolean",
+                    &[
+                        empty(),
+                        DerivedValue::Bool(false),
+                        DerivedValue::Bool(false)
+                    ]
+                )
+                .unwrap()
+            )
+            .is_empty()
+        );
+        let q = r.resolve_qualified("Q").unwrap();
+        assert_eq!(
+            r.property(q, "importedMembership").unwrap(),
+            json!([{"@id": r.b.elements[alias].id.to_string()}, {"@id": r.b.elements[a_mem].id.to_string()}])
+        );
+    }
+    #[test]
+    fn recursive_imports_and_exclusion_cycles_are_bounded_and_ordered() {
+        let mut r = fixture(
+            "package P { package A { package B; } private package Secret; public import Q::*; } package Q { public import P::*::**; }",
+        );
+        let a = r.resolve_qualified("P::A").unwrap();
+        let b = r.resolve_qualified("P::A::B").unwrap();
+        assert_eq!(
+            refs(imported(&mut r, "Q")),
+            [a, b].map(|e| ElementRef(r.b.elements[e.0].owning_relationship.unwrap()))
+        );
+        let p = r.resolve_qualified("P").unwrap();
+        assert!(
+            refs(
+                call(
+                    &mut r,
+                    "Q",
+                    "importedMemberships_Namespace",
+                    &[DerivedValue::Elements(vec![p])]
+                )
+                .unwrap()
+            )
+            .is_empty()
+        );
+        let q = r.resolve_qualified("Q").unwrap();
+        let rel = r.b.elements[q.0].owned_relationships[0];
+        let operation = "Root-Namespaces-NamespaceImport-importedMemberships_Namespace";
+        let direct = r
+            .invoke_operation(
+                ElementRef(rel),
+                operation,
+                &[DerivedValue::Elements(vec![p])],
+            )
+            .unwrap()
+            .value;
+        assert!(refs(direct).is_empty());
+    }
+    #[test]
+    fn collisions_are_pruned_only_from_the_namespace_imported_collection() {
+        let mut r = fixture(
+            "package A { class X; } package B { class X; } package Q { private import A::*; private import B::*; }",
+        );
+        assert!(refs(imported(&mut r, "Q")).is_empty());
+        let raw = call(
+            &mut r,
+            "Q",
+            "membershipsOfVisibility_VisibilityKind_Namespace",
+            &[DerivedValue::Null, empty()],
+        )
+        .unwrap();
+        assert_eq!(refs(raw).len(), 2);
+    }
+    #[test]
+    fn malformed_import_aliases_flags_and_inverse_owners_refuse_current_reads() {
+        for (key, value) in [
+            ("isRecursive", json!(null)),
+            ("isImportAll", json!("true")),
+            ("importedElement", json!({"@id":"missing"})),
+            ("target", json!([])),
+            ("source", json!([])),
+            ("relatedElement", json!([])),
+        ] {
+            let mut r = fixture("package P { class A; } package Q { private import P::*; }");
+            assert_eq!(refs(imported(&mut r, "Q")).len(), 1);
+            let q = r.resolve_qualified("Q").unwrap();
+            let rel = r.b.elements[q.0].owned_relationships[0];
+            r.b.set(rel, key, value);
+            assert!(
+                call(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_err(),
+                "{key}"
+            );
+        }
+    }
+    #[test]
+    fn namespace_import_budget_and_revision_reuse_do_not_certify_partial_results() {
+        let mut r = fixture("package P { class A; } package Q { private import P::*; }");
+        let q = r.resolve_qualified("Q").unwrap();
+        let mut row = NamespaceRow::default();
+        let declaration = "Root-Namespaces-Namespace-importedMembership";
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert!(row.property(&mut r, q, declaration, &mut steps).is_err());
+        assert_eq!(
+            refs(row.property(&mut r, q, declaration, &mut 0).unwrap()).len(),
+            1
+        );
+        let rel = r.b.elements[q.0].owned_relationships[0];
+        r.b.set(rel, "isRecursive", json!("invalid"));
+        assert!(row.property(&mut r, q, declaration, &mut 0).is_err());
+        assert!(r.b.implied.is_none());
+    }
+    #[test]
+    fn import_proofs_reconstruct_from_compact_and_full_in_both_formats() {
+        for format in [
+            crate::model::GraphFormat::LegacyV2,
+            crate::model::GraphFormat::CanonicalV3,
+        ] {
+            let mut m = Model::with_graph_format(format);
+            let u = m.add_source(
+                "import-replay.kerml",
+                "package P { class A; alias Alias for A; } package Q { public import P::Alias; }",
+            );
+            assert!(u.diagnostics.is_empty());
+            let mut original = ResolvedModel::build(&m);
+            let original_ids: Vec<_> = refs(imported(&mut original, "Q"))
+                .iter()
+                .map(|e| original.element_id(*e))
+                .collect();
+            for document in [
+                crate::json::model_to_compact_json(&m),
+                crate::full::model_to_full_json(&m),
+            ] {
+                let (_, mut loaded, _, _) =
+                    crate::loader::load_document_with_format(&document, &HashMap::new(), format)
+                        .unwrap();
+                let ids: Vec<_> = refs(imported(&mut loaded, "Q"))
+                    .iter()
+                    .map(|e| loaded.element_id(*e))
+                    .collect();
+                assert_eq!(ids, original_ids);
+                let alias = refs(imported(&mut loaded, "Q"))[0];
+                assert_eq!(
+                    call(
+                        &mut loaded,
+                        "Q",
+                        "resolveVisible_String",
+                        &[DerivedValue::Str("Alias".into())]
+                    )
+                    .unwrap(),
+                    DerivedValue::Reference(Reference::Element(alias))
+                );
+                assert_eq!(
+                    call(
+                        &mut loaded,
+                        "Q",
+                        "resolveVisible_String",
+                        &[DerivedValue::Str("A".into())]
+                    )
+                    .unwrap(),
+                    DerivedValue::Null
+                );
+            }
+        }
+    }
+    #[test]
+    fn recursive_member_import_keeps_its_membership_when_namespace_is_excluded() {
+        let mut r = fixture("package P { package A; } package Q { public import P::**; }");
+        let p = r.resolve_qualified("P").unwrap();
+        let q = r.resolve_qualified("Q").unwrap();
+        let membership = ElementRef(r.b.elements[p.0].owning_relationship.unwrap());
+        let relationship = ElementRef(r.b.elements[q.0].owned_relationships[0]);
+        let result = r
+            .invoke_operation(
+                relationship,
+                "Root-Namespaces-MembershipImport-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![p])],
+            )
+            .unwrap();
+        assert_eq!(refs(result.value), [membership]);
+        assert_eq!(refs(imported(&mut r, "Q")).len(), 2);
+    }
+    #[test]
+    fn omitted_import_visibility_is_private_and_literal_false_filters_are_proven() {
+        let mut r = fixture("package P { class A; } package Q { public import P::*; }");
+        let q = r.resolve_qualified("Q").unwrap();
+        let rel = r.b.elements[q.0].owned_relationships[0];
+        let mut props = crate::properties::Properties::new();
+        for (key, value) in r.b.elements[rel].props.to_json() {
+            if key != "visibility" {
+                props.insert(&key, value);
+            }
+        }
+        r.b.elements[rel].props = props;
+        assert_eq!(refs(imported(&mut r, "Q")).len(), 1);
+        assert!(
+            refs(
+                call(
+                    &mut r,
+                    "Q",
+                    "visibleMemberships_Namespace_Boolean_Boolean",
+                    &[
+                        empty(),
+                        DerivedValue::Bool(false),
+                        DerivedValue::Bool(false)
+                    ]
+                )
+                .unwrap()
+            )
+            .is_empty()
+        );
+        let mut r =
+            fixture("package P { class A; } package Q { private import P::*; filter false; }");
+        assert!(refs(imported(&mut r, "Q")).is_empty());
+        let mut r = fixture("package P { class A; } package Q { private import P::*[false]; }");
+        let q = r.resolve_qualified("Q").unwrap();
+        let mut steps = 0;
+        let raw = StoredStructure::for_query(&mut r.b, &mut steps).unwrap();
+        assert!(
+            raw.import_domains(&r.b, &mut steps)
+                .unwrap()
+                .owner_complete(q.0)
+        );
+        assert!(call(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_err());
+        let import = r.b.elements[q.0].owned_relationships[0];
+        let child = r.b.elements[import].children[0];
+        r.b.elements[child].owning_relationship = None;
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(
+            !raw.import_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(q.0)
+        );
+    }
+    #[test]
+    fn private_membership_import_type_features_survive_full_and_compact_replay() {
+        const LIB: &str = "standard library package Base { classifier Anything; datatype DataValue specializes Anything; feature things:Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things; }";
+        for format in [
+            crate::model::GraphFormat::LegacyV2,
+            crate::model::GraphFormat::CanonicalV3,
+        ] {
+            let mut model = Model::with_graph_format(format);
+            model.add_library_source("private-import-library.kerml", LIB);
+            let u = model.add_source("private-import-types.kerml", "package P { class C; alias Alias for C; } class A { private import P::Alias; in feature x; }");
+            assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+            let names = crate::json::library_name_map(&model);
+            let mut original = ResolvedModel::build(&model);
+            let a = original.resolve_qualified("A").unwrap();
+            assert!(original.type_feature_report(a).projections.is_ok());
+            for document in [
+                crate::json::model_to_compact_json(&model),
+                crate::full::model_to_full_json(&model),
+            ] {
+                let (mut replay, _, _, _) =
+                    crate::loader::load_document_with_format(&document, &names, format).unwrap();
+                replay.add_library_source("private-import-library.kerml", LIB);
+                let mut loaded = ResolvedModel::build(&replay);
+                let a = loaded.resolve_qualified("A").unwrap();
+                let x = loaded.resolve_qualified("A::x").unwrap();
+                let report = loaded.type_feature_report(a);
+                assert_eq!(report.projections.unwrap().inputs, [x], "{format:?}");
+                let import = loaded.b.elements[a.0]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| loaded.b.elements[rel].ty == "MembershipImport")
+                    .unwrap();
+                let selected = loaded.b.elements[import]
+                    .props
+                    .get("importedMembership")
+                    .unwrap()
+                    .as_reference()
+                    .unwrap();
+                loaded
+                    .b
+                    .set(import, "target", json!([{"@id":selected.to_string()}]));
+                // MembershipImport redefines Relationship.target with the
+                // Membership, not its effectively imported member Element.
+                assert_eq!(
+                    loaded.type_feature_report(a).projections.unwrap().inputs,
+                    [x]
+                );
+                let member = loaded.resolve_qualified("P::C").unwrap();
+                let member_id = loaded.element_id(member);
+                loaded
+                    .b
+                    .set(import, "target", json!([{"@id":member_id.to_string()}]));
+                assert!(loaded.type_feature_report(a).projections.is_err());
+                loaded
+                    .b
+                    .set(import, "target", json!([{"@id":selected.to_string()}]));
+                assert_eq!(
+                    loaded.type_feature_report(a).projections.unwrap().inputs,
+                    [x]
+                );
+            }
+        }
+    }
+    #[test]
+    fn package_filter_aliases_must_agree_with_the_owned_condition() {
+        for (on_condition, key) in [
+            (false, "condition"),
+            (true, "owningFilter"),
+            (true, "conditionedPackage"),
+        ] {
+            for malformed in [json!(null), json!({"@id":"not-an-element"})] {
+                let mut r = fixture(
+                    "package P { class A; } package Q { private import P::*; filter false; }",
+                );
+                assert!(refs(imported(&mut r, "Q")).is_empty());
+                let q = r.resolve_qualified("Q").unwrap();
+                let membership = r.b.elements[q.0]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| r.b.elements[rel].ty == "ElementFilterMembership")
+                    .unwrap();
+                let condition = r.b.elements[membership].children[0];
+                r.b.set(
+                    if on_condition { condition } else { membership },
+                    key,
+                    malformed,
+                );
+                assert!(
+                    call(&mut r, "Q", "importedMemberships_Namespace", &[empty()]).is_err(),
+                    "{key}"
+                );
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod depth_tests;
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces/imports/depth_tests.rs b/crates/sysmlv2-model/src/json/operations/namespaces/imports/depth_tests.rs
new file mode 100644
index 0000000..80259f5
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces/imports/depth_tests.rs
@@ -0,0 +1,263 @@
+use super::*;
+use crate::model::{GraphFormat, Model};
+
+fn chain(edges: usize) -> String {
+    let mut source = format!("package P{edges} {{ class A; }}");
+    for n in (0..edges).rev() {
+        source.push_str(&format!("package P{n} {{public import $::P{}::*;}}", n + 1));
+    }
+    source
+}
+
+fn namespace_call(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    operation: &str,
+    arguments: &[DerivedValue],
+) -> Result<DerivedValue, OperationError> {
+    r.invoke_operation(
+        owner,
+        &format!("Root-Namespaces-Namespace-{operation}"),
+        arguments,
+    )
+    .map(|report| report.value)
+}
+
+fn references_of(r: &ResolvedModel, members: &[usize]) -> DerivedValue {
+    DerivedValue::References(
+        members
+            .iter()
+            .map(|&m| Reference::Element(ElementRef(r.b.elements[m].owning_relationship.unwrap())))
+            .collect(),
+    )
+}
+
+fn assert_chain(r: &mut ResolvedModel, edges: usize) {
+    let owner = r.resolve_qualified("P0").unwrap();
+    let terminal = r.resolve_qualified(&format!("P{edges}::A")).unwrap();
+    let expected = references_of(r, &[terminal.0]);
+    let empty = DerivedValue::Elements(vec![]);
+    let import = ElementRef(r.b.elements[owner.0].owned_relationships[0]);
+    let mut results = vec![
+        r.invoke_operation(
+            import,
+            "Root-Namespaces-NamespaceImport-importedMemberships_Namespace",
+            std::slice::from_ref(&empty),
+        )
+        .map(|report| report.value),
+    ];
+    for (op, args) in [
+        ("importedMemberships_Namespace", vec![empty.clone()]),
+        (
+            "membershipsOfVisibility_VisibilityKind_Namespace",
+            vec![DerivedValue::Null, empty.clone()],
+        ),
+        (
+            "visibleMemberships_Namespace_Boolean_Boolean",
+            vec![empty, DerivedValue::Bool(false), DerivedValue::Bool(false)],
+        ),
+    ] {
+        results.push(namespace_call(r, owner, op, &args));
+    }
+    for result in results {
+        if edges <= crate::json::MAX_RESOLUTION_DEPTH {
+            assert_eq!(result.unwrap(), expected, "edges={edges}");
+        } else {
+            assert!(
+                matches!(result, Err(OperationError::Incomplete { .. })),
+                "edges={edges}: {result:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn import_edge_boundary_agrees_across_selectors_and_serialization() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for edges in [
+            1,
+            8,
+            crate::json::MAX_RESOLUTION_DEPTH,
+            crate::json::MAX_RESOLUTION_DEPTH + 1,
+        ] {
+            let mut model = Model::with_graph_format(format);
+            assert!(
+                model
+                    .add_source("import-depth.kerml", &chain(edges))
+                    .diagnostics
+                    .is_empty()
+            );
+            assert_chain(&mut ResolvedModel::build(&model), edges);
+            for document in [
+                crate::json::model_to_compact_json(&model),
+                crate::full::model_to_full_json(&model),
+            ] {
+                let (_, mut loaded, _, _) =
+                    crate::loader::load_document_with_format(&document, &HashMap::new(), format)
+                        .unwrap();
+                assert_chain(&mut loaded, edges);
+            }
+        }
+    }
+}
+
+#[test]
+fn recursive_containment_uses_one_depth_per_child_and_preserves_order() {
+    for edges in [
+        crate::json::MAX_RESOLUTION_DEPTH,
+        crate::json::MAX_RESOLUTION_DEPTH + 1,
+    ] {
+        let mut source = String::from("package P0 {");
+        for n in 1..=edges {
+            source.push_str(&format!("package P{n} {{"));
+        }
+        source.push_str(&"}".repeat(edges + 1));
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("containment-depth.kerml", &source)
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        // Read owned rows directly: resolving a long qualified name has its own bound.
+        let owner = r.resolve_qualified("P0").unwrap();
+        let mut children = vec![];
+        let mut parent = owner.0;
+        for _ in 0..edges {
+            let membership = r.b.elements[parent].owned_relationships[0];
+            parent = r.b.elements[membership].children[0];
+            children.push(parent);
+        }
+        let result = namespace_call(
+            &mut r,
+            owner,
+            "visibleMemberships_Namespace_Boolean_Boolean",
+            &[
+                DerivedValue::Elements(vec![]),
+                DerivedValue::Bool(true),
+                DerivedValue::Bool(false),
+            ],
+        );
+        if edges <= crate::json::MAX_RESOLUTION_DEPTH {
+            assert_eq!(result.unwrap(), references_of(&r, &children));
+        } else {
+            assert!(matches!(result, Err(OperationError::Incomplete { .. })));
+        }
+    }
+}
+
+#[test]
+fn import_and_containment_edges_share_one_cumulative_depth_bound() {
+    let imports = 12;
+    for containment in [12, 13] {
+        let mut source = String::new();
+        for n in 0..imports {
+            source.push_str(&format!(
+                "package P{n} {{public import $::P{}::*::**;}}",
+                n + 1
+            ));
+        }
+        source.push_str(&format!("package P{imports} {{"));
+        for n in 0..containment {
+            source.push_str(&format!("package C{n} {{"));
+        }
+        source.push_str(&"}".repeat(containment + 1));
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("mixed-depth.kerml", &source)
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let owner = r.resolve_qualified("P0").unwrap();
+        let tree = r.resolve_qualified(&format!("P{imports}")).unwrap();
+        let mut children = vec![];
+        let mut parent = tree.0;
+        for _ in 0..containment {
+            let membership = r.b.elements[parent].owned_relationships[0];
+            parent = r.b.elements[membership].children[0];
+            children.push(parent);
+        }
+        let result = namespace_call(
+            &mut r,
+            owner,
+            "importedMemberships_Namespace",
+            &[DerivedValue::Elements(vec![])],
+        );
+        if imports + containment <= crate::json::MAX_RESOLUTION_DEPTH {
+            assert_eq!(result.unwrap(), references_of(&r, &children));
+        } else {
+            assert!(matches!(result, Err(OperationError::Incomplete { .. })));
+        }
+    }
+}
+
+#[test]
+fn deep_imports_keep_exclusions_identity_checks_and_budget_retry() {
+    let edges = 12;
+    let mut model = Model::new();
+    let source = format!(
+        "{} package Diamond {{public import $::P0::*; public import $::P1::*;}}",
+        chain(edges).replace("class A;", "class A; public import $::P0::*;")
+    );
+    assert!(
+        model
+            .add_source("deep-imports.kerml", &source)
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&model);
+    let owner = r.resolve_qualified("Diamond").unwrap();
+    let leaf = r.resolve_qualified(&format!("P{edges}::A")).unwrap();
+    let expected = references_of(&r, &[leaf.0]);
+    let empty = DerivedValue::Elements(vec![]);
+    assert_eq!(
+        namespace_call(
+            &mut r,
+            owner,
+            "importedMemberships_Namespace",
+            std::slice::from_ref(&empty)
+        )
+        .unwrap(),
+        expected
+    );
+    let excluded = r.resolve_qualified("P6").unwrap();
+    assert_eq!(
+        namespace_call(
+            &mut r,
+            owner,
+            "importedMemberships_Namespace",
+            &[DerivedValue::Elements(vec![excluded])]
+        )
+        .unwrap(),
+        DerivedValue::References(vec![])
+    );
+    let mut row = NamespaceRow::default();
+    let declaration = "Root-Namespaces-Namespace-importedMembership";
+    let mut steps = crate::eval::MAX_STEPS - 1;
+    assert!(
+        row.property(&mut r, owner, declaration, &mut steps)
+            .is_err()
+    );
+    assert_eq!(
+        row.property(&mut r, owner, declaration, &mut 0).unwrap(),
+        expected
+    );
+    let membership = r.b.elements[leaf.0].owning_relationship.take().unwrap();
+    assert!(
+        namespace_call(
+            &mut r,
+            owner,
+            "importedMemberships_Namespace",
+            std::slice::from_ref(&empty)
+        )
+        .is_err()
+    );
+    r.b.elements[leaf.0].owning_relationship = Some(membership);
+    assert_eq!(
+        namespace_call(&mut r, owner, "importedMemberships_Namespace", &[empty]).unwrap(),
+        expected
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces/recursive_features.rs b/crates/sysmlv2-model/src/json/operations/namespaces/recursive_features.rs
new file mode 100644
index 0000000..14869ee
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces/recursive_features.rs
@@ -0,0 +1,354 @@
+//! Recursive visibility traverses admitted Feature namespaces with full Type evidence.
+use super::*;
+use crate::model::{GraphFormat, Model};
+
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;}";
+const SOURCE: &str = "class BaseType { class Inherited; }
+class Outer {
+    feature plain;
+    feature typedSlot : BaseType subsets Occurrences::occurrences {class Local;}
+    private feature hidden {class Secret;}
+}
+package Consumer {public import Outer::**;}";
+fn fixture(format: GraphFormat, source: &str) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    model.add_library_source("recursive-library.kerml", LIB);
+    let unit = model.add_source("recursive-features.kerml", source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+fn memberships_for(r: &mut ResolvedModel, names: &[&str]) -> DerivedValue {
+    DerivedValue::References(
+        names
+            .iter()
+            .map(|name| {
+                let element = r.resolve_qualified(name).unwrap();
+                Reference::Element(ElementRef(
+                    r.b.elements[element.0].owning_relationship.unwrap(),
+                ))
+            })
+            .collect(),
+    )
+}
+fn visible(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    all: bool,
+) -> Result<DerivedValue, OperationError> {
+    r.invoke_operation(
+        owner,
+        "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+            DerivedValue::Bool(all),
+        ],
+    )
+    .map(|result| {
+        assert_eq!(
+            result.effective,
+            "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean"
+        );
+        result.value
+    })
+}
+#[test]
+fn recursive_feature_namespaces_preserve_order_visibility_and_inherited_memberships() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(format, SOURCE);
+        let outer = r.resolve_qualified("Outer").unwrap();
+        let expected = memberships_for(
+            &mut r,
+            &[
+                "Outer::plain",
+                "Outer::typedSlot",
+                "Outer::typedSlot::Local",
+                "BaseType::Inherited",
+            ],
+        );
+        assert_eq!(
+            visible(&mut r, outer, false),
+            Ok(expected.clone()),
+            "{format:?}"
+        );
+        let all = memberships_for(
+            &mut r,
+            &[
+                "Outer::plain",
+                "Outer::typedSlot",
+                "Outer::hidden",
+                "Outer::typedSlot::Local",
+                "BaseType::Inherited",
+                "Outer::hidden::Secret",
+            ],
+        );
+        assert_eq!(visible(&mut r, outer, true), Ok(all), "{format:?}");
+        let consumer = r.resolve_qualified("Consumer").unwrap();
+        let imported = r
+            .invoke_operation(
+                consumer,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![])],
+            )
+            .unwrap();
+        let imported_expected = memberships_for(
+            &mut r,
+            &[
+                "Outer",
+                "Outer::plain",
+                "Outer::typedSlot",
+                "Outer::typedSlot::Local",
+                "BaseType::Inherited",
+            ],
+        );
+        assert_eq!(imported.value, imported_expected);
+        let excluded = r
+            .invoke_operation(
+                consumer,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![outer])],
+            )
+            .unwrap();
+        // MembershipImport includes its selected Membership even when Namespace
+        // exclusion suppresses the recursively imported descendants.
+        assert_eq!(excluded.value, memberships_for(&mut r, &["Outer"]));
+        // Namespace exclusions affect imports, not the receiver's own descendants.
+        let direct = r
+            .invoke_operation(
+                outer,
+                "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+                &[
+                    DerivedValue::Elements(vec![outer]),
+                    DerivedValue::Bool(true),
+                    DerivedValue::Bool(false),
+                ],
+            )
+            .unwrap();
+        assert_eq!(direct.value, expected);
+    }
+}
+#[test]
+fn recursive_feature_imports_admit_cold_package_queries() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(format, SOURCE);
+        let consumer = r.resolve_qualified("Consumer").unwrap();
+        let expected = memberships_for(
+            &mut r,
+            &[
+                "Outer",
+                "Outer::plain",
+                "Outer::typedSlot",
+                "Outer::typedSlot::Local",
+                "BaseType::Inherited",
+            ],
+        );
+        let result = r
+            .invoke_operation(
+                consumer,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![])],
+            )
+            .unwrap();
+        assert_eq!(result.value, expected, "{format:?}");
+    }
+}
+
+#[test]
+fn recursive_feature_import_and_resolution_admit_cold_entry_points() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for direct_import in [false, true] {
+            let mut r = fixture(format, SOURCE);
+            let consumer = r.resolve_qualified("Consumer").unwrap();
+            if direct_import {
+                let relationship = r.b.elements[consumer.0]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&rel| conforms(r.b.elements[rel].ty, "Import"))
+                    .unwrap();
+                let expected = memberships_for(
+                    &mut r,
+                    &[
+                        "Outer",
+                        "Outer::plain",
+                        "Outer::typedSlot",
+                        "Outer::typedSlot::Local",
+                        "BaseType::Inherited",
+                    ],
+                );
+                let result = r
+                    .invoke_operation(
+                        ElementRef(relationship),
+                        "Root-Namespaces-MembershipImport-importedMemberships_Namespace",
+                        &[DerivedValue::Elements(vec![])],
+                    )
+                    .unwrap();
+                assert_eq!(result.value, expected, "{format:?}");
+            } else {
+                let local = r.resolve_qualified("Outer::typedSlot::Local").unwrap();
+                let relationship = ElementRef(r.b.elements[local.0].owning_relationship.unwrap());
+                let result = r
+                    .invoke_operation(
+                        consumer,
+                        "Root-Namespaces-Namespace-resolveVisible_String",
+                        &[DerivedValue::Str("Local".into())],
+                    )
+                    .unwrap();
+                assert_eq!(
+                    result.value,
+                    DerivedValue::Reference(Reference::Element(relationship)),
+                    "{format:?}"
+                );
+            }
+        }
+    }
+}
+#[test]
+fn recursive_package_visibility_initializes_type_evidence_without_imports() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(format, "package Holder {class Outer {feature plain;}}");
+        let holder = r.resolve_qualified("Holder").unwrap();
+        let expected = memberships_for(&mut r, &["Holder::Outer", "Holder::Outer::plain"]);
+        let result = r
+            .invoke_operation(
+                holder,
+                "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+                &[
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Bool(true),
+                    DerivedValue::Bool(false),
+                ],
+            )
+            .unwrap();
+        assert_eq!(result.value, expected, "{format:?}");
+    }
+}
+#[test]
+fn cold_recursive_preparation_retry_keeps_one_work_allowance() {
+    let effective = "Kernel-Packages-Package-importedMemberships_Namespace";
+    let mut r = fixture(GraphFormat::CanonicalV3, SOURCE);
+    let consumer = r.resolve_qualified("Consumer").unwrap();
+    let mut needed = 0;
+    prepare(&mut r, consumer, &mut needed, effective, &[]).unwrap();
+    assert!(needed > 1 && needed < crate::eval::MAX_STEPS);
+    let mut retry = fixture(GraphFormat::CanonicalV3, SOURCE);
+    let consumer = retry.resolve_qualified("Consumer").unwrap();
+    let mut steps = crate::eval::MAX_STEPS - needed + 1;
+    assert!(prepare(&mut retry, consumer, &mut steps, effective, &[]).is_err());
+    assert!(steps >= crate::eval::MAX_STEPS);
+    // A failed cold attempt must not poison a subsequent full-budget query.
+    let result = retry
+        .invoke_operation(consumer, effective, &[DerivedValue::Elements(vec![])])
+        .unwrap();
+    assert_eq!(
+        result.value,
+        memberships_for(
+            &mut retry,
+            &[
+                "Outer",
+                "Outer::plain",
+                "Outer::typedSlot",
+                "Outer::typedSlot::Local",
+                "BaseType::Inherited",
+            ]
+        )
+    );
+}
+#[test]
+fn recursive_feature_visibility_rejects_incomplete_ownership_metadata_and_feature_families() {
+    for mutation in 0..4 {
+        let mut r = fixture(GraphFormat::CanonicalV3, SOURCE);
+        let outer = r.resolve_qualified("Outer").unwrap();
+        let typed = r.resolve_qualified("Outer::typedSlot").unwrap();
+        let local = r.resolve_qualified("Outer::typedSlot::Local").unwrap();
+        assert!(visible(&mut r, outer, false).is_ok());
+        let membership = r.b.elements[local.0].owning_relationship.unwrap();
+        match mutation {
+            0 => r.b.elements[typed.0]
+                .owned_relationships
+                .make_mut()
+                .retain(|&rel| rel != membership),
+            1 => {
+                r.b.metadata_of.insert(typed.0, vec![typed.0]);
+            }
+            2 => {
+                r.b.set(typed.0, "direction", serde_json::json!("in"));
+            }
+            _ => {
+                r.b.set(typed.0, "isEnd", serde_json::json!(true));
+            }
+        }
+        assert!(
+            matches!(
+                visible(&mut r, outer, false),
+                Err(OperationError::Incomplete { .. })
+            ),
+            "mutation {mutation}"
+        );
+    }
+    for source in [
+        "class Outer {feature valued=1;}",
+        "class Outer {feature nested {feature child;}}",
+    ] {
+        let mut r = fixture(GraphFormat::CanonicalV3, source);
+        let outer = r.resolve_qualified("Outer").unwrap();
+        assert!(matches!(
+            visible(&mut r, outer, false),
+            Err(OperationError::Incomplete { .. })
+        ));
+    }
+}
+#[test]
+fn recursive_feature_visibility_observes_mutations_and_budget_retry() {
+    let mut r = fixture(GraphFormat::CanonicalV3, SOURCE);
+    let outer = r.resolve_qualified("Outer").unwrap();
+    let expected = visible(&mut r, outer, false).unwrap();
+    let effective = "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean";
+    let signature = crate::json::operations::operation_execution_signature(effective).unwrap();
+    let arguments = [
+        DerivedValue::Elements(vec![]),
+        DerivedValue::Bool(true),
+        DerivedValue::Bool(false),
+    ];
+    assert!(matches!(
+        invoke(
+            &mut r,
+            outer,
+            effective,
+            signature,
+            &arguments,
+            Body::Visible,
+            crate::eval::MAX_STEPS
+        ),
+        Err(OperationError::WorkLimit { .. })
+    ));
+    assert_eq!(visible(&mut r, outer, false), Ok(expected));
+    let typed = r.resolve_qualified("Outer::typedSlot").unwrap();
+    let relationship = r.b.elements[typed.0].owning_relationship.unwrap();
+    r.b.set(relationship, "visibility", serde_json::json!("private"));
+    let expected = memberships_for(&mut r, &["Outer::plain"]);
+    assert_eq!(visible(&mut r, outer, false), Ok(expected));
+}
+
+#[test]
+fn package_owned_feature_roots_keep_the_same_narrow_flag_boundary() {
+    for (key, value) in [
+        ("isEnd", serde_json::json!(true)),
+        ("direction", serde_json::json!("in")),
+    ] {
+        let mut r = fixture(GraphFormat::CanonicalV3, "feature plain;");
+        let feature = r.resolve_qualified("plain").unwrap();
+        assert_eq!(
+            visible(&mut r, feature, false),
+            Ok(DerivedValue::References(vec![]))
+        );
+        r.b.set(feature.0, key, value);
+        assert!(
+            matches!(
+                visible(&mut r, feature, false),
+                Err(OperationError::Incomplete { .. })
+            ),
+            "{key}"
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces/resolution.rs b/crates/sysmlv2-model/src/json/operations/namespaces/resolution.rs
new file mode 100644
index 0000000..1450ce7
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces/resolution.rs
@@ -0,0 +1,294 @@
+//! Membership-valued resolution with explicit, checked multi-unit global scope.
+use super::*;
+fn find(
+    r: &mut ResolvedModel,
+    values: Vec<Membership>,
+    name: &str,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Option<Membership>, OperationError> {
+    charge(steps, values.len(), effective)?;
+    for membership in values {
+        if member_names(r, &membership, steps, effective)?
+            .iter()
+            .any(|v| v == name)
+        {
+            return Ok(Some(membership));
+        }
+    }
+    Ok(None)
+}
+fn global(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    name: &str,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Option<Membership>, OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    // The toolkit's global environment is the union of its source-unit root
+    // Namespaces, including prepared library units. Unlike compatibility root
+    // lookup, duplicate global bindings are qualified instead of selecting a
+    // winner by source-unit insertion order.
+    charge(steps, r.b.unit_starts.len(), effective)?;
+    let roots: Vec<_> = r.b.unit_starts.iter().map(|&(root, _)| root).collect();
+    let mut result: Option<Membership> = None;
+    for root in roots {
+        if r.b.elements[root].ty != "Namespace" || r.b.elements[root].owning_relationship.is_some()
+        {
+            return Err(incomplete());
+        }
+        let values = imports::sequence(r, raw, root, &[], steps, effective)?.all;
+        // Reject ambiguity within a root as well as between units. Aliases
+        // remain separate bindings even if they denote the same member.
+        for value in values {
+            if member_names(r, &value, steps, effective)?
+                .iter()
+                .any(|v| v == name)
+            {
+                if result
+                    .as_ref()
+                    .is_some_and(|m| m.relationship != value.relationship)
+                {
+                    return Err(incomplete());
+                }
+                result = Some(value);
+            }
+        }
+    }
+    Ok(result)
+}
+fn parent(
+    r: &ResolvedModel,
+    raw: &StoredStructure,
+    owner: usize,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Option<usize>, OperationError> {
+    let incomplete = || OperationError::Incomplete { effective };
+    charge(steps, 8, effective)?;
+    let row = &r.b.elements[owner];
+    if row.owning_relationship.is_none() {
+        charge(steps, r.b.unit_starts.len(), effective)?;
+        if !r.b.unit_starts.iter().any(|&(root, _)| root == owner) {
+            return Err(incomplete());
+        }
+    }
+    let result = if let Some(relationship) = row.owning_relationship {
+        if conforms(r.b.elements[relationship].ty, "OwningMembership") {
+            let parent =
+                semantic_ownership::checked_relationship_carrier(&r.b, raw, relationship, steps)
+                    .flatten()
+                    .ok_or_else(incomplete)?;
+            if membership_evidence::member(&r.b, raw, parent, relationship, steps) != Some(owner) {
+                return Err(incomplete());
+            }
+            Some(parent)
+        } else {
+            let relation = &r.b.elements[relationship];
+            if !conforms(relation.ty, "Import")
+                || (relation.children.len() != 1 || relation.children.first() != Some(&owner))
+                || relation
+                    .props
+                    .get("importedNamespace")
+                    .and_then(|v| v.as_reference())
+                    != Some(row.id)
+            {
+                return Err(incomplete());
+            }
+            None
+        }
+    } else {
+        None
+    };
+    if result.is_none()
+        && row
+            .props
+            .get("owningMembership")
+            .is_some_and(|v| !v.is_null())
+    {
+        return Err(incomplete());
+    }
+    if row
+        .props
+        .get("owningNamespace")
+        .is_some_and(|value| match result {
+            Some(parent) => value.as_reference() != Some(r.b.elements[parent].id),
+            None => !value.is_null(),
+        })
+    {
+        return Err(incomplete());
+    }
+    Ok(result)
+}
+fn local(
+    r: &mut ResolvedModel,
+    raw: &StoredStructure,
+    mut owner: usize,
+    name: &str,
+    steps: &mut usize,
+    effective: &'static str,
+) -> Result<Option<Membership>, OperationError> {
+    let mut seen = HashSet::new();
+    loop {
+        charge(steps, 1, effective)?;
+        if !seen.insert(owner) || seen.len() > crate::json::MAX_RESOLUTION_DEPTH {
+            return Err(OperationError::Incomplete { effective });
+        }
+        let Some(parent) = parent(r, raw, owner, steps, effective)? else {
+            return global(r, raw, name, steps, effective);
+        };
+        let values = imports::sequence(r, raw, owner, &[], steps, effective)?.all;
+        if let Some(member) = find(r, values, name, steps, effective)? {
+            return Ok(Some(member));
+        }
+        owner = parent;
+    }
+}
+pub(super) fn invoke(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    effective: &'static str,
+    signature: &OperationExecutionSignature,
+    arguments: &[DerivedValue],
+    body: Body,
+    steps: &mut usize,
+) -> Result<DerivedValue, OperationError> {
+    let (_, _, result) =
+        super::with_stable_evidence(r, receiver, steps, effective, |r, raw, steps| {
+            let DerivedValue::Str(name) = &arguments[0] else {
+                unreachable!("validated string")
+            };
+            charge(steps, name.len(), effective)?;
+            let result = match body {
+                Body::ResolveLocal => local(r, raw, receiver.0, name, steps, effective)?,
+                Body::Resolve | Body::ResolveGlobal => {
+                    let (explicit_global, names) =
+                        qualified_names(name, effective, signature, steps)?;
+                    let is_global = explicit_global || matches!(body, Body::ResolveGlobal);
+                    let mut names = names.into_iter();
+                    let name = names.next().expect("qualified syntax has a name");
+                    let mut selected = if is_global {
+                        global(r, raw, &name, steps, effective)?
+                    } else {
+                        local(r, raw, receiver.0, &name, steps, effective)?
+                    };
+                    for name in names {
+                        let Some(namespace) = selected else { break };
+                        if !conforms(r.b.elements[namespace.member].ty, "Namespace") {
+                            selected = None;
+                            break;
+                        }
+                        let visible = imports::visible(
+                            r,
+                            raw,
+                            namespace.member,
+                            &[],
+                            false,
+                            false,
+                            steps,
+                            effective,
+                            0,
+                        )?;
+                        selected = find(r, visible, &name, steps, effective)?;
+                    }
+                    selected
+                }
+                _ => unreachable!("resolution body"),
+            };
+            Ok(result)
+        })?;
+    Ok(result.map_or(DerivedValue::Null, |m| {
+        DerivedValue::Reference(Reference::Element(ElementRef(m.relationship)))
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+    use serde_json::json;
+    fn fixture() -> ResolvedModel {
+        let mut model = Model::new();
+        let unit = model.add_source("resolution.kerml", "package P { class Outer; package Q { class Inner; alias Alias for Inner; } private package Hidden { class Secret; } } package Elsewhere { class Global; }");
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&model)
+    }
+    fn call(
+        r: &mut ResolvedModel,
+        receiver: ElementRef,
+        op: &str,
+        name: &str,
+    ) -> Result<DerivedValue, OperationError> {
+        r.invoke_operation(
+            receiver,
+            &format!("Root-Namespaces-Namespace-{op}_String"),
+            &[DerivedValue::Str(name.into())],
+        )
+        .map(|v| v.value)
+    }
+    fn member(r: &mut ResolvedModel, path: &str) -> DerivedValue {
+        let e = r.resolve_qualified(path).unwrap();
+        DerivedValue::Reference(Reference::Element(ElementRef(
+            r.b.elements[e.0].owning_relationship.unwrap(),
+        )))
+    }
+    #[test]
+    fn local_resolution_searches_outers_and_qualified_resolution_keeps_memberships() {
+        let mut r = fixture();
+        let q = r.resolve_qualified("P::Q").unwrap();
+        for (op, name, target) in [
+            ("resolveLocal", "Inner", "P::Q::Inner"),
+            ("resolveLocal", "Outer", "P::Outer"),
+            ("resolve", "P::Outer", "P::Outer"),
+            ("resolve", "$::Elsewhere::Global", "Elsewhere::Global"),
+            ("resolveGlobal", "Elsewhere::Global", "Elsewhere::Global"),
+        ] {
+            let expected = member(&mut r, target);
+            assert_eq!(call(&mut r, q, op, name).unwrap(), expected, "{op} {name}");
+        }
+        assert_eq!(
+            call(&mut r, q, "resolve", "P::Hidden::Secret").unwrap(),
+            DerivedValue::Null
+        );
+        assert_eq!(
+            call(&mut r, q, "resolve", "NoSuchName").unwrap(),
+            DerivedValue::Null
+        );
+        let alias = r.b.elements[q.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&m| r.b.elements[m].ty == "Membership")
+            .unwrap();
+        assert_eq!(
+            call(&mut r, q, "resolve", "Alias").unwrap(),
+            DerivedValue::Reference(Reference::Element(ElementRef(alias)))
+        );
+    }
+    #[test]
+    fn global_ambiguity_and_corrupt_lexical_ownership_are_qualified() {
+        let mut m = Model::new();
+        m.add_source("a.kerml", "package Root; package P;");
+        m.add_source("b.kerml", "package Root;");
+        let mut r = ResolvedModel::build(&m);
+        let p = r.resolve_qualified("P").unwrap();
+        assert!(matches!(
+            call(&mut r, p, "resolveGlobal", "Root"),
+            Err(OperationError::Incomplete { .. })
+        ));
+        let mut r = fixture();
+        let q = r.resolve_qualified("P::Q").unwrap();
+        r.b.elements[q.0].owning_relationship = None;
+        assert!(call(&mut r, q, "resolveLocal", "Elsewhere").is_err());
+        let mut r = fixture();
+        let q = r.resolve_qualified("P::Q").unwrap();
+        let other = r.resolve_qualified("Elsewhere").unwrap();
+        r.b.set(
+            q.0,
+            "owningNamespace",
+            json!({"@id": r.element_id(other).to_string()}),
+        );
+        assert!(call(&mut r, q, "resolveLocal", "Inner").is_err());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/operations/namespaces/type_memberships.rs b/crates/sysmlv2-model/src/json/operations/namespaces/type_memberships.rs
new file mode 100644
index 0000000..c3946c6
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/operations/namespaces/type_memberships.rs
@@ -0,0 +1,373 @@
+//! Checked Type operation cases share the complete membership provider.
+use super::*;
+use crate::model::{GraphFormat, Model};
+const LIB: &str = "standard library package Base { classifier Anything; feature things:Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things; } standard library package Performances { behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance { return result; } step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; }";
+fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_library_source("membership-library.kerml", LIB)
+            .diagnostics
+            .is_empty()
+    );
+    let unit = model.add_source("membership-operations.kerml", source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+fn empty() -> DerivedValue {
+    DerivedValue::Elements(vec![])
+}
+fn args(excluded: Vec<ElementRef>, implied: bool) -> [DerivedValue; 3] {
+    [
+        empty(),
+        DerivedValue::Elements(excluded),
+        DerivedValue::Bool(implied),
+    ]
+}
+fn call(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    op: &str,
+    args: &[DerivedValue],
+) -> Result<DerivedValue, OperationError> {
+    r.invoke_operation(
+        owner,
+        &format!("Core-Types-Type-{op}_Namespace_Type_Boolean"),
+        args,
+    )
+    .map(|r| r.value)
+}
+fn expected(r: &mut ResolvedModel, names: &[&str]) -> DerivedValue {
+    DerivedValue::References(
+        names
+            .iter()
+            .map(|name| {
+                let e = r.resolve_qualified(name).unwrap();
+                Reference::Element(ElementRef(r.b.elements[e.0].owning_relationship.unwrap()))
+            })
+            .collect(),
+    )
+}
+#[test]
+fn type_operation_order_visibility_redefinitions_and_exclusions() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "class A { protected feature guarded; feature initialSlot; private feature hidden; feature last; class Nested; } class B specializes A { protected feature ownGuard; private feature ownHidden; feature own redefines A::initialSlot; } class C specializes B;",
+            format,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        let inherited = expected(&mut r, &["A::last", "A::Nested", "A::guarded"]);
+        let inheritable = expected(
+            &mut r,
+            &["A::initialSlot", "A::last", "A::Nested", "A::guarded"],
+        );
+        let nonprivate = expected(
+            &mut r,
+            &[
+                "B::own",
+                "B::ownGuard",
+                "A::last",
+                "A::Nested",
+                "A::guarded",
+            ],
+        );
+        assert_eq!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![], true)),
+            Ok(inherited)
+        );
+        assert_eq!(
+            call(&mut r, b, "inheritableMemberships", &args(vec![], true)),
+            Ok(inheritable)
+        );
+        assert_eq!(
+            call(&mut r, b, "nonPrivateMemberships", &args(vec![], true)),
+            Ok(nonprivate)
+        );
+        for op in ["inheritedMemberships", "inheritableMemberships"] {
+            assert_eq!(
+                call(&mut r, b, op, &args(vec![a], true)),
+                Ok(DerivedValue::References(vec![]))
+            );
+            let baseline = call(&mut r, b, op, &args(vec![], true));
+            assert_eq!(call(&mut r, b, op, &args(vec![b], true)), baseline);
+            let mut namespaces = args(vec![], true);
+            namespaces[0] = DerivedValue::Elements(vec![a, b]);
+            assert_eq!(call(&mut r, b, op, &namespaces), baseline);
+        }
+        let own = expected(&mut r, &["B::own", "B::ownGuard"]);
+        assert_eq!(
+            call(&mut r, b, "nonPrivateMemberships", &args(vec![a], true)),
+            Ok(own)
+        );
+        let c = r.resolve_qualified("C").unwrap();
+        let transitively_cut = expected(&mut r, &["B::own", "B::ownGuard"]);
+        assert_eq!(
+            call(&mut r, c, "inheritedMemberships", &args(vec![a], true)),
+            Ok(transitively_cut)
+        );
+    }
+}
+#[test]
+fn type_visible_override_has_exact_dispatch_and_visibility_order() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "class A { protected feature guarded; feature inherited; } class B specializes A { private feature secret; feature own; } class C specializes A;",
+            format,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        let public = expected(&mut r, &["B::own", "A::inherited"]);
+        let all = expected(
+            &mut r,
+            &["B::secret", "B::own", "A::inherited", "A::guarded"],
+        );
+        for recursive in [false, true] {
+            for (include_all, expected) in [(false, public.clone()), (true, all.clone())] {
+                let result = r
+                    .invoke_operation(
+                        b,
+                        "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+                        &[
+                            empty(),
+                            DerivedValue::Bool(recursive),
+                            DerivedValue::Bool(include_all),
+                        ],
+                    )
+                    .unwrap();
+                assert_eq!(
+                    result.effective,
+                    "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean"
+                );
+                assert_eq!(result.value, expected);
+            }
+        }
+        let c = r.resolve_qualified("C").unwrap();
+        for include_all in [false, true] {
+            let expected = expected(
+                &mut r,
+                if include_all {
+                    &["A::inherited", "A::guarded"]
+                } else {
+                    &["A::inherited"]
+                },
+            );
+            let result = r
+                .invoke_operation(
+                    c,
+                    "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean",
+                    &[
+                        empty(),
+                        DerivedValue::Bool(true),
+                        DerivedValue::Bool(include_all),
+                    ],
+                )
+                .unwrap();
+            assert_eq!(result.value, expected);
+        }
+    }
+}
+#[test]
+fn type_alias_memberships_remain_distinct_and_private_imports_never_inherit() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "package P { class Imported; } class A { class Nested; alias firstAlias for Nested; alias second for Nested; private import P::*; } class B specializes A;",
+            format,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        let rels: Vec<_> = r.b.elements[a.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&rel| conforms(r.b.elements[rel].ty, "Membership"))
+            .map(|rel| Reference::Element(ElementRef(rel)))
+            .collect();
+        assert_eq!(rels.len(), 3);
+        let result = call(&mut r, b, "inheritedMemberships", &args(vec![], true)).unwrap();
+        assert_eq!(result, DerivedValue::References(rels));
+        for access in ["public", "protected"] {
+            let import = r.b.elements[a.0]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&rel| conforms(r.b.elements[rel].ty, "Import"))
+                .unwrap();
+            r.b.set(import, "visibility", serde_json::json!(access));
+            let mut excluded = args(vec![a], true);
+            excluded[0] = DerivedValue::Elements(vec![r.resolve_qualified("P").unwrap()]);
+            assert_eq!(
+                call(&mut r, b, "inheritedMemberships", &excluded),
+                Ok(DerivedValue::References(vec![]))
+            );
+            r.b.set(import, "visibility", serde_json::json!("private"));
+        }
+    }
+}
+#[test]
+fn type_visibility_retains_import_collisions_that_namespace_prunes() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "package P {class Shared;} package Q {class Shared;} class A {public import P::*; public import Q::*;} class B specializes A;",
+            format,
+        );
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        let both = expected(&mut r, &["P::Shared", "Q::Shared"]);
+        assert_eq!(
+            call(&mut r, a, "nonPrivateMemberships", &args(vec![], true)),
+            Ok(both.clone()),
+            "{format:?}"
+        );
+        assert_eq!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![], true)),
+            Ok(both),
+            "{format:?}"
+        );
+        let pruned = r
+            .invoke_operation(
+                a,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[empty()],
+            )
+            .unwrap();
+        assert_eq!(pruned.value, DerivedValue::References(vec![]), "{format:?}");
+    }
+}
+#[test]
+fn implied_filter_keeps_semantic_positional_suppression() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "function A { in a; feature kept; } function B specializes A { in x; }",
+            format,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        let ordinary = call(&mut r, b, "inheritedMemberships", &args(vec![], false)).unwrap();
+        let explicit = expected(&mut r, &["A::kept"]);
+        assert_eq!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![], true)),
+            Ok(explicit.clone())
+        );
+        assert_ne!(ordinary, explicit);
+        let candidates = expected(&mut r, &["A::a", "A::kept"]);
+        assert_eq!(
+            call(&mut r, b, "inheritableMemberships", &args(vec![], true)),
+            Ok(candidates)
+        );
+    }
+}
+#[test]
+fn operation_arguments_budget_and_same_identity_edits_are_checked() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "class A { feature slot; } class B specializes A; package P;",
+            format,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        let p = r.resolve_qualified("P").unwrap();
+        assert!(matches!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![p], true)),
+            Err(OperationError::InvalidArgument {
+                index: 1,
+                issue: OperationArgumentIssue::WrongMetaclass { .. },
+                ..
+            })
+        ));
+        assert!(matches!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![a, a], true)),
+            Err(OperationError::InvalidArgument {
+                index: 1,
+                issue: OperationArgumentIssue::DuplicateIdentity,
+                ..
+            })
+        ));
+        let baseline = call(&mut r, b, "inheritedMemberships", &args(vec![], true)).unwrap();
+        let effective = "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean";
+        let signature = crate::json::operations::operation_execution_signature(effective).unwrap();
+        assert!(matches!(
+            invoke(
+                &mut r,
+                b,
+                effective,
+                signature,
+                &args(vec![], true),
+                Body::Inherited,
+                crate::eval::MAX_STEPS
+            ),
+            Err(OperationError::WorkLimit { .. })
+        ));
+        assert_eq!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![], true)),
+            Ok(baseline)
+        );
+        let member = r.resolve_qualified("A::slot").unwrap();
+        let membership = r.b.elements[member.0].owning_relationship.unwrap();
+        r.b.set(membership, "visibility", serde_json::json!("private"));
+        assert_eq!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![], true)),
+            Ok(DerivedValue::References(vec![]))
+        );
+        r.b.elements[a.0]
+            .owned_relationships
+            .make_mut()
+            .retain(|&rel| rel != membership);
+        assert!(matches!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![a], true)),
+            Err(OperationError::Incomplete { .. })
+        ));
+    }
+}
+#[test]
+fn excluded_types_do_not_mask_cycles_or_unresolved_ancestry() {
+    for source in [
+        "class A specializes B; class B specializes A;",
+        "class A specializes Missing; class B specializes A;",
+    ] {
+        let mut r = fixture(source, GraphFormat::CanonicalV3);
+        let b = r.resolve_qualified("B").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        assert!(matches!(
+            call(&mut r, b, "inheritedMemberships", &args(vec![a], true)),
+            Err(OperationError::Incomplete { .. })
+        ));
+    }
+}
+
+#[test]
+fn named_multiplicity_members_are_not_features_and_require_complete_carriers() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut r = fixture(
+            "class A { feature count=4; multiplicity limit[count]; feature slots {multiplicity subsets limit;} } class B specializes A;",
+            format,
+        );
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        let limit = r.resolve_qualified("A::limit").unwrap();
+        let membership = r.b.elements[limit.0].owning_relationship.unwrap();
+        assert_eq!(r.b.elements[membership].ty, "OwningMembership");
+        let projection = r.type_feature_report(a).projections.unwrap();
+        assert!(!projection.features.contains(&limit));
+        assert!(
+            projection
+                .owned_memberships
+                .contains(&ElementRef(membership))
+        );
+        let inherited = call(&mut r, b, "inheritedMemberships", &args(vec![], true)).unwrap();
+        assert!(
+            matches!(inherited, DerivedValue::References(ref members) if members.contains(&Reference::Element(ElementRef(membership))))
+        );
+        r.b.set(limit.0, "direction", serde_json::json!("in"));
+        assert!(r.type_feature_report(a).projections.is_err());
+        r.b.set(limit.0, "direction", serde_json::Value::Null);
+        assert!(r.type_feature_report(a).projections.is_ok());
+        r.b.set(limit.0, "isEnd", serde_json::json!(true));
+        assert!(r.type_feature_report(a).projections.is_err());
+        r.b.set(limit.0, "isEnd", serde_json::json!(false));
+        assert!(r.type_feature_report(a).projections.is_ok());
+        r.b.elements[a.0]
+            .owned_relationships
+            .make_mut()
+            .retain(|&m| m != membership);
+        assert!(r.type_feature_report(a).projections.is_err());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/owned_results.rs b/crates/sysmlv2-model/src/json/owned_results.rs
new file mode 100644
index 0000000..fdd8ba6
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/owned_results.rs
@@ -0,0 +1,783 @@
+//! Bounded owned-result additions over stored expression identities.
+//!
+//! Planning runs over the unchanged source graph and shared carrier index.
+//! Publication happens only after all endpoints and generated IDs are admitted.
+//! This implements the result/Subsetting obligation of FeatureReferenceExpression;
+//! It also supplies the owned binary BindingConnector obligation. Required
+//! connector library ancestry/featuring and broader expression rules remain qualified.
+use super::{
+    Builder, Elem, semantic_ownership::SemanticOwnership, structural_index::StoredStructure,
+};
+use crate::properties::Properties;
+use serde_json::json;
+use std::collections::HashSet;
+use uuid::Uuid;
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+/// The only plan admitted by the first result increment. Existing owned results
+/// are left unchanged; absence from this plan is never a completeness claim.
+pub(super) struct OwnedResultPlan {
+    expression: usize,
+    referent: usize,
+    membership_id: Uuid,
+    result_id: Uuid,
+    specialization_id: Uuid,
+    binding_ids: [Uuid; 8],
+    relationship_type: &'static str,
+    source_key: &'static str,
+    target_key: &'static str,
+}
+
+impl OwnedResultPlan {
+    pub(super) fn ids(&self) -> impl Iterator<Item = Uuid> + '_ {
+        [self.membership_id, self.result_id, self.specialization_id]
+            .into_iter()
+            .chain(self.binding_ids)
+    }
+}
+
+/// Read once before appending any semantic nodes. The shared structural index
+/// supplies UUID uniqueness and carrier facts; it does not duplicate ownership.
+/// None is an interrupted proof: discard every prepared plan, so budget order
+/// cannot publish a prefix of this family. Some does not certify unsupported
+/// expressions; only each returned plan is a positive admission.
+pub(super) fn plan_reference_results(
+    b: &mut Builder,
+    steps: &mut usize,
+) -> Option<Vec<OwnedResultPlan>> {
+    let mut plans = Vec::new();
+    let raw = StoredStructure::get(b, steps)?;
+    // UUID uniqueness is independent of unrelated source-edge anomalies.
+    // This local positive proof validates its own complete carrier path.
+    if !raw.ids_unique {
+        return Some(plans);
+    }
+    let from = b.explicit_len();
+    charge(steps, from)?;
+    let mut assigned_ids = HashSet::new();
+    for expression in 0..from {
+        if b.elements[expression].ty != "FeatureReferenceExpression" {
+            continue;
+        }
+        let Some(referent) = reference_referent(b, &raw, expression, steps) else {
+            if *steps > crate::eval::MAX_STEPS {
+                return None;
+            }
+            continue;
+        };
+        let expression_id = b.elements[expression].id;
+        let referent_id = b.elements[referent].id;
+        let result_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{expression_id}/implied/ownedResult").as_bytes(),
+        );
+        let membership_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{expression_id}/implied/returnMembership").as_bytes(),
+        );
+        let subsetting_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{result_id}/implied/Subsetting/{referent_id}").as_bytes(),
+        );
+        let binding_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{expression_id}/implied/referenceBinding").as_bytes(),
+        );
+        let binding_member = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{expression_id}/implied/referenceBindingMembership").as_bytes(),
+        );
+        let end_id = |position: usize| {
+            Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{binding_id}/implied/end/{position}").as_bytes(),
+            )
+        };
+        let end_member = |position: usize| {
+            Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{binding_id}/implied/endMembership/{position}").as_bytes(),
+            )
+        };
+        let reference_id = |end: Uuid, target: Uuid| {
+            Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{end}/implied/ReferenceSubsetting/{target}").as_bytes(),
+            )
+        };
+        let binding_ids = [
+            binding_member,
+            binding_id,
+            end_member(0),
+            end_id(0),
+            reference_id(end_id(0), referent_id),
+            end_member(1),
+            end_id(1),
+            reference_id(end_id(1), result_id),
+        ];
+        let ids = [
+            membership_id,
+            result_id,
+            subsetting_id,
+            binding_ids[0],
+            binding_ids[1],
+            binding_ids[2],
+            binding_ids[3],
+            binding_ids[4],
+            binding_ids[5],
+            binding_ids[6],
+            binding_ids[7],
+        ];
+        charge(steps, ids.len())?;
+        let unique: HashSet<_> = ids.iter().copied().collect();
+        if unique.len() != ids.len() {
+            continue;
+        }
+        if ids
+            .iter()
+            .any(|id| b.element_index_of_uuid(*id).is_some() || assigned_ids.contains(id))
+        {
+            continue;
+        }
+        assigned_ids.extend(ids);
+        plans.push(OwnedResultPlan {
+            expression,
+            referent,
+            membership_id,
+            result_id,
+            specialization_id: subsetting_id,
+            binding_ids,
+            relationship_type: "Subsetting",
+            source_key: "subsettingFeature",
+            target_key: "subsettedFeature",
+        });
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+    }
+    Some(plans)
+}
+
+fn reference_referent(
+    b: &mut Builder,
+    raw: &StoredStructure,
+    expression: usize,
+    steps: &mut usize,
+) -> Option<usize> {
+    super::membership_evidence::first_unowned_member(
+        b,
+        raw,
+        expression,
+        "ParameterMembership",
+        "Feature",
+        Some("ReturnParameterMembership"),
+        steps,
+    )
+}
+
+pub(super) struct StagedResult {
+    pub specializations: [(Uuid, Uuid); 3],
+    pub featuring: [super::local_featuring::Role; 3],
+}
+
+/// Called after generic implied relationships have been registered. Only new
+/// rows are mutated; all source relationships, children and UUIDs remain intact.
+pub(super) fn stage_owned_result(
+    b: &Builder,
+    ownership: &mut SemanticOwnership,
+    plan: OwnedResultPlan,
+    start: usize,
+    output: &mut Vec<Elem>,
+) -> StagedResult {
+    let membership = start;
+    let result = membership + 1;
+    let subsetting = membership + 2;
+    let source_id = b.elements[plan.expression].id;
+    let target_id = b.elements[plan.referent].id;
+    let mut member_props = Properties::new();
+    member_props.insert("isImplied", json!(true));
+    member_props.insert("owningRelatedElement", json!({"@id":source_id.to_string()}));
+    member_props.insert("visibility", json!("public"));
+    let mut result_props = Properties::new();
+    result_props.insert("direction", json!("out"));
+    let mut subsetting_props = Properties::new();
+    subsetting_props.insert("isImplied", json!(true));
+    subsetting_props.insert(
+        "owningRelatedElement",
+        json!({"@id":plan.result_id.to_string()}),
+    );
+    subsetting_props.insert(plan.source_key, json!({"@id":plan.result_id.to_string()}));
+    subsetting_props.insert(plan.target_key, json!({"@id":target_id.to_string()}));
+    let rows = [
+        Elem {
+            ty: "ReturnParameterMembership",
+            id: plan.membership_id,
+            path: String::new(),
+            path_parent: None,
+            props: member_props,
+            owned_relationships: Default::default(),
+            children: vec![result].into(),
+            owning_relationship: None,
+        },
+        Elem {
+            ty: "Feature",
+            id: plan.result_id,
+            path: String::new(),
+            path_parent: None,
+            props: result_props,
+            owned_relationships: vec![subsetting].into(),
+            children: Default::default(),
+            owning_relationship: Some(membership),
+        },
+        Elem {
+            ty: plan.relationship_type,
+            id: plan.specialization_id,
+            path: String::new(),
+            path_parent: None,
+            props: subsetting_props,
+            owned_relationships: Default::default(),
+            children: Default::default(),
+            owning_relationship: None,
+        },
+    ];
+    // The plan and sequential materializer establish these invariants before
+    // publication. No user payload can invoke an arbitrary owner override.
+    ownership
+        .register(membership, Some(plan.expression), plan.expression, true)
+        .expect("ordered result membership");
+    ownership
+        .register(result, None, plan.expression, false)
+        .expect("ordered result feature");
+    ownership
+        .register(subsetting, Some(result), plan.expression, false)
+        .expect("ordered result specialization");
+    output.extend(rows);
+    ownership
+        .record_result(plan.expression, membership, result)
+        .expect("unique admitted result projection");
+    let (binding, first, second) = stage_binding(
+        b,
+        ownership,
+        plan.expression,
+        plan.expression,
+        plan.referent,
+        plan.result_id,
+        &plan.binding_ids,
+        start + 3,
+        output,
+    );
+    StagedResult {
+        specializations: [
+            (plan.result_id, target_id),
+            (plan.binding_ids[3], target_id),
+            (plan.binding_ids[6], plan.result_id),
+        ],
+        featuring: [
+            super::local_featuring::Role {
+                source: result,
+                target: plan.expression,
+                anchor: plan.expression,
+            },
+            super::local_featuring::Role {
+                source: first,
+                target: binding,
+                anchor: plan.expression,
+            },
+            super::local_featuring::Role {
+                source: second,
+                target: binding,
+                anchor: plan.expression,
+            },
+        ],
+    }
+}
+
+/// The BindingConnector is both Feature and Relationship, owned as a child of
+/// an OwningMembership. This deliberately does not assert that the expression
+/// is its featuring Type: the required rule says ownedMember, and the connector
+/// relates an outer referent to the result. It has no direct relationship carrier;
+/// its two EndFeatureMemberships and ReferenceSubsettings do. Do not conflate
+/// that legitimate dual metaclass with a malformed membership child backlink.
+#[allow(clippy::too_many_arguments)]
+fn stage_binding(
+    b: &Builder,
+    ownership: &mut SemanticOwnership,
+    owner: usize,
+    anchor: usize,
+    referent: usize,
+    target_id: Uuid,
+    binding_ids: &[Uuid; 8],
+    start: usize,
+    output: &mut Vec<Elem>,
+) -> (usize, usize, usize) {
+    let binding = start + 1;
+    let first = start + 3;
+    let second = start + 6;
+    let owner_id = b.elements[owner].id;
+    let referent_id = b.elements[referent].id;
+    let mut rows = Vec::with_capacity(8);
+    let membership_props = |owner: Uuid| {
+        let mut props = Properties::new();
+        props.insert("isImplied", json!(true));
+        props.insert("visibility", json!("public"));
+        props.insert("owningRelatedElement", json!({"@id":owner.to_string()}));
+        props
+    };
+    let node = |ty: &'static str,
+                id: Uuid,
+                owning_relationship: Option<usize>,
+                children: Vec<usize>,
+                owned_relationships: Vec<usize>,
+                props: Properties| Elem {
+        ty,
+        id,
+        path: String::new(),
+        path_parent: None,
+        props,
+        children: children.into(),
+        owned_relationships: owned_relationships.into(),
+        owning_relationship,
+    };
+    rows.push(node(
+        "OwningMembership",
+        binding_ids[0],
+        None,
+        vec![binding],
+        vec![],
+        membership_props(owner_id),
+    ));
+    let mut binding_props = Properties::new();
+    binding_props.insert("isImplied", json!(true));
+    rows.push(node(
+        "BindingConnector",
+        binding_ids[1],
+        Some(start),
+        vec![],
+        vec![start + 2, start + 5],
+        binding_props,
+    ));
+    for (offset, end, target_id) in [(2, first, referent_id), (5, second, target_id)] {
+        rows.push(node(
+            "EndFeatureMembership",
+            binding_ids[offset],
+            None,
+            vec![end],
+            vec![],
+            membership_props(binding_ids[1]),
+        ));
+        let mut props = Properties::new();
+        props.insert("isEnd", json!(true));
+        props.insert("isComposite", json!(false));
+        rows.push(node(
+            "Feature",
+            binding_ids[offset + 1],
+            Some(start + offset),
+            vec![],
+            vec![start + offset + 2],
+            props,
+        ));
+        let mut props = Properties::new();
+        props.insert("isImplied", json!(true));
+        props.insert(
+            "owningRelatedElement",
+            json!({"@id":binding_ids[offset+1].to_string()}),
+        );
+        props.insert(
+            "subsettingFeature",
+            json!({"@id":binding_ids[offset+1].to_string()}),
+        );
+        props.insert("referencedFeature", json!({"@id":target_id.to_string()}));
+        rows.push(node(
+            "ReferenceSubsetting",
+            binding_ids[offset + 2],
+            None,
+            vec![],
+            vec![],
+            props,
+        ));
+    }
+    for (offset, row) in rows.into_iter().enumerate() {
+        let carrier = match offset {
+            0 => Some(owner),
+            2 | 5 => Some(binding),
+            4 => Some(first),
+            7 => Some(second),
+            _ => None,
+        };
+        output.push(row);
+        ownership
+            .register(start + offset, carrier, anchor, offset == 0)
+            .expect("prevalidated generated binding subtree");
+    }
+    (binding, first, second)
+}
+
+pub(super) struct ConstructorDefaultPlan {
+    expression: usize,
+    result: usize,
+    feature: usize,
+    value: usize,
+    ids: [Uuid; 8],
+}
+impl ConstructorDefaultPlan {
+    pub(super) fn ids(&self) -> impl Iterator<Item = Uuid> + '_ {
+        self.ids.iter().copied()
+    }
+}
+/// Omitted defaults share constructor argument selection and the checked
+/// redefinition provider. Incomplete constructors contribute no partial family.
+pub(super) fn plan_constructor_defaults(
+    b: &mut Builder,
+    reserved: &HashSet<Uuid>,
+    steps: &mut usize,
+) -> Option<Vec<ConstructorDefaultPlan>> {
+    if b.graph_format != crate::model::GraphFormat::CanonicalV3 {
+        return Some(Vec::new());
+    }
+    let mut batch = super::constructor_bindings::ConstructorBatchEvidence::default();
+    let mut plans = Vec::new();
+    charge(steps, reserved.len())?;
+    let mut assigned = reserved.clone();
+    for expression in 0..b.explicit_len() {
+        charge(steps, 1)?;
+        if b.elements[expression].ty != "ConstructorExpression" {
+            continue;
+        }
+        let Ok(arguments) = b.checked_constructor_bindings_in_batch(
+            expression,
+            steps,
+            Some(&mut Default::default()),
+            &mut batch,
+        ) else {
+            charge(steps, 0)?;
+            continue;
+        };
+        let Ok(defaults) = b.checked_constructor_defaults_in_batch(&arguments, steps, &mut batch)
+        else {
+            charge(steps, 0)?;
+            continue;
+        };
+        let mut candidate = Vec::new();
+        let mut candidate_ids = HashSet::new();
+        let mut valid = true;
+        for default in defaults {
+            charge(steps, 8)?;
+            let owner_id = b.elements[arguments.result.0].id;
+            let valuation_id = b.elements[default.valuation.0].id;
+            let binding = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{owner_id}/implied/defaultBinding/{valuation_id}").as_bytes(),
+            );
+            let id = |suffix: &str| {
+                Uuid::new_v5(
+                    &Uuid::NAMESPACE_OID,
+                    format!("{binding}/{suffix}").as_bytes(),
+                )
+            };
+            let ids = [
+                id("membership"),
+                binding,
+                id("endMembership/0"),
+                id("end/0"),
+                id("reference/0"),
+                id("endMembership/1"),
+                id("end/1"),
+                id("reference/1"),
+            ];
+            for generated in ids {
+                if b.element_index_of_uuid(generated).is_some()
+                    || assigned.contains(&generated)
+                    || !candidate_ids.insert(generated)
+                {
+                    valid = false;
+                }
+            }
+            candidate.push(ConstructorDefaultPlan {
+                expression,
+                result: arguments.result.0,
+                feature: default.feature_with_value.0,
+                value: default.value.0,
+                ids,
+            });
+        }
+        if valid {
+            assigned.extend(candidate_ids);
+            plans.extend(candidate);
+        }
+    }
+    Some(plans)
+}
+pub(super) fn stage_constructor_default(
+    b: &Builder,
+    ownership: &mut SemanticOwnership,
+    plan: ConstructorDefaultPlan,
+    start: usize,
+    output: &mut Vec<Elem>,
+) -> ([(Uuid, Uuid); 2], [super::local_featuring::Role; 2]) {
+    let feature_id = b.elements[plan.feature].id;
+    let value_id = b.elements[plan.value].id;
+    let (binding, first, second) = stage_binding(
+        b,
+        ownership,
+        plan.result,
+        plan.expression,
+        plan.feature,
+        value_id,
+        &plan.ids,
+        start,
+        output,
+    );
+    (
+        [(plan.ids[3], feature_id), (plan.ids[6], value_id)],
+        [
+            super::local_featuring::Role {
+                source: first,
+                target: binding,
+                anchor: plan.expression,
+            },
+            super::local_featuring::Role {
+                source: second,
+                target: binding,
+                anchor: plan.expression,
+            },
+        ],
+    )
+}
+
+/// Verify the published subtree by reciprocal membership and typed endpoint
+/// evidence. Source isImplied flags cannot stand in for a generated owner.
+pub(super) fn constructor_default_present(
+    b: &mut Builder,
+    owner: usize,
+    default: &super::constructor_bindings::ConstructorDefaultBinding,
+    steps: &mut usize,
+) -> bool {
+    let checked = (|| {
+        let raw = StoredStructure::for_query(b, steps)?;
+        let owner_id = b.elements[owner].id;
+        let valuation_id = b.elements[default.valuation.0].id;
+        let binding_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{owner_id}/implied/defaultBinding/{valuation_id}").as_bytes(),
+        );
+        let binding = raw.element_for_uuid(b, binding_id)?;
+        if b.elements[binding].ty != "BindingConnector" || binding < b.explicit_len() {
+            return None;
+        }
+        let membership = b.elements[binding].owning_relationship?;
+        let view = b.semantic_ownership.as_ref()?;
+        if !view.matches_suffix(b)
+            || view.generated_relationship_owner(membership) != Some(owner)
+            || super::membership_evidence::member(b, &raw, owner, membership, steps)? != binding
+        {
+            return None;
+        }
+        let members = super::semantic_ownership::owned_relationships(b, binding)?;
+        charge(steps, members.len())?;
+        let members: Vec<_> = members
+            .iter()
+            .filter(|&rel| b.elements[rel].ty == "EndFeatureMembership")
+            .collect();
+        if members.len() != 2 {
+            return None;
+        }
+        for (membership, expected) in members
+            .into_iter()
+            .zip([default.feature_with_value.0, default.value.0])
+        {
+            let end = super::membership_evidence::member(b, &raw, binding, membership, steps)?;
+            if b.elements[end].ty != "Feature"
+                || b.elements[end].props.get("isEnd").and_then(|v| v.as_bool()) != Some(true)
+                || !raw.membership_domains(b, steps)?.owner_complete(binding)
+            {
+                return None;
+            }
+            let relationships = super::semantic_ownership::owned_relationships(b, end)?;
+            charge(steps, relationships.len())?;
+            let references: Vec<_> = relationships
+                .iter()
+                .filter(|&rel| b.elements[rel].ty == "ReferenceSubsetting")
+                .collect();
+            if references.len() != 1
+                || super::semantic_ownership::checked_relationship_carrier(
+                    b,
+                    &raw,
+                    references[0],
+                    steps,
+                ) != Some(Some(end))
+            {
+                return None;
+            }
+            let typing = raw.typing(b, steps)?;
+            if typing.sources_incomplete {
+                return None;
+            }
+            let incoming = typing
+                .relationships
+                .get(&end)
+                .map_or(&[][..], Vec::as_slice);
+            charge(steps, incoming.len())?;
+            if incoming.iter().any(|&relationship| {
+                b.elements[relationship].ty == "ReferenceSubsetting"
+                    && relationship != references[0]
+            }) {
+                return None;
+            }
+            let target = super::type_relations::endpoint_with_carrier(
+                b,
+                end,
+                Some(end),
+                references[0],
+                &["specific", "subsettingFeature", "referencingFeature"],
+                &["general", "subsettedFeature", "referencedFeature"],
+                "Feature",
+                steps,
+            )?;
+            if target != expected {
+                return None;
+            }
+        }
+        Some(())
+    })();
+    checked.is_some()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    fn model() -> (ResolvedModel, usize) {
+        let mut model = Model::new();
+        model.add_source(
+            "owned-results.kerml",
+            "feature n; feature x=n; feature y=n;",
+        );
+        assert!(!model.has_errors());
+        let r = ResolvedModel::build(&model);
+        let expression = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap()
+            .0;
+        (r, expression)
+    }
+
+    #[test]
+    fn owning_referent_without_owned_child_is_not_admitted() {
+        let (mut r, expression) = model();
+        let membership = r.b.elements[expression].owned_relationships[0];
+        assert_eq!(r.b.elements[membership].ty, "Membership");
+        for bad_kind in ["OwningMembership", "FeatureMembership"] {
+            r.b.elements[membership].ty = bad_kind;
+            let plans = plan_reference_results(&mut r.b, &mut 0).unwrap();
+            assert!(!plans.iter().any(|p| p.expression == expression));
+        }
+    }
+
+    #[test]
+    fn exhausted_planning_drops_all_earlier_positive_plans() {
+        let (r, _) = model();
+        let mut measured = r.b.clone();
+        let mut used = 0;
+        let plans = plan_reference_results(&mut measured, &mut used).unwrap();
+        assert_eq!(plans.len(), 2);
+        assert!(used > 1 && used < crate::eval::MAX_STEPS);
+        let mut limited = r.b.clone();
+        let count = limited.elements.len();
+        let mut steps = crate::eval::MAX_STEPS - used + 1;
+        assert!(plan_reference_results(&mut limited, &mut steps).is_none());
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert_eq!(
+            limited.elements.len(),
+            count,
+            "planning never appends a prefix"
+        );
+    }
+
+    #[test]
+    fn certified_generated_carriers_still_refuse_raw_contradictions_and_duplicate_ids() {
+        let (mut r, expression) = model();
+        r.ensure_implied();
+        let view = r.b.semantic_ownership.as_ref().unwrap().clone();
+        let result = view.result(expression).unwrap();
+        let mut steps = 0;
+        let raw = StoredStructure::get(&mut r.b, &mut steps).unwrap();
+        assert_eq!(
+            view.effective_carrier(&r.b, &raw, result.membership, &mut steps),
+            Some(Some(expression))
+        );
+        let wrong_id = r.b.elements[result.feature].id;
+        r.b.elements[result.membership]
+            .props
+            .insert("owningRelatedElement", json!({"@id":wrong_id.to_string()}));
+        let raw = StoredStructure::get(&mut r.b, &mut steps).unwrap();
+        assert_eq!(
+            view.effective_carrier(&r.b, &raw, result.membership, &mut steps),
+            None
+        );
+        let owner_id = r.b.elements[expression].id;
+        r.b.elements[result.membership]
+            .props
+            .insert("owningRelatedElement", json!({"@id":owner_id.to_string()}));
+        r.b.elements[result.membership].owning_relationship = Some(result.membership);
+        let raw = StoredStructure::get(&mut r.b, &mut steps).unwrap();
+        assert_eq!(
+            view.effective_carrier(&r.b, &raw, result.membership, &mut steps),
+            None
+        );
+        r.b.elements[result.membership].owning_relationship = None;
+        r.b.elements[result.feature].id = owner_id;
+        r.b.id_index = None;
+        let raw = StoredStructure::get(&mut r.b, &mut steps).unwrap();
+        assert!(!raw.ids_unique);
+        assert_eq!(
+            view.effective_carrier(&r.b, &raw, result.membership, &mut steps),
+            None
+        );
+    }
+    #[test]
+    fn owned_binding_has_membership_backlink_but_no_direct_relationship_carrier() {
+        let (mut r, expression) = model();
+        r.ensure_implied();
+        let view = r.b.semantic_ownership.clone().unwrap();
+        let binding_member = view
+            .relationships(&r.b, expression)
+            .unwrap()
+            .iter()
+            .find(|&rel| r.b.elements[rel].ty == "OwningMembership")
+            .unwrap();
+        let binding = r.b.elements[binding_member].children[0];
+        assert_eq!(r.b.elements[binding].ty, "BindingConnector");
+        assert_eq!(
+            r.b.elements[binding].owning_relationship,
+            Some(binding_member)
+        );
+        let mut steps = 0;
+        let raw = StoredStructure::for_query(&mut r.b, &mut steps).unwrap();
+        assert_eq!(raw.carrier(&r.b, binding), Some(None));
+        assert_eq!(
+            super::super::semantic_ownership::checked_relationship_carrier(
+                &r.b, &raw, binding, &mut steps
+            ),
+            Some(None)
+        );
+        assert_eq!(
+            super::super::semantic_ownership::checked_relationship_carrier(
+                &r.b,
+                &raw,
+                binding_member,
+                &mut steps
+            ),
+            Some(Some(expression))
+        );
+        assert_eq!(
+            r.owner(super::super::ElementRef(binding)),
+            Some(super::super::ElementRef(expression))
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/parameter_context.rs b/crates/sysmlv2-model/src/json/parameter_context.rs
new file mode 100644
index 0000000..103cbe2
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/parameter_context.rs
@@ -0,0 +1,463 @@
+//! Receiver-qualified admission of generalized runtime parameter references.
+use super::{
+    Builder, ElementRef, ResolvedModel, ScopeRef, provider_completeness::ProviderCompleteness,
+};
+use std::collections::{HashMap, HashSet};
+
+/// The runtime input declaration selected within one active calculation frame.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RuntimeParameterSelection {
+    /// A unique input of the active calculation matches or redefines the referent.
+    Selected(ElementRef),
+    /// The reference has no contextual parameter in this frame.
+    NotApplicable,
+    /// Incomplete, cyclic or ambiguous relationships prevent safe selection.
+    Unsupported,
+}
+
+pub(super) fn descendant(
+    b: &Builder,
+    mut scope: usize,
+    ancestor: usize,
+    steps: &mut usize,
+) -> Option<bool> {
+    b.scopes.get(ancestor)?;
+    for _ in 0..=super::MAX_RESOLUTION_DEPTH {
+        charge(steps, 1)?;
+        let context = b.scopes.get(scope)?;
+        if scope == ancestor {
+            return Some(true);
+        }
+        match context.parent {
+            Some(parent) => scope = parent,
+            None => return Some(false),
+        }
+    }
+    None
+}
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+/// Recorded explicit edges only: resolving a missing endpoint here could use
+/// the currently executing expression's source instead of its declaration.
+pub(super) fn explicit_ancestor(
+    b: &mut Builder,
+    callee: usize,
+    ancestor: usize,
+    steps: &mut usize,
+) -> Option<bool> {
+    b.ensure_spec_index();
+    let mut stack = vec![(callee, 0)];
+    let mut seen = HashSet::new();
+    let mut found = false;
+    while let Some((element, depth)) = stack.pop() {
+        charge(steps, 1)?;
+        if depth > super::MAX_RESOLUTION_DEPTH {
+            return None;
+        }
+        b.elements.get(element)?;
+        if !seen.insert(element) {
+            continue;
+        }
+        found |= element == ancestor;
+        for &index in b.spec_index.as_ref()?.get(&element).into_iter().flatten() {
+            charge(steps, 1)?;
+            let target = b.spec_resolved.get(index).copied().flatten()?;
+            stack.push((target, depth + 1));
+        }
+    }
+    Some(found)
+}
+
+struct Redefinitions {
+    target: usize,
+    known: HashMap<(usize, usize), bool>,
+    active: HashSet<usize>,
+}
+
+impl Redefinitions {
+    fn reaches(
+        &mut self,
+        b: &mut Builder,
+        element: usize,
+        depth: usize,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        if depth > super::MAX_RESOLUTION_DEPTH || element >= b.elements.len() {
+            return None;
+        }
+        if let Some(&reaches) = self.known.get(&(element, depth)) {
+            return Some(reaches);
+        }
+        if !self.active.insert(element) {
+            return None;
+        }
+        let result = (|| {
+            if !crate::metaclass::conforms(b.elements[element].ty, "Feature") {
+                return None;
+            }
+            let targets = b.cardinality_redefinition_targets(element, steps)?;
+            charge(steps, targets.len())?;
+            let mut reaches = element == self.target;
+            // Complete the whole closure even after finding the target: a
+            // second edge may be missing or cyclic rather than another alias.
+            for target in targets {
+                reaches |= self.reaches(b, target, depth + 1, steps)?;
+            }
+            Some(reaches)
+        })();
+        self.active.remove(&element);
+        if let Some(reaches) = result {
+            self.known.insert((element, depth), reaches);
+        }
+        result
+    }
+}
+
+impl Builder {
+    pub(crate) fn runtime_parameter_visible_with_steps(
+        &self,
+        parameter: usize,
+        lexical_scope: usize,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        if parameter >= self.elements.len() || lexical_scope >= self.scopes.len() {
+            return None;
+        }
+        let declaration = self.owner_scope_of(parameter)?;
+        descendant(self, lexical_scope, declaration, steps)
+    }
+
+    pub(crate) fn runtime_parameter_selection(
+        &mut self,
+        callee: usize,
+        lexical_scope: usize,
+        receiver_scope: usize,
+        target: usize,
+    ) -> RuntimeParameterSelection {
+        self.runtime_parameter_selection_with_steps(
+            callee,
+            lexical_scope,
+            receiver_scope,
+            target,
+            &mut 0,
+        )
+    }
+
+    pub(crate) fn runtime_parameter_selection_with_steps(
+        &mut self,
+        callee: usize,
+        lexical_scope: usize,
+        receiver_scope: usize,
+        target: usize,
+        steps: &mut usize,
+    ) -> RuntimeParameterSelection {
+        use RuntimeParameterSelection::{NotApplicable, Selected, Unsupported};
+        if charge(steps, 1).is_none() {
+            return Unsupported;
+        }
+        let Some(&callee_scope) = self.elem_scope.get(&callee) else {
+            return Unsupported;
+        };
+        match descendant(self, receiver_scope, callee_scope, steps) {
+            Some(true) => {}
+            Some(false) => return NotApplicable,
+            None => return Unsupported,
+        }
+        let Some(lexically_inside) = descendant(self, lexical_scope, callee_scope, steps) else {
+            return Unsupported;
+        };
+        if !ProviderCompleteness::default().scope(self, callee_scope, steps) {
+            return Unsupported;
+        }
+        if !lexically_inside {
+            let Some(owner) = self.nearest_scope_owner(lexical_scope) else {
+                return NotApplicable;
+            };
+            match explicit_ancestor(self, callee, owner, steps) {
+                Some(true) => {}
+                Some(false) => return NotApplicable,
+                None => return Unsupported,
+            }
+        }
+        let Some(parameters) = self.calc_parameter_bindings(callee) else {
+            return Unsupported;
+        };
+        let mut closure = Redefinitions {
+            target,
+            known: HashMap::new(),
+            active: HashSet::new(),
+        };
+        let mut selected = None;
+        for parameter in parameters {
+            match closure.reaches(self, parameter.element.0, 0, steps) {
+                Some(true) => {
+                    if selected.replace(parameter.element).is_some() {
+                        return Unsupported;
+                    }
+                }
+                Some(false) => {}
+                None => return Unsupported,
+            }
+        }
+        selected.map_or(NotApplicable, Selected)
+    }
+}
+
+impl ResolvedModel {
+    /// Whether an exact runtime parameter binding is lexically visible from
+    /// this expression's declaration scope. A matching element identity alone
+    /// does not allow an unrelated calculation to capture its caller's input.
+    /// `None` means the scope is unavailable or the shared proof budget is
+    /// exhausted; it must not be treated as permission to use the binding.
+    pub fn runtime_parameter_visible_with_steps(
+        &self,
+        parameter: ElementRef,
+        lexical_scope: ScopeRef,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        self.b
+            .runtime_parameter_visible_with_steps(parameter.0, lexical_scope.0, steps)
+    }
+
+    /// Select a generalized input reference within one active calculation
+    /// frame, after checking runtime bindings for the exact reference identity.
+    /// Receiver scope must be inside the callee; lexical scope must be inside
+    /// it or owned by a proven explicit ancestor. Only a unique, complete
+    /// Redefinition closure admits a parameter. An unsupported result must not
+    /// fall through to a declaration default, and a selected input must still
+    /// have a value in that same frame.
+    pub fn runtime_parameter_selection(
+        &mut self,
+        callee: ElementRef,
+        lexical_scope: ScopeRef,
+        receiver_scope: ScopeRef,
+        target: ElementRef,
+    ) -> RuntimeParameterSelection {
+        self.b
+            .runtime_parameter_selection(callee.0, lexical_scope.0, receiver_scope.0, target.0)
+    }
+
+    /// As [`Self::runtime_parameter_selection`], charging proof work against
+    /// an evaluation-wide step count. Repeated frame queries share the same
+    /// budget rather than each receiving a fresh allowance. Exhaustion returns
+    /// [`RuntimeParameterSelection::Unsupported`].
+    pub fn runtime_parameter_selection_with_steps(
+        &mut self,
+        callee: ElementRef,
+        lexical_scope: ScopeRef,
+        receiver_scope: ScopeRef,
+        target: ElementRef,
+        steps: &mut usize,
+    ) -> RuntimeParameterSelection {
+        self.b.runtime_parameter_selection_with_steps(
+            callee.0,
+            lexical_scope.0,
+            receiver_scope.0,
+            target.0,
+            steps,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+
+    fn resolved(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_source("parameter-context.sysml", source);
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn generalized_input_requires_matching_receiver_and_lexical_context() {
+        let mut model = resolved(
+            "calc def Base { in p default 1; attribute v = p; }
+             calc def Child :> Base { in q :>> Base::p; calc def Nested { q } }
+             calc def Other { Base::p }
+             package Constants { attribute global = Base::p; }",
+        );
+        let child = model.resolve_qualified("Child").unwrap();
+        let base = model.resolve_qualified("Base").unwrap();
+        let q = model.resolve_qualified("Child::q").unwrap();
+        let p = model.resolve_qualified("Base::p").unwrap();
+        let child_scope = model.element_scope(child).unwrap();
+        let base_scope = model.element_scope(base).unwrap();
+        for name in ["Child", "Child::Nested", "Base"] {
+            let owner = model.resolve_qualified(name).unwrap();
+            let lexical = model.element_scope(owner).unwrap();
+            assert_eq!(
+                model.runtime_parameter_selection(child, lexical, child_scope, p),
+                RuntimeParameterSelection::Selected(q),
+                "{name}",
+            );
+        }
+        for name in ["Other", "Constants"] {
+            let owner = model.resolve_qualified(name).unwrap();
+            let lexical = model.element_scope(owner).unwrap();
+            assert_eq!(
+                model.runtime_parameter_selection(child, lexical, child_scope, p),
+                RuntimeParameterSelection::NotApplicable,
+                "{name}",
+            );
+        }
+        assert_eq!(
+            model.runtime_parameter_selection(child, base_scope, base_scope, p),
+            RuntimeParameterSelection::NotApplicable,
+        );
+    }
+
+    #[test]
+    fn competing_inputs_and_incomplete_closures_are_unsupported() {
+        let mut model = resolved(
+            "calc def Base { in p; }
+             calc def Child :> Base { in q :>> Base::p; }
+             calc def Ambiguous :> Base { in q :>> Base::p; in r :>> Base::p; }",
+        );
+        let child = model.resolve_qualified("Child").unwrap();
+        let ambiguous = model.resolve_qualified("Ambiguous").unwrap();
+        let p = model.resolve_qualified("Base::p").unwrap();
+        let q = model.resolve_qualified("Child::q").unwrap();
+        let child_scope = model.element_scope(child).unwrap();
+        let ambiguous_scope = model.element_scope(ambiguous).unwrap();
+        assert_eq!(
+            model.runtime_parameter_selection(ambiguous, ambiguous_scope, ambiguous_scope, p),
+            RuntimeParameterSelection::Unsupported,
+        );
+        model.b.ensure_spec_index();
+        let index = model.b.spec_index.as_ref().unwrap()[&q.0][0];
+        let saved = model.b.spec_resolved[index];
+        model.b.spec_resolved[index] = None;
+        assert_eq!(
+            model.runtime_parameter_selection(child, child_scope, child_scope, p),
+            RuntimeParameterSelection::Unsupported,
+        );
+        model.b.spec_resolved[index] = Some(q.0);
+        assert_eq!(
+            model.runtime_parameter_selection(child, child_scope, child_scope, p),
+            RuntimeParameterSelection::Unsupported,
+        );
+        model.b.spec_resolved[index] = saved;
+        assert_eq!(
+            model.runtime_parameter_selection(child, child_scope, child_scope, p),
+            RuntimeParameterSelection::Selected(q),
+        );
+    }
+
+    #[test]
+    fn repeated_selections_charge_shared_budget_and_recover_in_a_new_query() {
+        let mut model = resolved(
+            "calc def Base { in p; }
+             calc def Child :> Base { in q :>> Base::p; }",
+        );
+        let child = model.resolve_qualified("Child").unwrap();
+        let p = model.resolve_qualified("Base::p").unwrap();
+        let q = model.resolve_qualified("Child::q").unwrap();
+        let scope = model.element_scope(child).unwrap();
+        let mut steps = 0;
+        for _ in 0..2 {
+            let before = steps;
+            assert_eq!(
+                model.runtime_parameter_selection_with_steps(child, scope, scope, p, &mut steps),
+                RuntimeParameterSelection::Selected(q),
+            );
+            assert!(steps > before);
+        }
+        steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            model.runtime_parameter_selection_with_steps(child, scope, scope, p, &mut steps),
+            RuntimeParameterSelection::Unsupported,
+        );
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert_eq!(
+            model.runtime_parameter_selection(child, scope, scope, p),
+            RuntimeParameterSelection::Selected(q),
+        );
+    }
+
+    #[test]
+    fn exact_bindings_require_lexical_containment_including_lambda_scopes() {
+        let mut model = resolved(
+            "calc def Base { in p; calc def Nested { Base::p }
+                 attribute values = (1,2)->collect { in lambdaInput; lambdaInput }; }
+             calc def Other { Base::p }
+             package Constants { attribute bridge = Base::p; }",
+        );
+        let p = model.resolve_qualified("Base::p").unwrap();
+        let mut steps = 0;
+        for (name, expected) in [
+            ("Base", true),
+            ("Base::Nested", true),
+            ("Other", false),
+            ("Constants", false),
+        ] {
+            let owner = model.resolve_qualified(name).unwrap();
+            let lexical = model.element_scope(owner).unwrap();
+            assert_eq!(
+                model.runtime_parameter_visible_with_steps(p, lexical, &mut steps),
+                Some(expected),
+                "{name}"
+            );
+        }
+        let lambda_parameter = model
+            .b
+            .elements
+            .iter()
+            .position(|element| {
+                element
+                    .props
+                    .get("declaredName")
+                    .and_then(|value| value.as_str())
+                    == Some("lambdaInput")
+            })
+            .unwrap();
+        let lambda_scope = ScopeRef(model.b.owner_scope_of(lambda_parameter).unwrap());
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(p, lambda_scope, &mut steps),
+            Some(true)
+        );
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(
+                ElementRef(lambda_parameter),
+                lambda_scope,
+                &mut steps
+            ),
+            Some(true)
+        );
+        let base_scope = model.b.owner_scope_of(p.0).unwrap();
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(
+                ElementRef(lambda_parameter),
+                ScopeRef(base_scope),
+                &mut steps
+            ),
+            Some(false)
+        );
+        steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(p, lambda_scope, &mut steps),
+            None
+        );
+        steps = 0;
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(p, lambda_scope, &mut steps),
+            Some(true)
+        );
+        assert_eq!(
+            model.runtime_parameter_visible_with_steps(
+                ElementRef(usize::MAX),
+                lambda_scope,
+                &mut steps
+            ),
+            None
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/parameters.rs b/crates/sysmlv2-model/src/json/parameters.rs
new file mode 100644
index 0000000..81beed3
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/parameters.rs
@@ -0,0 +1,1586 @@
+//! Declaration identities used to admit runtime parameter bindings.
+use super::{Builder, ElementRef, ResolvedModel, ScopeRef};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+use sysmlv2_syntax::ast::{Expr, ExprKind, FeatureDirection, MemberKind, QualifiedName};
+
+/// A parameter's declaration identity and the name an argument binds it by.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ParameterBinding {
+    /// The name a named argument binds the parameter by: its declared name,
+    /// else that of the parameter it redefines (`in :>> b` is `b`), whether
+    /// explicitly or by position. Empty when neither supplies one.
+    pub name: String,
+    /// The parameter declaration in the resolved model.
+    pub element: ElementRef,
+}
+
+/// The declaration selected by a reference in its source and lexical context.
+/// An exact identity may have no in-model target; that case must not fall back
+/// to an unrelated runtime binding with the same textual spelling.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ReferenceIdentity {
+    /// The selected declaration, if it is present in this model.
+    pub target: Option<ElementRef>,
+    /// Whether this source site carries an exact identity binding.
+    pub identity_bound: bool,
+}
+
+type SiteKey = (usize, u32, u32);
+type ParameterSite = (usize, usize);
+
+/// Derived from declaration spans, never serialized. The size stamp rejects a
+/// library-prefix index after user declarations have been appended to its clone.
+#[derive(Clone)]
+pub(super) struct ParameterSites {
+    elements_len: usize,
+    sites: HashMap<SiteKey, Option<ParameterSite>>,
+}
+
+/// Signatures of a completed, unchanged graph. Cached failures retain their
+/// distinction from a valid empty signature.
+#[derive(Clone)]
+pub(super) struct ParameterSignatures {
+    elements_len: usize,
+    signatures: HashMap<usize, Option<Vec<ParameterBinding>>>,
+}
+
+impl ParameterSites {
+    fn build(b: &Builder) -> Self {
+        let mut sites = HashMap::new();
+        for (&element, span) in b.member_spans.iter() {
+            if !input_parameter(b, element) {
+                continue;
+            }
+            let key = (b.unit_of_elem(element), span.start, span.end);
+            let site = b.owner_scope_of(element).map(|scope| (element, scope));
+            sites
+                .entry(key)
+                .and_modify(|previous| {
+                    if *previous != site {
+                        *previous = None;
+                    }
+                })
+                .or_insert(site);
+        }
+        Self {
+            elements_len: b.elements.len(),
+            sites,
+        }
+    }
+
+    fn current(&self, b: &Builder) -> bool {
+        self.elements_len == b.elements.len()
+    }
+}
+
+fn input_parameter(b: &Builder, element: usize) -> bool {
+    b.is_parameter(element)
+        && matches!(
+            b.elements[element]
+                .props
+                .get("direction")
+                .and_then(|value| value.as_str()),
+            Some("in" | "inout")
+        )
+}
+
+/// Deeper heritage than any callable needs: a walk past it answers
+/// no signature instead of exhausting the stack.
+const MAX_SIGNATURE_DEPTH: usize = 64;
+
+/// One callable's signature walk: each type's parameter list once, its owned
+/// parameters once with the type that owns each, the types whose lists are
+/// still being worked out, and the positional slots read on the way.
+#[derive(Default)]
+struct SignatureWalk {
+    lists: HashMap<usize, Option<Vec<usize>>>,
+    owned: HashMap<usize, Vec<usize>>,
+    owners: HashMap<usize, usize>,
+    active: HashSet<usize>,
+    slots: SlotMemo,
+}
+
+/// A role whose redefinition the specification implies by position.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Role {
+    Parameter,
+    End,
+    Result,
+    Subject,
+}
+
+/// The slots of each type and role read so far by one positional walk —
+/// a function of the heritage and the structure, which do not change
+/// while a walk runs — and the ones being worked out up the recursion.
+/// Exact for an acyclic heritage: on a cycle the re-entered type answers
+/// its own slots, which the types consuming that answer keep.
+#[derive(Default)]
+pub(crate) struct SlotMemo {
+    slots: HashMap<(usize, Role), Vec<usize>>,
+    active: HashSet<(usize, Role)>,
+    /// Header names resolved once in the feature's own context.
+    spelled_redefinitions: HashMap<usize, Vec<usize>>,
+}
+
+fn behavior_or_step(ty: &str) -> bool {
+    conforms(ty, "Behavior") || conforms(ty, "Step")
+}
+
+fn function_or_expression(ty: &str) -> bool {
+    conforms(ty, "Function") || conforms(ty, "Expression")
+}
+
+/// The SysML families whose subject redefines its general's subject, even an
+/// inherited one: requirements and cases.
+fn subject_family(ty: &str) -> Option<u8> {
+    if conforms(ty, "RequirementDefinition") || conforms(ty, "RequirementUsage") {
+        Some(0)
+    } else if conforms(ty, "CaseDefinition") || conforms(ty, "CaseUsage") {
+        Some(1)
+    } else {
+        None
+    }
+}
+
+impl Builder {
+    fn is_subject(&self, feature: usize) -> bool {
+        self.elements[feature]
+            .owning_relationship
+            .is_some_and(|r| conforms(self.elements[r].ty, "SubjectMembership"))
+    }
+
+    fn is_private_member(&self, feature: usize) -> bool {
+        self.elements[feature].owning_relationship.is_some_and(|r| {
+            self.elements[r]
+                .props
+                .get("visibility")
+                .and_then(|value| value.as_str())
+                == Some("private")
+        })
+    }
+
+    /// A type's owned parameters other than the result, in declaration order:
+    /// the ones a position pairs.
+    fn owned_parameters(&self, owner: usize) -> Vec<usize> {
+        self.owned_member_elems(owner, true)
+            .into_iter()
+            .filter(|&f| self.is_parameter(f) && !self.positional_is_result(f))
+            .collect()
+    }
+
+    /// A type's owned end features, in declaration order.
+    fn owned_ends(&self, owner: usize) -> Vec<usize> {
+        self.owned_member_elems(owner, true)
+            .into_iter()
+            .filter(|&f| self.positional_is_end(f))
+            .collect()
+    }
+
+    /// [`Self::owned_parameters`], recorded in the walk with the owner of
+    /// each parameter.
+    fn ordered_parameters(&self, walk: &mut SignatureWalk, owner: usize) -> Vec<usize> {
+        if let Some(parameters) = walk.owned.get(&owner) {
+            return parameters.clone();
+        }
+        let parameters = self.owned_parameters(owner);
+        for &parameter in &parameters {
+            walk.owners.insert(parameter, owner);
+        }
+        walk.owned.insert(owner, parameters.clone());
+        parameters
+    }
+
+    /// The types `ty` directly specializes, as its inherited members read
+    /// them: its written generals (typings, specializations, subsettings,
+    /// redefinitions, reference subsettings, chains), in the order written,
+    /// then the implied library bases of its kind.
+    fn direct_generals(&mut self, ty: usize) -> Vec<usize> {
+        // A type without a scope of its own (the argument of an assignment,
+        // terminate or satisfy usage) has no body to inherit into and no
+        // generals here — whenever asked: a base scope's answer must not
+        // depend on whether the specialization index exists yet, and a
+        // parameter's positional generals come from `direct_redefinitions`.
+        let Some(&scope) = self.elem_scope.get(&ty) else {
+            return Vec::new();
+        };
+        let (bases, _) = self.base_scopes_split(scope);
+        let mut generals = Vec::new();
+        for base in bases {
+            if let Some(owner) = self.scopes[base].owner {
+                if owner != ty && !generals.contains(&owner) {
+                    generals.push(owner);
+                }
+            }
+        }
+        generals
+    }
+
+    /// The parameters a callable has, its result aside: those it owns, then
+    /// each direct general's (see [`Self::direct_generals`]), in that order,
+    /// but for those its own features redefine. `None` for cyclic or overly
+    /// deep heritage.
+    fn signature(
+        &mut self,
+        walk: &mut SignatureWalk,
+        ty: usize,
+        depth: usize,
+        cacheable: &mut bool,
+    ) -> Option<Vec<usize>> {
+        if let Some(list) = walk.lists.get(&ty) {
+            return list.clone();
+        }
+        if depth > MAX_SIGNATURE_DEPTH || !walk.active.insert(ty) {
+            return None;
+        }
+        let list = self.signature_uncached(walk, ty, depth, cacheable);
+        walk.active.remove(&ty);
+        walk.lists.insert(ty, list.clone());
+        list
+    }
+
+    fn signature_uncached(
+        &mut self,
+        walk: &mut SignatureWalk,
+        ty: usize,
+        depth: usize,
+        cacheable: &mut bool,
+    ) -> Option<Vec<usize>> {
+        // The supertype helper can re-resolve missing outcomes. Do not
+        // retain a result that could depend on ambient source or lookup
+        // state rather than the graph's recorded endpoints.
+        self.ensure_spec_index();
+        if self
+            .spec_index
+            .as_ref()
+            .and_then(|index| index.get(&ty))
+            .is_some_and(|indices| {
+                indices
+                    .iter()
+                    .any(|&index| self.spec_resolved.get(index).is_none_or(Option::is_none))
+            })
+        {
+            *cacheable = false;
+        }
+        let own = self.ordered_parameters(walk, ty);
+        let mut generals = self.direct_generals(ty);
+        // A parameter also specializes the ones it redefines by position: an
+        // argument written `in f = g;` is called with `f`'s parameters.
+        if self.is_parameter(ty) {
+            for target in self.direct_redefinitions(walk, ty) {
+                if !generals.contains(&target) {
+                    generals.push(target);
+                }
+            }
+        }
+        let mut inherited = Vec::new();
+        for general in generals {
+            for parameter in self.signature(walk, general, depth + 1, cacheable)? {
+                if !own.contains(&parameter)
+                    && !inherited.contains(&parameter)
+                    && !self.is_private_member(parameter)
+                {
+                    inherited.push(parameter);
+                }
+            }
+        }
+        if inherited.is_empty() {
+            return Some(own);
+        }
+        // KerML removes an inherited feature that an owned feature redefines
+        // directly, or redefines through something it redefines, and one that
+        // another inherited feature redefines.
+        let owned = self.owned_member_elems(ty, true);
+        let mut owned_targets = HashSet::new();
+        for &feature in &owned {
+            owned_targets.extend(self.direct_redefinitions(walk, feature));
+        }
+        let mut hidden = HashSet::new();
+        for &parameter in &inherited {
+            let closure = self.redefinition_closure(walk, parameter);
+            if closure.iter().any(|t| owned_targets.contains(t)) {
+                hidden.insert(parameter);
+            }
+            hidden.extend(closure.into_iter().filter(|&t| t != parameter));
+        }
+        inherited.retain(|parameter| !hidden.contains(parameter));
+        Some(own.into_iter().chain(inherited).collect())
+    }
+
+    /// The features `feature` redefines in one step: those it names, and
+    /// those its position pairs it with
+    /// ([`Self::positional_redefinition_targets`]), through the type the
+    /// walk recorded as its owner — the arguments of assignment, terminate
+    /// and satisfy usages have no scope of their own, so `owner_elem`
+    /// cannot find them.
+    fn direct_redefinitions(&mut self, walk: &mut SignatureWalk, feature: usize) -> Vec<usize> {
+        let mut targets = self.redefinition_target_elems(feature);
+        let Some(owner) = walk
+            .owners
+            .get(&feature)
+            .copied()
+            .or_else(|| self.owner_elem(feature))
+        else {
+            return targets;
+        };
+        for target in self.positional_targets(feature, owner, &mut walk.slots) {
+            if !targets.contains(&target) {
+                targets.push(target);
+            }
+        }
+        targets
+    }
+
+    /// `feature` and everything it redefines, transitively.
+    fn redefinition_closure(&mut self, walk: &mut SignatureWalk, feature: usize) -> Vec<usize> {
+        let mut closure = vec![feature];
+        let mut next = 0;
+        while let Some(&current) = closure.get(next) {
+            next += 1;
+            for target in self.direct_redefinitions(walk, current) {
+                if !closure.contains(&target) {
+                    closure.push(target);
+                }
+            }
+        }
+        closure
+    }
+
+    /// Whether `e` plays a role whose redefinition the specification implies
+    /// by position — a parameter of a behavior or step, a result, an end —
+    /// so that reusing an inherited name says nothing about what it
+    /// redefines (see [`Self::positional_redefinition_targets`]).
+    pub(crate) fn redefines_by_position(&self, e: usize) -> bool {
+        if self.positional_is_end(e) || self.positional_is_result(e) {
+            return true;
+        }
+        self.is_parameter(e)
+            && self
+                .owner_elem(e)
+                .is_some_and(|owner| behavior_or_step(self.elements[owner].ty))
+    }
+
+    /// KerML's `checkFeatureParameterRedefinition` exempts an invocation's
+    /// argument that names the parameter it redefines (`f(b = 1)`): such an
+    /// argument takes over no parameter by position.
+    fn names_its_redefined_parameter(&self, feature: usize, owner_ty: &str) -> bool {
+        conforms(owner_ty, "InvocationExpression")
+            && self.elements[feature].owned_relationships.iter().any(|&r| {
+                conforms(self.elements[r].ty, "Redefinition")
+                    && self.elements[r]
+                        .props
+                        .get("isImplied")
+                        .and_then(|v| v.as_bool())
+                        != Some(true)
+            })
+    }
+
+    /// The features `feature` redefines by position, read off the direct
+    /// generals of `owner`, the type that owns it (see
+    /// [`Self::direct_generals`]):
+    ///
+    /// - an end feature redefines each general's end at the same position
+    ///   (KerML `checkFeatureEndRedefinition`);
+    /// - a parameter of a behavior or step, its result aside, redefines each
+    ///   behavior or step general's parameter at the same position
+    ///   (`checkFeatureParameterRedefinition`, which exempts only an
+    ///   invocation's argument naming what it redefines);
+    /// - the result of a function or expression redefines each function or
+    ///   expression general's result, wherever that is
+    ///   (`checkFeatureResultRedefinition`);
+    /// - a requirement's or case's subject redefines each same-family
+    ///   general's subject, wherever that is (SysML).
+    ///
+    /// A general's parameters and ends are its effective ones — its own,
+    /// then those it inherits after them, less those its features redefine
+    /// ([`Self::effective_slots`]); its result and subject are its own,
+    /// else the nearest its heritage declares ([`Self::nearest_members`]).
+    /// The parameter walk pairs through this too; the positional planner
+    /// materializes the same edges for the whole model
+    /// (`PositionalRedefinitions`), and also counts a membership a general
+    /// imports as one of its slots, which this structural reading — made
+    /// for a body scope's bases, before the specialization index may
+    /// exist — does not. Nothing for an ambiguous subject or result.
+    pub(crate) fn positional_redefinition_targets(
+        &mut self,
+        feature: usize,
+        owner: usize,
+    ) -> Vec<usize> {
+        self.positional_targets(feature, owner, &mut SlotMemo::default())
+    }
+
+    /// [`Self::positional_redefinition_targets`] within one walk.
+    pub(crate) fn positional_targets(
+        &mut self,
+        feature: usize,
+        owner: usize,
+        memo: &mut SlotMemo,
+    ) -> Vec<usize> {
+        let mut targets = Vec::new();
+        // A cyclic heritage could pair a feature with itself.
+        let push = |targets: &mut Vec<usize>, target: usize| {
+            if target != feature && !targets.contains(&target) {
+                targets.push(target);
+            }
+        };
+        let owner_ty = self.elements[owner].ty;
+        if self.positional_is_end(feature) {
+            let Some(index) = self.owned_ends(owner).iter().position(|&f| f == feature) else {
+                return targets;
+            };
+            for general in self.direct_generals(owner) {
+                if let Some(&target) = self.effective_slots(general, Role::End, memo).get(index) {
+                    push(&mut targets, target);
+                }
+            }
+            return targets;
+        }
+        if self.positional_is_result(feature) {
+            if !function_or_expression(owner_ty) {
+                return targets;
+            }
+            for general in self.direct_generals(owner) {
+                if !function_or_expression(self.elements[general].ty) {
+                    continue;
+                }
+                if let [target] = self.nearest_members(general, Role::Result, memo)[..] {
+                    push(&mut targets, target);
+                }
+            }
+            return targets;
+        }
+        // Every subject family is a behavior or step, so the parameter
+        // rule's owner test comes first and spares a classifier's directed
+        // feature its owner's base fill.
+        if !self.is_parameter(feature) || !behavior_or_step(owner_ty) {
+            return targets;
+        }
+        let own = self.owned_parameters(owner);
+        let Some(index) = own.iter().position(|&p| p == feature) else {
+            return targets;
+        };
+        let subject = self.is_subject(feature);
+        let generals = self.direct_generals(owner);
+        let mut subject_generals = Vec::new();
+        if let Some(family) = subject_family(owner_ty) {
+            if own.iter().filter(|&&p| self.is_subject(p)).count() > 1 {
+                return targets;
+            }
+            for &general in &generals {
+                if subject_family(self.elements[general].ty) != Some(family) {
+                    continue;
+                }
+                match self.nearest_members(general, Role::Subject, memo)[..] {
+                    [] => {}
+                    [target] => {
+                        subject_generals.push(general);
+                        if subject {
+                            push(&mut targets, target);
+                        }
+                    }
+                    _ => return targets,
+                }
+            }
+        }
+        if self.names_its_redefined_parameter(feature, owner_ty) {
+            return targets;
+        }
+        for &general in &generals {
+            if !behavior_or_step(self.elements[general].ty)
+                || (subject && subject_generals.contains(&general))
+            {
+                continue;
+            }
+            if let Some(&target) = self
+                .effective_slots(general, Role::Parameter, memo)
+                .get(index)
+            {
+                push(&mut targets, target);
+            }
+        }
+        targets
+    }
+
+    /// Whether a written redefinition selects this supplied slot. Header names
+    /// select declaration identities, never every inherited slot of that name.
+    fn spelled_redefinition(&mut self, feature: usize, slot: usize, memo: &mut SlotMemo) -> bool {
+        let Some(&scope) = self.elem_scope.get(&feature) else {
+            return false;
+        };
+        let spellings = &self.scopes[scope].redefinition_spellings;
+        if spellings.is_empty() {
+            return false;
+        }
+        if let std::collections::hash_map::Entry::Vacant(entry) =
+            memo.spelled_redefinitions.entry(feature)
+        {
+            let spellings = spellings.clone();
+            let mut targets = Vec::new();
+            if !spellings.is_empty() {
+                // This helper also runs during base-cache construction. Resolve
+                // in the header's own lexical/source context, never the ambient
+                // query's access, exclusion or source-identity mode. Do not read
+                // the specialization index while lowering is still appending it.
+                let query = self.enter_fill_mode();
+                let mark = self.query_imports.len();
+                let origin = self.set_identity_origin(feature);
+                self.exclude = Some(feature);
+                self.redefinition_lookup_owner = self.owner_elem(feature);
+                let from = self.scopes[scope].parent.unwrap_or(scope);
+                for qn in spellings {
+                    if let Some(target) = self.resolve(from, &qn, 0) {
+                        targets.push(target);
+                    }
+                }
+                self.identity_origin_unit = origin;
+                self.query_imports.truncate(mark);
+                self.leave_fill_mode(query);
+            }
+            entry.insert(targets);
+        }
+        memo.spelled_redefinitions[&feature].contains(&slot)
+    }
+
+    /// A type's features of one positional role (its parameters, its ends),
+    /// as a specialization pairs them: its own, then those it inherits
+    /// after them — each general's, nearest first, past the positions its
+    /// own take over (KerML 7.4.7.2: a general's parameters are its owned
+    /// ones, then the inherited ones ordered after them) — less those an
+    /// own slot or another inherited slot redefines, by position or by a
+    /// spelled `:>>`, directly or through what that one redefines (the
+    /// KerML removal of redefined features). A type whose slots are being
+    /// worked out up the recursion contributes its own.
+    fn effective_slots(&mut self, ty: usize, role: Role, memo: &mut SlotMemo) -> Vec<usize> {
+        if let Some(slots) = memo.slots.get(&(ty, role)) {
+            return slots.clone();
+        }
+        let own = match role {
+            Role::Parameter => self.owned_parameters(ty),
+            Role::End => self.owned_ends(ty),
+            Role::Result | Role::Subject => unreachable!("singular roles are read nearest"),
+        };
+        if memo.active.len() > MAX_SIGNATURE_DEPTH || !memo.active.insert((ty, role)) {
+            return own;
+        }
+        let mut inherited = Vec::new();
+        for general in self.direct_generals(ty) {
+            // Positions take over a behavior's or step's parameters and
+            // any general's ends, as the pairing does; a classifier's
+            // directed features are inherited whole.
+            let taken = match role {
+                Role::Parameter if !behavior_or_step(self.elements[general].ty) => 0,
+                _ => own.len(),
+            };
+            for (position, slot) in self
+                .effective_slots(general, role, memo)
+                .into_iter()
+                .enumerate()
+            {
+                if position >= taken && !own.contains(&slot) && !inherited.contains(&slot) {
+                    inherited.push(slot);
+                }
+            }
+        }
+        let mut hidden = HashSet::new();
+        if !inherited.is_empty() {
+            let mut pending: Vec<(usize, usize)> = own
+                .iter()
+                .map(|&slot| (slot, ty))
+                .chain(
+                    inherited
+                        .iter()
+                        .filter_map(|&slot| Some((slot, self.owner_elem(slot)?))),
+                )
+                .collect();
+            let mut seen: HashSet<usize> = pending.iter().map(|&(slot, _)| slot).collect();
+            let mut supplied_by: HashMap<usize, HashSet<usize>> = HashMap::new();
+            while let Some((slot, slot_owner)) = pending.pop() {
+                let mut redefined = self.positional_targets(slot, slot_owner, memo);
+                // A `:>>` spelled on `slot` names a feature its owner
+                // inherits — one of its owner's generals' slots — never a
+                // nearer namesake (`IfThenPerformance::ifTest`, itself a
+                // `:>> ifTest`, cannot hide `IfThenAction`'s).
+                if let std::collections::hash_map::Entry::Vacant(entry) =
+                    supplied_by.entry(slot_owner)
+                {
+                    let mut supplied = HashSet::new();
+                    for general in self.direct_generals(slot_owner) {
+                        supplied.extend(self.effective_slots(general, role, memo));
+                    }
+                    entry.insert(supplied);
+                }
+                let supplied = &supplied_by[&slot_owner];
+                redefined.extend(inherited.iter().copied().filter(|&candidate| {
+                    supplied.contains(&candidate)
+                        && self.spelled_redefinition(slot, candidate, memo)
+                }));
+                for target in redefined {
+                    if target != slot {
+                        hidden.insert(target);
+                        if seen.insert(target) {
+                            if let Some(target_owner) = self.owner_elem(target) {
+                                pending.push((target, target_owner));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        memo.active.remove(&(ty, role));
+        let slots: Vec<usize> = own
+            .into_iter()
+            .chain(inherited.into_iter().filter(|slot| !hidden.contains(slot)))
+            .collect();
+        memo.slots.insert((ty, role), slots.clone());
+        slots
+    }
+
+    /// The members of one singular role (result, subject) a specialization
+    /// of `ty` pairs with: `ty`'s own, else those its generals pair with,
+    /// where a nearer one wins — a candidate reached through another
+    /// candidate's heritage is what that one redefines (`FEA1 :> FEA` with
+    /// `FEA { subject vehicle; }` inherits `vehicle` beside the library
+    /// case's `subj`, which `vehicle` redefines). More than one left means
+    /// the heritage does not say which; a cyclic heritage says nothing.
+    fn nearest_members(&mut self, ty: usize, role: Role, memo: &mut SlotMemo) -> Vec<usize> {
+        if let Some(found) = memo.slots.get(&(ty, role)) {
+            return found.clone();
+        }
+        let select: fn(&Self, usize) -> bool = match role {
+            Role::Result => Self::positional_is_result,
+            Role::Subject => Self::is_subject,
+            Role::Parameter | Role::End => unreachable!("positional roles are read as slots"),
+        };
+        let own: Vec<usize> = self
+            .owned_member_elems(ty, true)
+            .into_iter()
+            .filter(|&m| select(self, m))
+            .collect();
+        if !own.is_empty() {
+            memo.slots.insert((ty, role), own.clone());
+            return own;
+        }
+        if memo.active.len() > MAX_SIGNATURE_DEPTH || !memo.active.insert((ty, role)) {
+            return Vec::new();
+        }
+        let mut candidates = Vec::new();
+        for general in self.direct_generals(ty) {
+            for member in self.nearest_members(general, role, memo) {
+                if !candidates.contains(&member) {
+                    candidates.push(member);
+                }
+            }
+        }
+        memo.active.remove(&(ty, role));
+        if candidates.len() > 1 {
+            let mut reachable = HashSet::new();
+            for &candidate in &candidates {
+                if let Some(owner) = self.owner_elem(candidate) {
+                    self.role_heritage(owner, select, &mut HashSet::new(), 0, &mut reachable);
+                }
+            }
+            candidates.retain(|candidate| !reachable.contains(candidate));
+        }
+        memo.slots.insert((ty, role), candidates.clone());
+        candidates
+    }
+
+    /// Every member of the role `select` reachable through the generals of
+    /// `ty`, at any depth, into `out`.
+    fn role_heritage(
+        &mut self,
+        ty: usize,
+        select: fn(&Self, usize) -> bool,
+        seen: &mut HashSet<usize>,
+        depth: usize,
+        out: &mut HashSet<usize>,
+    ) {
+        if depth > MAX_SIGNATURE_DEPTH || !seen.insert(ty) {
+            return;
+        }
+        for general in self.direct_generals(ty) {
+            for member in self.owned_member_elems(general, true) {
+                if select(self, member) {
+                    out.insert(member);
+                }
+            }
+            self.role_heritage(general, select, seen, depth + 1, out);
+        }
+    }
+
+    /// The name a named argument binds `parameter` by (see
+    /// [`ParameterBinding::name`]), nearest redefinition first.
+    fn binding_name(&mut self, walk: &mut SignatureWalk, parameter: usize) -> Option<String> {
+        let mut pending = vec![parameter];
+        let mut next = 0;
+        while let Some(&current) = pending.get(next) {
+            next += 1;
+            if let Some(name) = self.id_name(current) {
+                return Some(name);
+            }
+            for target in self.direct_redefinitions(walk, current) {
+                if !pending.contains(&target) {
+                    pending.push(target);
+                }
+            }
+        }
+        Some(String::new())
+    }
+}
+
+impl Builder {
+    /// Context-free scope selection without traversing receiver dependencies.
+    pub(crate) fn value_evaluation_scope(
+        &self,
+        element: usize,
+        receiver: Option<usize>,
+    ) -> Option<usize> {
+        let own_scope = self.values.get(&element)?.0;
+        let featured = self
+            .owner_elem(element)
+            .is_some_and(|owner| crate::metaclass::conforms(self.elements[owner].ty, "Type"));
+        (!featured || receiver.is_none_or(|scope| scope == own_scope)).then_some(own_scope)
+    }
+
+    pub(crate) fn reference_identity(
+        &mut self,
+        scope: usize,
+        name: &QualifiedName,
+    ) -> ReferenceIdentity {
+        let identity_bound = self.id_spelled_target(scope, name).is_some();
+        ReferenceIdentity {
+            target: self.resolve(scope, name, 0).map(ElementRef),
+            identity_bound,
+        }
+    }
+
+    /// The inputs of the callable's signature (see [`Self::signature`]) with
+    /// the names a named argument binds them by.
+    pub(crate) fn calc_parameter_bindings(
+        &mut self,
+        element: usize,
+    ) -> Option<Vec<ParameterBinding>> {
+        if !self.semantic_ready {
+            return self.calc_parameter_bindings_uncached(element, &mut false);
+        }
+        if self
+            .parameter_signatures
+            .as_ref()
+            .is_none_or(|cache| cache.elements_len != self.elements.len())
+        {
+            self.parameter_signatures = Some(ParameterSignatures {
+                elements_len: self.elements.len(),
+                signatures: HashMap::new(),
+            });
+        }
+        if let Some(signature) = self
+            .parameter_signatures
+            .as_ref()
+            .and_then(|cache| cache.signatures.get(&element))
+        {
+            return signature.clone();
+        }
+        let mut cacheable = true;
+        let signature = self.calc_parameter_bindings_uncached(element, &mut cacheable);
+        if cacheable {
+            self.parameter_signatures
+                .as_mut()
+                .expect("a ready graph initialized its signature cache")
+                .signatures
+                .insert(element, signature.clone());
+        }
+        signature
+    }
+
+    fn calc_parameter_bindings_uncached(
+        &mut self,
+        element: usize,
+        cacheable: &mut bool,
+    ) -> Option<Vec<ParameterBinding>> {
+        let mut names = HashSet::new();
+        let mut bindings = Vec::new();
+        for parameter in self.named_signature(element, cacheable)? {
+            if !input_parameter(self, parameter.element.0) {
+                continue;
+            }
+            if !parameter.name.is_empty() && !names.insert(parameter.name.clone()) {
+                return None;
+            }
+            bindings.push(parameter);
+        }
+        Some(bindings)
+    }
+
+    /// The callable's signature (see [`Self::signature`]), each parameter
+    /// with the name an argument binds it by.
+    pub(crate) fn named_signature(
+        &mut self,
+        callee: usize,
+        cacheable: &mut bool,
+    ) -> Option<Vec<ParameterBinding>> {
+        let mut walk = SignatureWalk::default();
+        self.signature(&mut walk, callee, 0, cacheable)?
+            .into_iter()
+            .map(|parameter| {
+                Some(ParameterBinding {
+                    name: self.binding_name(&mut walk, parameter)?,
+                    element: ElementRef(parameter),
+                })
+            })
+            .collect()
+    }
+
+    pub(crate) fn lambda_parameter_bindings(
+        &mut self,
+        unit: usize,
+        body: &Expr,
+    ) -> Option<(ScopeRef, Vec<ParameterBinding>)> {
+        let ExprKind::Body { members } = &body.kind else {
+            return None;
+        };
+        if self
+            .parameter_sites
+            .as_ref()
+            .is_none_or(|sites| !sites.current(self))
+        {
+            self.parameter_sites = Some(ParameterSites::build(self));
+        }
+        let sites = &self.parameter_sites.as_ref()?.sites;
+        let mut scope = None;
+        let mut names = HashSet::new();
+        let mut bindings = Vec::new();
+        for member in members {
+            let MemberKind::Usage(usage) = &member.kind else {
+                continue;
+            };
+            if !matches!(
+                usage.prefix.direction,
+                Some(FeatureDirection::In | FeatureDirection::InOut)
+            ) {
+                continue;
+            }
+            let name = &usage.declaration.id.name.as_ref()?.value;
+            if !names.insert(name.as_str()) {
+                return None;
+            }
+            let (element, declaration_scope) = sites
+                .get(&(unit, member.span.start, member.span.end))?
+                .as_ref()?;
+            if self.elements[*element]
+                .props
+                .get("declaredName")
+                .and_then(|value| value.as_str())
+                != Some(name.as_str())
+                || scope.is_some_and(|scope| scope != *declaration_scope)
+            {
+                return None;
+            }
+            scope = Some(*declaration_scope);
+            bindings.push(ParameterBinding {
+                name: name.clone(),
+                element: ElementRef(*element),
+            });
+        }
+        Some((ScopeRef(scope?), bindings))
+    }
+}
+
+impl ResolvedModel {
+    /// A context-free evaluation scope for an authored value. Root and other
+    /// non-Type-owned values use their declaration's lexical scope. Type-owned
+    /// values require no proof only when the receiver is absent or identical
+    /// to that scope. Other receivers return `None`; use
+    /// [`Self::value_scope_decision_with_steps`] for a checked contextual read.
+    /// `None` also denotes an absent authored expression and must not be treated
+    /// as permission to substitute a caller scope.
+    pub fn value_evaluation_scope(
+        &self,
+        element: ElementRef,
+        receiver: Option<ScopeRef>,
+    ) -> Option<ScopeRef> {
+        self.b
+            .value_evaluation_scope(element.0, receiver.map(|scope| scope.0))
+            .map(ScopeRef)
+    }
+
+    /// Resolve a reference for runtime parameter admission using its declaration
+    /// lexical scope and current source context (see [`Self::with_source`]).
+    /// The lexical scope is independent of any receiver used to evaluate a value.
+    pub fn reference_identity(
+        &mut self,
+        lexical_scope: ScopeRef,
+        name: &QualifiedName,
+    ) -> ReferenceIdentity {
+        self.b.reference_identity(lexical_scope.0, name)
+    }
+
+    /// The input parameters an invocation of `calculation` binds its
+    /// arguments to, in order: the `in` and `inout` parameters of
+    /// [`Self::callable_parameters`], each with the name a named argument
+    /// binds it by. With `calc def Diff { in a; in b; }` and
+    /// `calc def D :> Diff { in x; }`, `D` binds `(x, b)`: `x` takes over `a`
+    /// by position. Returns `None` when [`Self::callable_parameters`] does,
+    /// or when two inputs answer to the same name.
+    pub fn calc_parameter_bindings(
+        &mut self,
+        calculation: ElementRef,
+    ) -> Option<Vec<ParameterBinding>> {
+        self.b.calc_parameter_bindings(calculation.0)
+    }
+
+    /// A callable's parameters, its result aside, as an invocation sees them:
+    /// those it owns, in declaration order, then those of each general it is
+    /// written to specialize, type, subset or redefine, in the order the
+    /// generals are written, then those of the implied library bases of its
+    /// kind, but for any its own features redefine — explicitly, by
+    /// position, or as a requirement's or case's subject — each with the
+    /// name an argument binds it by (see
+    /// [`ParameterBinding::name`]). KerML pairs every owned parameter of a
+    /// behavior or step with each general's parameter at the same position
+    /// — the general's own, then those it inherits after them — even one
+    /// that also redefines a parameter explicitly:
+    /// `in :>> b;` in a specialization of `Diff { in a; in b; }` redefines
+    /// both `a` and `b`.
+    ///
+    /// Read off the callable's heritage alone, without the model-wide
+    /// positional plan, so the first call stays cheap. They agree with the
+    /// parameters among [`Self::effective_features`] with implied heritage
+    /// (a requirement without a subject of its own inherits its library
+    /// base's), except that this pairs a general reached through a feature
+    /// chain by position, as that view does not. `None` for cyclic or
+    /// overly deep heritage.
+    pub fn callable_parameters(&mut self, callee: ElementRef) -> Option<Vec<ParameterBinding>> {
+        self.b.named_signature(callee.0, &mut true)
+    }
+
+    /// The features `feature` redefines by position: for an end, each direct
+    /// general's end at the same position; for a parameter of a behavior or
+    /// step, each behavior or step general's parameter at the same position,
+    /// the general's own then those it inherits after them (an invocation's
+    /// argument naming what it redefines excepted);
+    /// for a result, each function or expression general's result; for a
+    /// requirement's or case's subject, each same-family general's subject.
+    /// Read off the owner's heritage alone (written generals, then the
+    /// implied library bases), without the model-wide positional plan: it is
+    /// what the redefining feature's body inherits members through, and what
+    /// the implied `Redefinition` relationships of [`Self::implied_relationships`]
+    /// materialize. Empty for a feature of no such role, or whose owner is
+    /// unknown.
+    pub fn positional_redefinition_targets(&mut self, feature: ElementRef) -> Vec<ElementRef> {
+        // The element's owner, not its scope's: the ends a `connect` clause
+        // declares resolve their targets from the enclosing scope.
+        let Some(owner) = self.owner(feature) else {
+            return Vec::new();
+        };
+        self.b
+            .positional_redefinition_targets(feature.0, owner.0)
+            .into_iter()
+            .map(ElementRef)
+            .collect()
+    }
+
+    /// Recover a lambda's input declaration identities and lexical scope from
+    /// the source owner's unit and the input members' exact declaration spans.
+    /// Returns `None` for absent or ambiguous declarations, or when no input
+    /// declaration establishes a body scope. This does not validate the body.
+    pub fn lambda_parameter_bindings(
+        &mut self,
+        source_owner: ElementRef,
+        body: &Expr,
+    ) -> Option<(ScopeRef, Vec<ParameterBinding>)> {
+        let unit = self.b.unit_of_elem(source_owner.0);
+        self.b.lambda_parameter_bindings(unit, body)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+    use sysmlv2_syntax::ast::ArrowArgs;
+
+    fn lambda_body(expression: &Expr) -> &Expr {
+        match &expression.kind {
+            ExprKind::Arrow {
+                args: ArrowArgs::Body(body),
+                ..
+            }
+            | ExprKind::Collect { body, .. } => body,
+            _ => panic!("expected a collection lambda"),
+        }
+    }
+
+    fn names(bindings: &[ParameterBinding]) -> Vec<&str> {
+        bindings.iter().map(|p| p.name.as_str()).collect()
+    }
+
+    #[test]
+    fn calculation_bindings_take_own_inputs_then_inherited_ones() {
+        let mut model = Model::new();
+        model.add_source(
+            "parameters.sysml",
+            "calc def Base { in x; inout y; return z; }
+             calc def Child :> Base;
+             calc def Other { in q; }
+             calc def Multiple :> Base, Other;
+             calc def Own :> Base { in local; }
+             calc def Duplicate { in x; in x; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let base = r.resolve_qualified("Base").unwrap();
+        let child = r.resolve_qualified("Child").unwrap();
+        let multiple = r.resolve_qualified("Multiple").unwrap();
+        let own = r.resolve_qualified("Own").unwrap();
+        let duplicate = r.resolve_qualified("Duplicate").unwrap();
+        let parameters = r.calc_parameter_bindings(base).unwrap();
+        assert_eq!(names(&parameters), ["x", "y"]);
+        assert_eq!(r.calc_parameter_bindings(child), Some(parameters.clone()));
+        // Each general's inputs, in the order the generals are written.
+        let both = r.calc_parameter_bindings(multiple).unwrap();
+        assert_eq!(names(&both), ["x", "y", "q"]);
+        assert_eq!(both[..2], parameters[..]);
+        assert_eq!(both[2].element, r.resolve_qualified("Other::q").unwrap());
+        // `local` takes over `x` by position; `y` is still inherited.
+        let own = r.calc_parameter_bindings(own).unwrap();
+        assert_eq!(names(&own), ["local", "y"]);
+        assert_eq!(own[1], parameters[1]);
+        assert_eq!(r.calc_parameter_bindings(duplicate), None);
+    }
+
+    /// The inputs a calculation binds are the input parameters among the
+    /// model's own view of its features, implied heritage included.
+    #[test]
+    fn calculation_bindings_agree_with_the_inherited_view() {
+        let mut model = Model::new();
+        model.add_source(
+            "signatures.sysml",
+            "package P {
+                calc def Diff { in a; in b; return r = a - b; }
+                calc def D3 :> Diff { in x; }
+                calc def D2 :> Diff { in :>> b; }
+                calc def A { in p; in q; }
+                calc def B :> A { in r; }
+                calc def C :> B { in s; in t; }
+                calc def Mixed { in a; out o; in b; }
+                calc def SubMixed :> Mixed { in x; in y; }
+                calc def Two :> A, Diff { in z; }
+                calc def SameName :> Diff { in b; }
+                attribute def Number;
+                calc def Unnamed :> Diff { in : Number; }
+                calc typed : Diff;
+                calc typedOwn : Diff { in x; }
+                part def Q { calc m : Diff; }
+                part def Q2 :> Q { calc :>> m { in y; } }
+            }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        for (name, expected) in [
+            ("Diff", &["a", "b"][..]),
+            ("D3", &["x", "b"]),
+            ("D2", &["b"]),
+            ("B", &["r", "q"]),
+            // A general's parameters are its own, then the inherited ones
+            // after them: `t` pairs with `B`'s second parameter, `q`.
+            ("C", &["s", "t"]),
+            // An output holds its position too.
+            ("SubMixed", &["x", "y", "b"]),
+            ("Two", &["z", "q", "b"]),
+            // A reused name hides nothing: `SameName::b` redefines `a` by
+            // position and `Diff::b` is still inherited — two inputs of one
+            // name, which no invocation can bind by name.
+            ("SameName", &["b", "b"]),
+            ("Unnamed", &["a", "b"]),
+            ("typed", &["a", "b"]),
+            ("typedOwn", &["x", "b"]),
+            ("Q::m", &["a", "b"]),
+            ("Q2::m", &["y", "b"]),
+        ] {
+            let callee = r.resolve_qualified(&format!("P::{name}")).unwrap();
+            let inherited: Vec<ElementRef> = r
+                .effective_features(callee, true)
+                .into_iter()
+                .filter(|&f| {
+                    r.is_parameter(f)
+                        && r.owning_membership_type(f) != Some("ReturnParameterMembership")
+                })
+                .collect();
+            let parameters = r.callable_parameters(callee).unwrap();
+            assert_eq!(
+                parameters.iter().map(|p| p.element).collect::<Vec<_>>(),
+                inherited,
+                "{name}"
+            );
+            let Some(bindings) = r.calc_parameter_bindings(callee) else {
+                assert_eq!(name, "SameName");
+                assert_eq!(names(&parameters), expected, "{name}");
+                continue;
+            };
+            assert!(bindings.iter().all(|b| parameters.contains(b)), "{name}");
+            assert_eq!(names(&bindings), expected, "{name}");
+            let inputs: Vec<ElementRef> = inherited
+                .into_iter()
+                .filter(|&f| matches!(r.declared_direction(f), Some("in" | "inout")))
+                .collect();
+            assert_eq!(
+                bindings.iter().map(|p| p.element).collect::<Vec<_>>(),
+                inputs,
+                "{name}"
+            );
+        }
+    }
+
+    /// A requirement without a subject of its own takes its library base's,
+    /// and a performed action the parameters of what it performs: the
+    /// implied bases and reference subsettings its inherited members read.
+    #[test]
+    fn implied_bases_and_reference_subsettings_supply_parameters() {
+        let mut model = Model::new();
+        model.add_library_source(
+            "Requirements.sysml",
+            "standard library package Requirements {
+                 abstract requirement def RequirementCheck { subject subj; }
+             }",
+        );
+        model.add_source(
+            "parameters.sysml",
+            "package P {
+                 requirement def Bare;
+                 requirement def Own { subject vehicle; }
+                 action def Run { in speed; }
+                 action run : Run;
+                 action trip { perform run; }
+             }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        for (name, expected) in [
+            ("P::Bare", &["subj"][..]),
+            ("P::Own", &["vehicle"]),
+            ("P::trip::run", &["speed"]),
+        ] {
+            let callee = r.resolve_qualified(name).unwrap();
+            let parameters = r.callable_parameters(callee).unwrap();
+            assert_eq!(names(&parameters), expected, "{name}");
+            let inherited: Vec<ElementRef> = r
+                .effective_features(callee, true)
+                .into_iter()
+                .filter(|&f| r.is_parameter(f))
+                .collect();
+            assert_eq!(
+                parameters.iter().map(|p| p.element).collect::<Vec<_>>(),
+                inherited,
+                "{name}"
+            );
+        }
+    }
+
+    /// KerML's `checkFeatureParameterRedefinition` exempts only an
+    /// invocation's argument that names what it redefines. A calculation's
+    /// parameter that redefines one explicitly still takes over the general's
+    /// parameter at its own position, so it stands for both.
+    #[test]
+    fn an_explicit_redefinition_does_not_release_the_position() {
+        let mut model = Model::new();
+        model.add_source(
+            "positions.sysml",
+            "calc def KineticEnergy { in m; in v; return ke = m * v * v / 2; }
+             calc def ByVelocity :> KineticEnergy { in :>> v; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let callee = r.resolve_qualified("ByVelocity").unwrap();
+        let parameter = r.callable_parameters(callee).unwrap();
+        assert_eq!(names(&parameter), ["v"]);
+        let parameter = parameter[0].element;
+        assert_eq!(r.owner(parameter), Some(callee));
+        let m = r.resolve_qualified("KineticEnergy::m").unwrap();
+        let v = r.resolve_qualified("KineticEnergy::v").unwrap();
+        let mut targets = r.b.semantic_redefinition_targets(parameter.0, true);
+        targets.sort_unstable();
+        assert_eq!(targets, [m.0, v.0]);
+        assert!(!r.effective_features(callee, true).contains(&m));
+        assert_eq!(names(&r.calc_parameter_bindings(callee).unwrap()), ["v"]);
+    }
+
+    /// Positions pair parameters whatever their names: a reused name hides
+    /// no inherited parameter at another position, and leaves the two
+    /// inputs without a name to tell them apart.
+    #[test]
+    fn a_reused_name_hides_no_inherited_parameter() {
+        let mut model = Model::new();
+        model.add_source(
+            "names.sysml",
+            "calc def Diff { in a; in b; return r = a - b; }
+             calc def Partial :> Diff { in b; }
+             calc def Swapped :> Diff { in b; in a; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let diff_a = r.resolve_qualified("Diff::a").unwrap();
+        let diff_b = r.resolve_qualified("Diff::b").unwrap();
+        let partial = r.resolve_qualified("Partial").unwrap();
+        let partial_b = r.resolve_qualified("Partial::b").unwrap();
+        assert_eq!(r.positional_redefinition_targets(partial_b), [diff_a]);
+        let parameters = r.callable_parameters(partial).unwrap();
+        assert_eq!(names(&parameters), ["b", "b"]);
+        assert_eq!(parameters[0].element, partial_b);
+        assert_eq!(parameters[1].element, diff_b);
+        assert_eq!(r.calc_parameter_bindings(partial), None);
+        let swapped = r.resolve_qualified("Swapped").unwrap();
+        let swapped_b = r.resolve_qualified("Swapped::b").unwrap();
+        let swapped_a = r.resolve_qualified("Swapped::a").unwrap();
+        assert_eq!(r.positional_redefinition_targets(swapped_b), [diff_a]);
+        assert_eq!(r.positional_redefinition_targets(swapped_a), [diff_b]);
+        let parameters = r.calc_parameter_bindings(swapped).unwrap();
+        assert_eq!(names(&parameters), ["b", "a"]);
+        assert_eq!(parameters[0].element, swapped_b);
+    }
+
+    /// Ends, results and subjects pair with what the general owns, else with
+    /// what it inherits.
+    #[test]
+    fn ends_results_and_subjects_pair_through_the_heritage() {
+        let mut model = Model::new();
+        model.add_source(
+            "roles.sysml",
+            "part def P1; part def P2;
+             connection def Conn { end e1 : P1; end e2 : P2; }
+             connection def Conn2 :> Conn { end f1; end f2; }
+             connection def Conn3 :> Conn2;
+             connection def Conn4 :> Conn3 { end g1; end g2; }
+             calc def C1 { in i; return r : P1; }
+             calc def C2 :> C1;
+             calc def C3 :> C2 { return s; }
+             requirement def R { subject sub : P1; }
+             requirement def R2 :> R;
+             requirement def R3 :> R2 { subject t; in x; }
+             port def Q;
+             interface def I { end port a : Q; end port b : ~Q; }
+             part def W { port p : Q; }
+             part def H { port q : ~Q; }
+             part def Sys { part w : W; part h : H; interface i : I connect w.p to h.q; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let q = |r: &mut ResolvedModel, name: &str| r.resolve_qualified(name).unwrap();
+        let (e1, e2) = (q(&mut r, "Conn::e1"), q(&mut r, "Conn::e2"));
+        let (f1, f2) = (q(&mut r, "Conn2::f1"), q(&mut r, "Conn2::f2"));
+        assert_eq!(r.positional_redefinition_targets(f1), [e1]);
+        assert_eq!(r.positional_redefinition_targets(f2), [e2]);
+        let g1 = q(&mut r, "Conn4::g1");
+        assert_eq!(r.positional_redefinition_targets(g1), [f1]);
+        let (c1_r, c3_s) = (q(&mut r, "C1::r"), q(&mut r, "C3::s"));
+        assert_eq!(r.positional_redefinition_targets(c3_s), [c1_r]);
+        let (sub, t) = (q(&mut r, "R::sub"), q(&mut r, "R3::t"));
+        assert_eq!(r.positional_redefinition_targets(t), [sub]);
+        let x = q(&mut r, "R3::x");
+        assert_eq!(r.positional_redefinition_targets(x), []);
+        // The ends a `connect` clause declares pair with the definition's.
+        let (a, b) = (q(&mut r, "I::a"), q(&mut r, "I::b"));
+        let i = q(&mut r, "Sys::i");
+        let ends: Vec<_> = r
+            .owned_members(i)
+            .into_iter()
+            .filter(|&e| {
+                r.element_properties(e)
+                    .get("isEnd")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+            })
+            .collect();
+        assert_eq!(ends.len(), 2);
+        assert_eq!(r.positional_redefinition_targets(ends[0]), [a]);
+        assert_eq!(r.positional_redefinition_targets(ends[1]), [b]);
+    }
+
+    /// An inherited parameter that another inherited one redefines is no
+    /// slot of the type inheriting both (`r` under `B1` redefines `A::p`,
+    /// which `B2` inherits), whichever general is written first; and a
+    /// parameter redefined by a qualified `:>>` is no slot either.
+    #[test]
+    fn redefined_inherited_parameters_are_no_slots() {
+        let mut model = Model::new();
+        model.add_source(
+            "slots.sysml",
+            "calc def A { in p; in q; }
+             calc def B1 :> A { in r; }
+             calc def B2 :> A;
+             calc def G :> B1, B2;
+             calc def G2 :> B2, B1;
+             calc def H :> G { in x; in y; in z; }
+             calc def H2 :> G2 { in x; in y; in z; }
+             calc def B :> A { in z :>> A::q; }
+             calc def C :> B { in m; in n; }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let q = |r: &mut ResolvedModel, name: &str| r.resolve_qualified(name).unwrap();
+        let (p, qq, rr) = (q(&mut r, "A::p"), q(&mut r, "A::q"), q(&mut r, "B1::r"));
+        for (general, first, second) in [("G", rr, qq), ("G2", qq, rr)] {
+            let general = q(&mut r, general);
+            let parameters: Vec<_> = r
+                .callable_parameters(general)
+                .unwrap()
+                .into_iter()
+                .map(|parameter| parameter.element)
+                .collect();
+            assert_eq!(parameters, [first, second]);
+            assert!(!r.effective_features(general, true).contains(&p));
+        }
+        for (specialization, first, second) in [("H", rr, qq), ("H2", qq, rr)] {
+            let x = q(&mut r, &format!("{specialization}::x"));
+            let y = q(&mut r, &format!("{specialization}::y"));
+            let z = q(&mut r, &format!("{specialization}::z"));
+            assert_eq!(r.positional_redefinition_targets(x), [first]);
+            assert_eq!(r.positional_redefinition_targets(y), [second]);
+            assert_eq!(r.positional_redefinition_targets(z), []);
+        }
+        let z = q(&mut r, "B::z");
+        let m = q(&mut r, "C::m");
+        let n = q(&mut r, "C::n");
+        assert_eq!(r.positional_redefinition_targets(m), [z]);
+        assert_eq!(r.positional_redefinition_targets(n), []);
+        let c = q(&mut r, "C");
+        assert_eq!(names(&r.callable_parameters(c).unwrap()), ["m", "n"]);
+    }
+
+    #[test]
+    fn lambda_sites_are_unit_scoped_and_ambiguous_sites_are_rejected() {
+        let mut model = Model::new();
+        for package in ["A", "B"] {
+            model.add_source(
+                format!("{package}.sysml"),
+                &format!("package {package} {{ attribute value = (1,2)->collect {{ in p; p }}; calc def Shadow {{ in p; }} }}"),
+            );
+        }
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A::value").unwrap();
+        let b = r.resolve_qualified("B::value").unwrap();
+        let (_, expression) = r.value_expr(a).unwrap();
+        let body = lambda_body(&expression);
+        let (scope_a, bindings_a) = r.lambda_parameter_bindings(a, body).unwrap();
+        let (scope_b, bindings_b) = r.lambda_parameter_bindings(b, body).unwrap();
+        assert_eq!(bindings_a[0].name, "p");
+        assert_ne!(bindings_a[0].element, bindings_b[0].element);
+        assert_ne!(scope_a, scope_b);
+        assert_eq!(r.b.scopes[scope_a.0].owner, None);
+        // A retained prefix index with an old length stamp must rebuild.
+        let index = r.b.parameter_sites.as_mut().unwrap();
+        index.elements_len = 0;
+        index.sites.clear();
+        assert_eq!(
+            r.lambda_parameter_bindings(a, body),
+            Some((scope_a, bindings_a.clone()))
+        );
+        // Two declarations claimed at one source site cannot select arbitrarily.
+        let span = *r.b.member_spans.get(&bindings_a[0].element.0).unwrap();
+        let duplicate = r.resolve_qualified("A::Shadow::p").unwrap();
+        r.b.member_spans.insert(duplicate.0, span);
+        r.b.parameter_sites = None;
+        assert!(r.lambda_parameter_bindings(a, body).is_none());
+        assert_eq!(r.b.owner_scope_of(bindings_b[0].element.0), Some(scope_b.0));
+    }
+
+    #[test]
+    fn populated_prepared_parameter_index_rebuilds_after_user_append() {
+        use crate::prepared::PreparedLibrary;
+        use std::sync::Arc;
+
+        let mut library_model = Model::new();
+        library_model.add_library_source(
+            "library.sysml",
+            "package L { attribute value = (1,2)->collect { in p; p }; }",
+        );
+        let prepared = PreparedLibrary::build(&library_model).unwrap();
+        let decoded = PreparedLibrary::from_bytes(&prepared.to_bytes(19).unwrap(), 19).unwrap();
+        // In-memory preparation retains already-parsed syntax; decoding starts
+        // cold. Neither path should hydrate another unit for parameter lookup.
+        for (mode, mut prepared) in [prepared, decoded].into_iter().enumerate() {
+            let library_owner = prepared
+                .builder
+                .resolve(0, &super::super::lib_qn("L::value"), 0)
+                .unwrap();
+            let expression = prepared
+                .builder
+                .values
+                .get(&library_owner)
+                .unwrap()
+                .1
+                .clone();
+            let (_, original) = prepared
+                .builder
+                .lambda_parameter_bindings(0, lambda_body(&expression))
+                .unwrap();
+            let library_elements = prepared.builder.elements.len();
+            assert_eq!(
+                prepared
+                    .builder
+                    .parameter_sites
+                    .as_ref()
+                    .unwrap()
+                    .elements_len,
+                library_elements
+            );
+            let prepared = Arc::new(prepared);
+            let mut model = Model::new();
+            Arc::clone(&prepared).install(&mut model).unwrap();
+            let initially_loaded = model.loaded_library_unit_count();
+            assert_eq!(initially_loaded, usize::from(mode == 0));
+            model.add_source(
+                "user.sysml",
+                "package U { attribute value = (3,4)->collect { in p; p }; }",
+            );
+            let mut r = ResolvedModel::build(&model);
+            assert!(r.b.elements.shares_prefix(&prepared.builder.elements));
+            assert!(r.b.elements.len() > library_elements);
+            let user_owner = r.resolve_qualified("U::value").unwrap();
+            let (_, expression) = r.value_expr(user_owner).unwrap();
+            let (_, user) = r
+                .lambda_parameter_bindings(user_owner, lambda_body(&expression))
+                .unwrap();
+            assert_eq!(user.len(), 1);
+            assert_ne!(user[0].element, original[0].element);
+            assert_eq!(r.b.unit_of_elem(user[0].element.0), 1);
+            assert_eq!(
+                r.b.parameter_sites.as_ref().unwrap().elements_len,
+                r.b.elements.len()
+            );
+            assert_eq!(
+                prepared
+                    .builder
+                    .parameter_sites
+                    .as_ref()
+                    .unwrap()
+                    .elements_len,
+                library_elements
+            );
+            assert_eq!(model.loaded_library_unit_count(), initially_loaded);
+        }
+    }
+
+    #[test]
+    fn exact_missing_reference_is_distinct_from_lexical_resolution() {
+        const ID: &str = "77777777-7777-4777-8777-777777777777";
+        let mut model = Model::new();
+        model.add_source(
+            "a.sysml",
+            &format!("attribute '{ID}' = 1; attribute value = '{ID}';"),
+        );
+        let mut r = ResolvedModel::build(&model);
+        let owner = r.resolve_qualified("value").unwrap();
+        let ordinary = r.resolve_qualified(&format!("'{ID}'")).unwrap();
+        let (scope, expression) = r.value_expr(owner).unwrap();
+        let ExprKind::Ref(name) = expression.kind else {
+            panic!("expected reference");
+        };
+        assert_eq!(
+            r.reference_identity(scope, &name),
+            ReferenceIdentity {
+                target: Some(ordinary),
+                identity_bound: false
+            }
+        );
+        let id = ID.parse().unwrap();
+        let span = name.segments[0].span;
+        r.b.id_spelled_targets
+            .insert((0, span.start, span.end), (id, id));
+        assert_eq!(
+            r.with_source(owner, |r| r.reference_identity(scope, &name)),
+            ReferenceIdentity {
+                target: None,
+                identity_bound: true
+            }
+        );
+    }
+
+    #[test]
+    fn signature_cache_requires_ready_recorded_heritage() {
+        let mut model = Model::new();
+        model.add_source(
+            "signatures.sysml",
+            "calc def Base { in p; } calc def Child :> Base;
+             calc def Missing :> absent;
+             calc def Duplicate { in p; in p; } calc def Empty;",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let base = r.resolve_qualified("Base").unwrap();
+        let child = r.resolve_qualified("Child").unwrap();
+        let missing = r.resolve_qualified("Missing").unwrap();
+        let duplicate = r.resolve_qualified("Duplicate").unwrap();
+        let empty = r.resolve_qualified("Empty").unwrap();
+        r.b.parameter_signatures = None;
+        r.b.semantic_ready = false;
+        let expected = r.calc_parameter_bindings(base).unwrap();
+        assert!(r.b.parameter_signatures.is_none());
+        r.b.semantic_ready = true;
+        assert_eq!(r.calc_parameter_bindings(child), Some(expected.clone()));
+        assert_eq!(r.calc_parameter_bindings(child), Some(expected));
+        assert_eq!(r.calc_parameter_bindings(missing), Some(Vec::new()));
+        assert_eq!(r.calc_parameter_bindings(duplicate), None);
+        assert_eq!(r.calc_parameter_bindings(empty), Some(Vec::new()));
+        let cache = r.b.parameter_signatures.as_ref().unwrap();
+        assert!(cache.signatures.contains_key(&child.0));
+        assert!(!cache.signatures.contains_key(&missing.0));
+        assert_eq!(cache.signatures.get(&duplicate.0), Some(&None));
+        assert_eq!(cache.signatures.get(&empty.0), Some(&Some(Vec::new())));
+        r.b.reset_lookup_caches();
+        assert!(r.b.parameter_signatures.is_none());
+    }
+
+    #[test]
+    fn signature_cache_does_not_survive_identity_rebinding() {
+        const ID: &str = "88888888-8888-4888-8888-888888888888";
+        let mut model = Model::new();
+        model.add_source(
+            "identity.sysml",
+            &format!(
+                "calc def Actual {{ in actual; }} calc def '{ID}' {{ in ordinary; }}
+                 calc def Child :> '{ID}';"
+            ),
+        );
+        let mut r = ResolvedModel::build(&model);
+        let actual = r.resolve_qualified("Actual").unwrap();
+        let ordinary = r.resolve_qualified(&format!("'{ID}'")).unwrap();
+        let child = r.resolve_qualified("Child").unwrap();
+        let sites = r.references_to(ordinary);
+        assert_eq!(sites.len(), 1);
+        let mut hints = HashMap::from([(
+            (r.element_id(sites[0].owner), sites[0].kind.clone()),
+            ID.parse().unwrap(),
+        )]);
+        assert_eq!(
+            r.calc_parameter_bindings(child).unwrap()[0].name,
+            "ordinary"
+        );
+        assert!(
+            r.b.parameter_signatures
+                .as_ref()
+                .unwrap()
+                .signatures
+                .contains_key(&child.0)
+        );
+        r.override_ids(&HashMap::from([(
+            r.element_id(actual),
+            ID.parse().unwrap(),
+        )]));
+        // Rewarm after remapping so the binding replay itself must invalidate.
+        assert_eq!(
+            r.calc_parameter_bindings(child).unwrap()[0].name,
+            "ordinary"
+        );
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        let rebound = r.calc_parameter_bindings(child).unwrap();
+        assert_eq!(rebound[0].name, "actual");
+        assert_eq!(
+            rebound[0].element,
+            r.resolve_qualified("Actual::actual").unwrap()
+        );
+        assert_eq!(r.calc_parameter_bindings(child), Some(rebound));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/positional.rs b/crates/sysmlv2-model/src/json/positional.rs
new file mode 100644
index 0000000..3ac2c31
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/positional.rs
@@ -0,0 +1,2296 @@
+//! Rule-required positional redefinitions, shared by inheritance and the
+//! materialized relationship view. This table never changes compact storage.
+
+#[cfg(test)]
+use super::membership_projection::{reset_scratch_map, reset_scratch_set};
+use super::{
+    Builder,
+    membership_projection::{
+        Membership as PositionalMembership, MembershipFacts, Node, Reachability, Reduction, charge,
+    },
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone, Default)]
+pub(super) struct PositionalRedefinitions {
+    pub targets: HashMap<usize, Vec<usize>>,
+    pub incomplete: HashSet<usize>,
+}
+
+/// Raw stored-row inputs shared only by the static/dynamic planning transaction.
+/// Imports and candidate bases are gathered anew on each pass. Reduction reuse
+/// requires equality of every consumed input; otherwise it is recomputed. Row
+/// mutations refuse reuse instead of relabeling an older snapshot.
+#[derive(Default)]
+pub(super) struct PositionalWorkspace {
+    rows: Option<crate::layered::Revision>,
+    explicit: usize,
+    one_shot: bool,
+    roots: Option<Vec<usize>>,
+    ids: Option<HashSet<uuid::Uuid>>,
+    owned: HashMap<usize, (Vec<usize>, Option<Vec<PositionalMembership>>)>,
+    unresolved: HashMap<usize, bool>,
+    reduction: Option<CompleteReduction>,
+}
+/// Recorded bootstrap edges indexed only for one planner invocation. These
+/// vectors can change without a stored-row revision, so this proof input must
+/// never be cached on Builder, StoredStructure, or the cross-pass workspace.
+#[derive(Default)]
+struct RecordedRedefinitions {
+    targets: HashMap<usize, HashSet<usize>>,
+    incomplete: HashSet<usize>,
+}
+impl RecordedRedefinitions {
+    fn build(b: &Builder, steps: &mut usize) -> Option<Self> {
+        charge(&mut Some(steps), b.spec_targets.len())?;
+        let mut index = Self::default();
+        for (i, &(source, kind, _, _)) in b.spec_targets.iter().enumerate() {
+            if kind != "Redefinition" {
+                continue;
+            }
+            if let Some(target) = b.spec_resolved.get(i).copied().flatten() {
+                index.targets.entry(source).or_default().insert(target);
+            } else {
+                index.incomplete.insert(source);
+            }
+        }
+        Some(index)
+    }
+
+    fn sources_match(
+        &self,
+        actual: &HashMap<usize, Vec<usize>>,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        for (source, targets) in actual {
+            charge(
+                &mut Some(&mut *steps),
+                targets.len().saturating_mul(2).saturating_add(1),
+            )?;
+            if self.incomplete.contains(source) {
+                return Some(false);
+            }
+            let current: HashSet<_> = targets.iter().copied().collect();
+            if self
+                .targets
+                .get(source)
+                .map_or(!current.is_empty(), |expected| &current != expected)
+            {
+                return Some(false);
+            }
+        }
+        Some(true)
+    }
+}
+
+#[derive(Default)]
+struct ImportProof {
+    recorded: Option<RecordedRedefinitions>,
+    // Domain evidence only, local to this immutable planning invocation.
+    role_domains: HashSet<usize>,
+}
+struct ImportSourceContext<'a> {
+    owner: usize,
+    bases: &'a HashMap<usize, Vec<usize>>,
+    incomplete: &'a HashSet<usize>,
+    ordinary_only: bool,
+    allow_prerequisites: bool,
+}
+
+struct CompleteReduction {
+    order: Vec<usize>,
+    nodes: HashMap<usize, Node>,
+    prerequisites: HashMap<usize, Vec<usize>>,
+    incomplete: HashSet<usize>,
+    redefinitions: HashMap<usize, Vec<usize>>,
+    result: PositionalRedefinitions,
+}
+fn charge_map_vectors(
+    map: &HashMap<usize, Vec<usize>>,
+    steps: &mut Option<&mut usize>,
+) -> Option<()> {
+    charge(steps, map.capacity())?;
+    for values in map.values() {
+        charge(steps, values.len())?;
+    }
+    Some(())
+}
+fn charge_plan(plan: &PositionalRedefinitions, steps: &mut Option<&mut usize>) -> Option<()> {
+    charge(steps, plan.incomplete.capacity())?;
+    charge_map_vectors(&plan.targets, steps)
+}
+impl CompleteReduction {
+    fn charge_inputs(&self, steps: &mut Option<&mut usize>) -> Option<()> {
+        charge(
+            steps,
+            self.order
+                .len()
+                .saturating_add(self.nodes.capacity())
+                .saturating_add(self.incomplete.capacity()),
+        )?;
+        for node in self.nodes.values() {
+            charge(
+                steps,
+                node.owned
+                    .len()
+                    .saturating_add(node.owned_memberships.len())
+                    .saturating_add(node.bases.len())
+                    .saturating_add(node.public_imports.len())
+                    .saturating_add(node.protected_imports.len()),
+            )?;
+        }
+        charge_map_vectors(&self.prerequisites, steps)?;
+        charge_map_vectors(&self.redefinitions, steps)
+    }
+}
+impl PositionalWorkspace {
+    pub(super) fn one_shot() -> Self {
+        Self {
+            one_shot: true,
+            ..Self::default()
+        }
+    }
+    fn align(&mut self, b: &mut Builder) -> Option<()> {
+        if let Some(rows) = &self.rows {
+            if self.explicit != b.explicit_len()
+                || !b
+                    .elements
+                    .revision()
+                    .is_some_and(|current| rows.same_as(current))
+            {
+                return None;
+            }
+        } else {
+            self.rows = Some(b.elements.observe_revision());
+            self.explicit = b.explicit_len();
+        }
+        Some(())
+    }
+}
+
+struct CompatibilityMembershipFacts<'a>(&'a Builder);
+impl MembershipFacts for CompatibilityMembershipFacts<'_> {
+    fn is_feature(&self, member: usize) -> bool {
+        conforms(self.0.elements[member].ty, "Feature")
+    }
+    fn is_feature_membership(&self, relationship: usize) -> bool {
+        conforms(self.0.elements[relationship].ty, "FeatureMembership")
+    }
+    fn is_protected(&self, relationship: usize) -> bool {
+        self.0.elements[relationship]
+            .props
+            .get("visibility")
+            .and_then(|value| value.as_str())
+            == Some("protected")
+    }
+}
+
+impl Builder {
+    pub(super) fn ensure_positional_redefinitions(&mut self) {
+        if !self.positional_planning {
+            self.refresh_supported_chain_evidence(None)
+                .expect("unbounded chain validation");
+        }
+        if !self.semantic_ready
+            || self.positional_redefinitions.is_some()
+            || self.positional_planning
+        {
+            return;
+        }
+        // Base resolution can inspect inheritance while resolving semantic
+        // metadata. Never recursively start another planner from that lookup.
+        self.positional_redefinitions = Some(Default::default());
+        let used = self.used_imports.clone();
+        let walks = std::mem::take(&mut self.query_imports);
+        let previous_static = std::mem::replace(&mut self.static_planning, true);
+        self.positional_planning = true;
+        let plan = self.plan_positional_redefinitions();
+        self.positional_planning = false;
+        self.static_planning = previous_static;
+        self.used_imports = used;
+        self.query_imports = walks;
+        self.inherited_cache.clear();
+        self.inherited_by_heritage.clear();
+        self.positional_redefinitions = Some(plan);
+    }
+
+    /// Prepare a complete positional table within the caller's allowance.
+    /// In-progress work is private: refusal never publishes an empty sentinel.
+    pub(super) fn ensure_positional_redefinitions_with_budget(
+        &mut self,
+        steps: &mut usize,
+    ) -> bool {
+        if charge(&mut Some(&mut *steps), 1).is_none() {
+            return false;
+        }
+        if self.positional_planning {
+            return false;
+        }
+        if self
+            .refresh_supported_chain_evidence(Some(&mut *steps))
+            .is_none()
+        {
+            return false;
+        }
+        if !self.semantic_ready || self.positional_redefinitions.is_some() {
+            return true;
+        }
+        // Precharge invalidation before planning or touching caller state.
+        if charge(
+            &mut Some(&mut *steps),
+            self.inherited_cache
+                .capacity()
+                .saturating_add(self.inherited_by_heritage.capacity()),
+        )
+        .is_none()
+        {
+            return false;
+        }
+        for key in self.inherited_by_heritage.keys() {
+            if charge(&mut Some(&mut *steps), key.0.len()).is_none() {
+                return false;
+            }
+        }
+        let previous_static = std::mem::replace(&mut self.static_planning, true);
+        self.positional_planning = true;
+        let plan = (|| {
+            let (bases, incomplete) =
+                self.positional_direct_bases_with_budget(Some(&mut *steps))?;
+            self.plan_positional_redefinitions_with_bases_and_budget(
+                &bases,
+                &incomplete,
+                Some(&mut *steps),
+            )
+        })();
+        self.positional_planning = false;
+        self.static_planning = previous_static;
+        let Some(plan) = plan else {
+            return false;
+        };
+        self.inherited_cache.clear();
+        self.inherited_by_heritage.clear();
+        self.positional_redefinitions = Some(plan);
+        true
+    }
+
+    fn plan_positional_redefinitions(&mut self) -> PositionalRedefinitions {
+        let (direct_bases, incomplete) = self.positional_direct_bases();
+        self.plan_positional_redefinitions_with_bases(&direct_bases, &incomplete)
+    }
+
+    /// Pure planning over an already admitted direct-base projection. Does not
+    /// consult or publish the retained implied or positional plan. Callers must
+    /// supply authored plus accepted static/dynamic bases in semantic order,
+    /// with unresolved providers represented in incomplete. Endpoint/carrier
+    /// admission precedes this internal seam; it is not an interchange reader.
+    pub(super) fn plan_positional_redefinitions_with_bases(
+        &mut self,
+        direct_bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+    ) -> PositionalRedefinitions {
+        self.plan_positional_redefinitions_with_bases_and_budget(direct_bases, incomplete, None)
+            .expect("unbounded positional construction cannot exhaust its budget")
+    }
+
+    /// Budgeted counterpart used before accepting mutable semantic candidates.
+    /// None discards the whole local plan; no partial targets/cache is published.
+    pub(super) fn plan_positional_redefinitions_with_bases_and_budget(
+        &mut self,
+        direct_bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: Option<&mut usize>,
+    ) -> Option<PositionalRedefinitions> {
+        self.plan_positional_redefinitions_with_workspace(
+            direct_bases,
+            incomplete,
+            steps,
+            &mut PositionalWorkspace::one_shot(),
+        )
+    }
+
+    pub(super) fn plan_positional_redefinitions_with_workspace(
+        &mut self,
+        direct_bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: Option<&mut usize>,
+        workspace: &mut PositionalWorkspace,
+    ) -> Option<PositionalRedefinitions> {
+        self.plan_positional_with_result_query(
+            direct_bases,
+            incomplete,
+            steps,
+            None,
+            None,
+            workspace,
+        )
+    }
+
+    /// Reuse the positional algorithm only when its stored selectors agree with
+    /// the caller's complete ordered Membership evidence. No plan is published.
+    pub(super) fn plan_checked_positional(
+        &mut self,
+        nodes: &HashMap<usize, Node>,
+        bases: &HashMap<usize, Vec<usize>>,
+        import_owners: &HashSet<usize>,
+        steps: &mut usize,
+    ) -> Option<PositionalRedefinitions> {
+        let mut budget = Some(steps);
+        charge(&mut budget, nodes.len())?;
+        let roots: Vec<_> = nodes.keys().copied().collect();
+        for (&owner, node) in nodes {
+            self.positional_charge_members(owner, &mut budget)?;
+            charge(&mut budget, node.owned.len() + node.owned_memberships.len())?;
+            if self.owned_member_elems(owner, true) != node.owned {
+                return None;
+            }
+            let memberships = self.positional_owned_memberships(owner, &mut budget)?;
+            if memberships.len() != node.owned_memberships.len()
+                || memberships
+                    .iter()
+                    .zip(&node.owned_memberships)
+                    .any(|(a, b)| a.relationship != b.relationship || a.member != b.member)
+            {
+                return None;
+            }
+        }
+        // The central planner must consume the exact visibility-specific import
+        // selectors proved by the checked provider. CanonicalV3 may use the same
+        // bounded Package traversal for selectors outside the legacy leaf domain.
+        if !import_owners.is_empty() {
+            let mut import_proof = ImportProof::default();
+            let mut prerequisites = HashMap::new();
+            charge(&mut budget, import_owners.len())?;
+            for &owner in import_owners {
+                let (mut public, mut protected) = self.positional_imports(
+                    owner,
+                    bases,
+                    &HashSet::new(),
+                    &mut budget,
+                    &mut import_proof,
+                    &mut prerequisites,
+                )?;
+                if let Some(required) = prerequisites.get(&owner) {
+                    charge(&mut budget, required.len())?;
+                    if required
+                        .iter()
+                        .any(|dependency| !nodes.contains_key(dependency))
+                    {
+                        return None;
+                    }
+                }
+                let node = nodes.get(&owner)?;
+                for (actual, expected) in [
+                    (&mut public, &node.public_imports),
+                    (&mut protected, &node.protected_imports),
+                ] {
+                    charge(&mut budget, actual.len().saturating_add(expected.len()))?;
+                    let mut seen = HashSet::new();
+                    actual.retain(|m| seen.insert(m.relationship));
+                    if actual != expected {
+                        return None;
+                    }
+                }
+            }
+        }
+        self.plan_positional_with_result_query(
+            bases,
+            &HashSet::new(),
+            budget,
+            Some(&roots),
+            None,
+            &mut PositionalWorkspace::one_shot(),
+        )
+    }
+
+    /// Bootstrap targets are compatibility inputs, never current-row authority.
+    /// A checked consumer must prove equality for its entire closure before
+    /// using the positional algorithm's reachability-based edge omissions.
+    pub(super) fn positional_redefinition_sources_match(
+        &self,
+        actual: &HashMap<usize, Vec<usize>>,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        let mut budget = Some(steps);
+        charge(&mut budget, self.spec_targets.len())?;
+        let mut indexed: HashMap<usize, HashSet<usize>> = HashMap::new();
+        for (i, &(owner, kind, _, _)) in self.spec_targets.iter().enumerate() {
+            if kind == "Redefinition" && actual.contains_key(&owner) {
+                let Some(target) = self.spec_resolved.get(i).copied().flatten() else {
+                    return Some(false);
+                };
+                indexed.entry(owner).or_default().insert(target);
+            }
+        }
+        for (owner, targets) in actual {
+            charge(
+                &mut budget,
+                targets.len().saturating_mul(2).saturating_add(1),
+            )?;
+            let expected = indexed.remove(owner).unwrap_or_default();
+            let current: HashSet<_> = targets.iter().copied().collect();
+            if current != expected {
+                return Some(false);
+            }
+        }
+        Some(true)
+    }
+
+    /// Detached candidate selection over caller-certified roots/bases. This
+    /// reuses the positional membership algorithm, not its possibly older cache.
+    /// Returned identities still require the caller's checked carrier/alias and
+    /// library-role certificate; this is not a whole result-family capability.
+    pub(super) fn plan_unique_result_candidates(
+        &mut self,
+        direct_bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        roots: &[usize],
+        steps: &mut usize,
+    ) -> Option<HashMap<usize, usize>> {
+        let mut candidates = HashMap::new();
+        let plan = self.plan_positional_with_result_query(
+            direct_bases,
+            incomplete,
+            Some(steps),
+            Some(roots),
+            Some(&mut candidates),
+            &mut PositionalWorkspace::one_shot(),
+        )?;
+        candidates.retain(|owner, _| !plan.incomplete.contains(owner));
+        Some(candidates)
+    }
+
+    fn plan_positional_with_result_query(
+        &mut self,
+        direct_bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        mut steps: Option<&mut usize>,
+        selected_roots: Option<&[usize]>,
+        mut result_candidates: Option<&mut HashMap<usize, usize>>,
+        workspace: &mut PositionalWorkspace,
+    ) -> Option<PositionalRedefinitions> {
+        charge(&mut steps, 1)?;
+        workspace.align(self)?;
+        // UUID lookup may lazily allocate its complete row index in the stored
+        // Membership helper. Account once before any such lookup can occur.
+        if self.id_index.is_none() || self.id_index_built_for != self.elements.len() {
+            charge(&mut steps, self.elements.len())?;
+        }
+        let mut roots = Vec::new();
+        if let Some(selected) = selected_roots {
+            charge(&mut steps, selected.len())?;
+            roots.extend_from_slice(selected);
+        } else if let Some(cached) = &workspace.roots {
+            charge(&mut steps, cached.len())?;
+            roots.extend_from_slice(cached);
+        } else {
+            for e in 0..self.explicit_len() {
+                charge(&mut steps, 1)?;
+                if !conforms(self.elements[e].ty, "Type") {
+                    continue;
+                }
+                // Root discovery needs existence, not an ordered collection.
+                // Defer sorting/allocation until the reachable Node is built.
+                let mut found = false;
+                for &rel in &self.elements[e].owned_relationships {
+                    charge(&mut steps, 1)?;
+                    if !super::is_feature_membership(self.elements[rel].ty) {
+                        continue;
+                    }
+                    for &f in &self.elements[rel].children {
+                        charge(&mut steps, 1)?;
+                        if self.positional_is_end(f) || self.is_parameter(f) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if found {
+                        break;
+                    }
+                }
+                if found {
+                    roots.push(e);
+                }
+            }
+        }
+        if !workspace.one_shot && selected_roots.is_none() && workspace.roots.is_none() {
+            charge(&mut steps, roots.len())?;
+            workspace.roots = Some(roots.clone());
+        }
+
+        let mut nodes = HashMap::new();
+        let mut import_proof = ImportProof::default();
+        let mut prerequisites = HashMap::new();
+        charge(&mut steps, roots.len())?;
+        let mut todo = roots.clone();
+        while let Some(e) = todo.pop() {
+            charge(&mut steps, 1)?;
+            if nodes.contains_key(&e) {
+                continue;
+            }
+            charge(
+                &mut steps,
+                direct_bases.get(&e).map_or(0, Vec::len).saturating_mul(2),
+            )?;
+            let bases = direct_bases.get(&e).cloned().unwrap_or_default();
+            todo.extend(bases.iter().copied());
+            let imports = self.positional_imports(
+                e,
+                direct_bases,
+                incomplete,
+                &mut steps,
+                &mut import_proof,
+                &mut prerequisites,
+            );
+            if let Some(required) = prerequisites.get(&e) {
+                charge(&mut steps, required.len())?;
+                todo.extend(required.iter().copied());
+            }
+            let (owned, owned_memberships) = if workspace.one_shot {
+                let owned_memberships = self.positional_owned_memberships(e, &mut steps);
+                charge(&mut steps, 0)?;
+                self.positional_charge_members(e, &mut steps)?;
+                (self.owned_member_elems(e, true), owned_memberships)
+            } else {
+                if let std::collections::hash_map::Entry::Vacant(entry) = workspace.owned.entry(e) {
+                    let owned_memberships = self.positional_owned_memberships(e, &mut steps);
+                    charge(&mut steps, 0)?;
+                    self.positional_charge_members(e, &mut steps)?;
+                    entry.insert((self.owned_member_elems(e, true), owned_memberships));
+                }
+                let (owned, memberships) = &workspace.owned[&e];
+                charge(
+                    &mut steps,
+                    owned
+                        .len()
+                        .saturating_add(memberships.as_ref().map_or(0, Vec::len)),
+                )?;
+                (owned.clone(), memberships.clone())
+            };
+            let memberships_complete = imports.is_some() && owned_memberships.is_some();
+            let (public_imports, protected_imports) = imports.unwrap_or_default();
+            nodes.insert(
+                e,
+                Node {
+                    owned,
+                    owned_memberships: owned_memberships.unwrap_or_default(),
+                    bases,
+                    public_imports,
+                    protected_imports,
+                    memberships_complete,
+                },
+            );
+        }
+
+        // Iterative postorder avoids a native-stack dependency on model depth.
+        // Cyclic bases have no well-founded positional ordering; do not guess.
+        let mut state = HashMap::new();
+        let mut order = Vec::new();
+        charge(&mut steps, incomplete.len())?;
+        let mut plan = PositionalRedefinitions {
+            targets: HashMap::new(),
+            incomplete: incomplete.clone(),
+        };
+        // Checked callers already hold this exact unique-identity snapshot.
+        // Reuse its index rather than re-scanning every row for each small
+        // positional closure. The fallback preserves compatibility planning
+        // when no such structural certificate exists.
+        let indexed_ids = self
+            .stored_structure
+            .as_ref()
+            .filter(|raw| raw.ids_unique && raw.is_current(self))
+            .cloned();
+        if indexed_ids.is_none() && workspace.ids.is_none() {
+            charge(&mut steps, self.explicit_len())?;
+            workspace.ids = Some(
+                self.elements
+                    .iter()
+                    .take(self.explicit_len())
+                    .map(|e| e.id)
+                    .collect(),
+            );
+        }
+        let ids = workspace.ids.as_ref();
+        for &e in nodes.keys() {
+            charge(&mut steps, 1)?;
+            let unresolved = if let Some(cached) = workspace.unresolved.get(&e) {
+                *cached
+            } else {
+                charge(&mut steps, self.elements[e].owned_relationships.len())?;
+                let value = self.elements[e].owned_relationships.iter().any(|&r| {
+                    let rel = &self.elements[r];
+                    conforms(rel.ty, "Specialization")
+                        && ![
+                            "general",
+                            "superclassifier",
+                            "type",
+                            "subsettedFeature",
+                            "redefinedFeature",
+                            "referencedFeature",
+                            "crossedFeature",
+                        ]
+                        .iter()
+                        .find_map(|key| rel.props.get(key))
+                        .and_then(|v| v.as_reference())
+                        .is_some_and(|id| {
+                            indexed_ids.as_ref().map_or_else(
+                                || ids.is_some_and(|ids| ids.contains(&id)),
+                                |raw| {
+                                    raw.element_for_uuid(self, id)
+                                        .is_some_and(|target| target < self.explicit_len())
+                                },
+                            )
+                        })
+                });
+                if !workspace.one_shot {
+                    workspace.unresolved.insert(e, value);
+                }
+                value
+            };
+            if unresolved {
+                plan.incomplete.insert(e);
+            }
+        }
+        for root in roots {
+            let mut stack = vec![(root, false)];
+            while let Some((e, exiting)) = stack.pop() {
+                charge(&mut steps, 1)?;
+                if exiting {
+                    state.insert(e, 2);
+                    order.push(e);
+                } else {
+                    match state.get(&e) {
+                        Some(1) => {
+                            plan.incomplete.insert(e);
+                            continue;
+                        }
+                        Some(2) => continue,
+                        _ => {}
+                    }
+                    state.insert(e, 1);
+                    stack.push((e, true));
+                    charge(&mut steps, nodes[&e].bases.len())?;
+                    stack.extend(nodes[&e].bases.iter().rev().map(|&b| (b, false)));
+                    if let Some(required) = prerequisites.get(&e) {
+                        charge(&mut steps, required.len())?;
+                        stack.extend(required.iter().rev().map(|&dependency| (dependency, false)));
+                    }
+                }
+            }
+        }
+
+        let mut redefinitions = HashMap::new();
+        for (i, &(e, kind, _, _)) in self.spec_targets.iter().enumerate() {
+            charge(&mut steps, 1)?;
+            if kind == "Redefinition" {
+                if let Some(target) = self.spec_resolved.get(i).copied().flatten() {
+                    redefinitions.entry(e).or_insert_with(Vec::new).push(target);
+                }
+            }
+        }
+        // The reduction reads only these fully gathered inputs and stored
+        // rows. Re-gather imports and candidate bases first, then reuse a prior
+        // complete result only when the entire consumed input is identical.
+        // This is equality memoization, not an incremental dependency guess.
+        let memoize =
+            !workspace.one_shot && selected_roots.is_none() && result_candidates.is_none();
+        if memoize {
+            if let Some(cached) = &workspace.reduction {
+                cached.charge_inputs(&mut steps)?;
+                if cached.order == order
+                    && cached.nodes == nodes
+                    && cached.prerequisites == prerequisites
+                    && cached.incomplete == plan.incomplete
+                    && cached.redefinitions == redefinitions
+                {
+                    charge_plan(&cached.result, &mut steps)?;
+
+                    return Some(cached.result.clone());
+                }
+
+                // Replacing an earlier complete result later also disposes its
+                // owned vectors; account before doing that work.
+                charge_plan(&cached.result, &mut steps)?;
+            }
+        }
+        let initial = if memoize {
+            charge(&mut steps, plan.incomplete.capacity())?;
+            charge_map_vectors(&redefinitions, &mut steps)?;
+            Some((plan.incomplete.clone(), redefinitions.clone()))
+        } else {
+            None
+        };
+        let mut effective: HashMap<usize, Vec<usize>> = HashMap::new();
+        struct Roles {
+            ends: Vec<usize>,
+            results: Vec<usize>,
+            parameters: Vec<usize>,
+        }
+        let mut roles: HashMap<usize, Roles> = HashMap::new();
+        let mut exported: HashMap<usize, Vec<PositionalMembership>> = HashMap::new();
+        let mut traversal = if selected_roots.is_some() {
+            Reachability::sparse()
+        } else {
+            charge(&mut steps, self.explicit_len())?;
+            Reachability::new(self.explicit_len())
+        };
+        let mut projection = Reduction::default();
+
+        for &e in &order {
+            charge(&mut steps, 1)?;
+            let node = &nodes[&e];
+            charge(&mut steps, node.bases.len())?;
+            // A direct import contributes to this type's non-private view,
+            // not its effective features. Unsupported visible sequences must
+            // not supply a shortened list to a child's positional matching.
+            if !node.memberships_complete {
+                plan.incomplete.insert(e);
+            }
+            if node
+                .bases
+                .iter()
+                .any(|b| plan.incomplete.contains(b) || !effective.contains_key(b))
+            {
+                plan.incomplete.insert(e);
+            }
+            if let Some(required) = prerequisites.get(&e) {
+                charge(&mut steps, required.len())?;
+                if required.iter().any(|dependency| {
+                    plan.incomplete.contains(dependency) || !effective.contains_key(dependency)
+                }) {
+                    plan.incomplete.insert(e);
+                }
+            }
+            if plan.incomplete.contains(&e) {
+                continue;
+            }
+            charge(&mut steps, node.owned.len().saturating_mul(4))?;
+            let ends: Vec<_> = node
+                .owned
+                .iter()
+                .copied()
+                .filter(|&f| self.positional_is_end(f))
+                .collect();
+            let parameters: Vec<_> = node
+                .owned
+                .iter()
+                .copied()
+                .filter(|&f| self.is_parameter(f) && !self.positional_is_result(f))
+                .collect();
+            let results: Vec<_> = node
+                .owned
+                .iter()
+                .copied()
+                .filter(|&f| self.positional_is_result(f))
+                .collect();
+            let behavior =
+                conforms(self.elements[e].ty, "Behavior") || conforms(self.elements[e].ty, "Step");
+            let function = conforms(self.elements[e].ty, "Function")
+                || conforms(self.elements[e].ty, "Expression");
+            let subject_family = |kind| {
+                if conforms(kind, "RequirementDefinition") || conforms(kind, "RequirementUsage") {
+                    Some(0)
+                } else if conforms(kind, "CaseDefinition") || conforms(kind, "CaseUsage") {
+                    Some(1)
+                } else {
+                    None
+                }
+            };
+            let is_subject = |feature: usize| {
+                self.elements[feature]
+                    .owning_relationship
+                    .is_some_and(|r| conforms(self.elements[r].ty, "SubjectMembership"))
+            };
+            let subjects: Vec<_> = parameters
+                .iter()
+                .copied()
+                .filter(|&f| is_subject(f))
+                .collect();
+            if subject_family(self.elements[e].ty).is_some() {
+                for base in &node.bases {
+                    charge(&mut steps, 1)?;
+                    charge_sort(&mut steps, effective[base].len())?;
+                }
+            }
+            let subject_bases: Vec<_> = if let Some(family) = subject_family(self.elements[e].ty) {
+                node.bases
+                    .iter()
+                    .filter(|&&base| subject_family(self.elements[base].ty) == Some(family))
+                    .map(|&base| {
+                        let mut subjects: Vec<_> = effective[&base]
+                            .iter()
+                            .copied()
+                            .filter(|&f| is_subject(f))
+                            .collect();
+                        subjects.sort_unstable();
+                        subjects.dedup();
+                        (base, subjects)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            };
+            // A requirement/case subject redefines the specialized owner's
+            // subject even when that subject is inherited. This is the SysML
+            // subject rule, not a change to KerML's positional pairing.
+            // Reject ambiguous subject views before emitting any local edges.
+            charge(&mut steps, subject_bases.len())?;
+            if subjects.len() > 1 || subject_bases.iter().any(|(_, s)| s.len() > 1) {
+                plan.incomplete.insert(e);
+                continue;
+            }
+            if let Some(&source) = subjects.first() {
+                for (_, targets) in &subject_bases {
+                    charge(&mut steps, 1)?;
+                    if let Some(&target) = targets.first() {
+                        add_edge(
+                            source,
+                            target,
+                            &mut redefinitions,
+                            &mut plan.targets,
+                            &mut traversal,
+                            &mut steps,
+                        )?;
+                    }
+                }
+            }
+            for &base in &node.bases {
+                charge(&mut steps, 1)?;
+                let base_roles = &roles[&base];
+                charge(&mut steps, ends.len().min(base_roles.ends.len()))?;
+                let base_ends = base_roles.ends.iter().copied();
+                for (&source, target) in ends.iter().zip(base_ends) {
+                    add_edge(
+                        source,
+                        target,
+                        &mut redefinitions,
+                        &mut plan.targets,
+                        &mut traversal,
+                        &mut steps,
+                    )?;
+                }
+                let base_kind = self.elements[base].ty;
+                if behavior && (conforms(base_kind, "Behavior") || conforms(base_kind, "Step")) {
+                    charge(
+                        &mut steps,
+                        parameters.len().min(base_roles.parameters.len()),
+                    )?;
+                    let base_parameters = base_roles.parameters.iter().copied();
+                    for (&source, target) in parameters.iter().zip(base_parameters) {
+                        charge(
+                            &mut steps,
+                            subject_bases
+                                .len()
+                                .saturating_add(self.elements[source].owned_relationships.len())
+                                .saturating_add(1),
+                        )?;
+                        if subjects.contains(&source)
+                            && subject_bases
+                                .iter()
+                                .any(|(owner, subjects)| *owner == base && !subjects.is_empty())
+                        {
+                            continue;
+                        }
+                        // KerML `checkFeatureParameterRedefinition` exempts
+                        // only an invocation's argument that names what it
+                        // redefines. Any other parameter takes over the
+                        // general's parameter at its position even when it
+                        // also redefines one explicitly: `in :>> b;` in a
+                        // specialization of `Diff { in a; in b; }` redefines
+                        // `a` as well as `b`, leaving one parameter.
+                        let explicit_invocation_argument =
+                            conforms(self.elements[e].ty, "InvocationExpression")
+                                && self.elements[source].owned_relationships.iter().any(|&r| {
+                                    conforms(self.elements[r].ty, "Redefinition")
+                                        && self.elements[r]
+                                            .props
+                                            .get("isImplied")
+                                            .and_then(|v| v.as_bool())
+                                            != Some(true)
+                                });
+                        if !explicit_invocation_argument {
+                            add_edge(
+                                source,
+                                target,
+                                &mut redefinitions,
+                                &mut plan.targets,
+                                &mut traversal,
+                                &mut steps,
+                            )?;
+                        }
+                    }
+                }
+                if function
+                    && (conforms(base_kind, "Function") || conforms(base_kind, "Expression"))
+                {
+                    let base_results = &base_roles.results;
+                    if results.len() > 1 || base_results.len() > 1 {
+                        plan.incomplete.insert(e);
+                    }
+                    if results.len() == 1 && base_results.len() == 1 {
+                        add_edge(
+                            results[0],
+                            base_results[0],
+                            &mut redefinitions,
+                            &mut plan.targets,
+                            &mut traversal,
+                            &mut steps,
+                        )?;
+                    }
+                }
+            }
+            let (features, surviving) = projection.reduce(
+                node,
+                &exported,
+                &redefinitions,
+                &mut traversal,
+                &CompatibilityMembershipFacts(self),
+                &mut steps,
+            )?;
+            if subject_family(self.elements[e].ty).is_some() {
+                charge_sort(&mut steps, features.len())?;
+                let mut subjects: Vec<_> = features
+                    .iter()
+                    .copied()
+                    .filter(|&f| is_subject(f))
+                    .collect();
+                subjects.sort_unstable();
+                subjects.dedup();
+                if subjects.len() > 1 {
+                    plan.incomplete.insert(e);
+                    continue;
+                }
+            }
+            let visible = projection.export(
+                node,
+                surviving,
+                &CompatibilityMembershipFacts(self),
+                &mut steps,
+            )?;
+            exported.insert(e, visible);
+            if function && !plan.incomplete.contains(&e) {
+                if let Some(candidates) = result_candidates.as_deref_mut() {
+                    charge(&mut steps, features.len())?;
+                    let mut results = features
+                        .iter()
+                        .copied()
+                        .filter(|&f| self.positional_is_result(f));
+                    if let Some(result) = results.next() {
+                        if results.next().is_none() {
+                            candidates.insert(e, result);
+                        }
+                    }
+                }
+            }
+            charge(&mut steps, features.len())?;
+            // The slots a specialization pairs by position are the type's
+            // effective ones — its own, then the inherited ones ordered
+            // after them (KerML 7.4.7.2) — for parameters as for ends.
+            let mut role_ends = Vec::new();
+            let mut role_results = Vec::new();
+            let mut role_parameters = Vec::new();
+            for &feature in &features {
+                if self.positional_is_end(feature) {
+                    role_ends.push(feature);
+                }
+                if self.positional_is_result(feature) {
+                    role_results.push(feature);
+                } else if self.is_parameter(feature) {
+                    role_parameters.push(feature);
+                }
+            }
+            roles.insert(
+                e,
+                Roles {
+                    ends: role_ends,
+                    results: role_results,
+                    parameters: role_parameters,
+                },
+            );
+            effective.insert(e, features);
+        }
+        if let Some((incomplete, redefinitions)) = initial {
+            charge_plan(&plan, &mut steps)?;
+            workspace.reduction = Some(CompleteReduction {
+                order,
+                nodes,
+                prerequisites,
+                incomplete,
+                redefinitions,
+                result: plan.clone(),
+            });
+        }
+        Some(plan)
+    }
+
+    /// Charge ownership scans before owned_member_elems allocates its result.
+    /// The unbounded legacy path avoids this additional accounting traversal.
+    fn positional_charge_members(
+        &self,
+        owner: usize,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<()> {
+        if steps.is_none() {
+            return Some(());
+        }
+        charge(steps, self.elements[owner].owned_relationships.len())?;
+        let mut children = 0usize;
+        for &relation in &self.elements[owner].owned_relationships {
+            let count = self.elements[relation].children.len();
+            charge(steps, count)?;
+            children = children.saturating_add(count);
+        }
+        // owned_member_elems sorts before deduplication. Include all stored
+        // children as a conservative upper bound on its collected members.
+        charge_sort(steps, children)
+    }
+
+    /// Keep the compatibility selector as the fast path. Canonical composition
+    /// may additionally consume the checked Namespace import algebra without
+    /// recursively asking for a Type certificate during positional planning.
+    fn positional_imports(
+        &mut self,
+        owner: usize,
+        bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: &mut Option<&mut usize>,
+        proof: &mut ImportProof,
+        prerequisites: &mut HashMap<usize, Vec<usize>>,
+    ) -> Option<(Vec<PositionalMembership>, Vec<PositionalMembership>)> {
+        let leaf = self.positional_leaf_imports(owner, bases, incomplete, steps);
+        if self.graph_format != crate::model::GraphFormat::CanonicalV3 {
+            return leaf;
+        }
+        // Existing leaf selectors need no extra work unless an imported
+        // Feature can bring a foreign positional Redefinition dependency.
+        if let Some(imports) = leaf {
+            charge(steps, imports.0.len().saturating_add(imports.1.len()))?;
+            if !imports
+                .0
+                .iter()
+                .chain(&imports.1)
+                .any(|m| conforms(self.elements[m.member].ty, "Feature"))
+            {
+                return Some(imports);
+            }
+            let mut local_steps = 0;
+            let steps = steps.as_deref_mut().unwrap_or(&mut local_steps);
+            let raw = super::structural_index::StoredStructure::for_query(self, steps)?;
+            let required = self.positional_import_source_dependencies(
+                &raw,
+                &imports,
+                ImportSourceContext {
+                    owner,
+                    bases,
+                    incomplete,
+                    ordinary_only: false,
+                    allow_prerequisites: true,
+                },
+                steps,
+                proof,
+            )?;
+            if !required.is_empty() {
+                prerequisites.insert(owner, required);
+            }
+            return Some(imports);
+        }
+        // Even an otherwise unbounded publication must not make the checked
+        // import traversal unbounded. Bounded callers retain their allowance.
+        if self
+            .elem_scope
+            .get(&owner)
+            .is_some_and(|&s| !self.scopes[s].filters.is_empty())
+        {
+            return None;
+        }
+        let mut local_steps = 0;
+        let steps = steps.as_deref_mut().unwrap_or(&mut local_steps);
+        let raw = super::structural_index::StoredStructure::for_query(self, steps)?;
+        if !raw.ids_unique || raw.annotations_incomplete || self.metadata_associations_incomplete {
+            return None;
+        }
+        // The checked Type caller establishes these domains before asking for
+        // selectors; the publication planner must establish them independently.
+        if !raw.import_domains(self, steps)?.owner_complete(owner)
+            || !raw.membership_domains(self, steps)?.owner_complete(owner)
+            || raw.metadata_annotation_targets.contains(&owner)
+            || self.metadata_of.get(&owner).is_some_and(|v| !v.is_empty())
+        {
+            return None;
+        }
+        let relationships = super::semantic_ownership::owned_relationships(self, owner)?;
+        charge(&mut Some(&mut *steps), relationships.len())?;
+        if relationships
+            .iter()
+            .any(|rel| conforms(self.elements[rel].ty, "ElementFilterMembership"))
+        {
+            return None;
+        }
+        let imports =
+            super::operations::namespaces::imports::type_imports(self, &raw, owner, &[], steps)
+                .ok()?;
+        let required = self.positional_import_source_dependencies(
+            &raw,
+            &imports,
+            ImportSourceContext {
+                owner,
+                bases,
+                incomplete,
+                ordinary_only: true,
+                allow_prerequisites: true,
+            },
+            steps,
+            proof,
+        )?;
+        if !required.is_empty() {
+            prerequisites.insert(owner, required);
+        }
+        Some(imports)
+    }
+
+    /// Prove imported Redefinition sources and their planning dependencies.
+    /// Existing ancestry remains sufficient. Foreign positional roles need a
+    /// complete ordinary owner domain, never an inheritance contribution.
+    /// Authored role sources must target strict actual ancestors; cycles and
+    /// arbitrary cross-owner positional dependencies remain qualified.
+    fn positional_import_source_dependencies(
+        &mut self,
+        raw: &super::structural_index::StoredStructure,
+        imports: &(Vec<PositionalMembership>, Vec<PositionalMembership>),
+        context: ImportSourceContext<'_>,
+        steps: &mut usize,
+        proof: &mut ImportProof,
+    ) -> Option<Vec<usize>> {
+        if !raw.ids_unique || raw.annotations_incomplete || self.metadata_associations_incomplete {
+            return None;
+        }
+        let mut budget = Some(steps);
+        charge(&mut budget, imports.0.len().saturating_add(imports.1.len()))?;
+        let mut todo: Vec<_> = imports
+            .0
+            .iter()
+            .chain(&imports.1)
+            .filter_map(|m| conforms(self.elements[m.member].ty, "Feature").then_some(m.member))
+            .collect();
+        if todo.is_empty() {
+            return Some(Vec::new());
+        }
+        charge(&mut budget, todo.len())?;
+        let roots = todo.clone();
+        let steps = budget?;
+        let inverse = raw.typing(self, steps)?;
+        if inverse.sources_incomplete {
+            return None;
+        }
+        let domains = raw.membership_domains(self, steps)?;
+        let mut seen = HashSet::new();
+        let mut dependency = Reachability::sparse();
+        let mut owners = HashMap::new();
+        let mut authored = HashMap::new();
+        let mut redefinitions = HashMap::new();
+        let mut roles = HashSet::new();
+        let mut external_roles = HashSet::new();
+        let mut required = Vec::new();
+        while let Some(feature) = todo.pop() {
+            charge(&mut Some(&mut *steps), 1)?;
+            if !seen.insert(feature) {
+                continue;
+            }
+            let row = self.elements.get(feature)?;
+            if (context.ordinary_only && row.ty != "Feature")
+                || row
+                    .props
+                    .get("isEnd")
+                    .is_some_and(|v| v.as_bool().is_none())
+                || row.props.get("direction").is_some_and(|v| {
+                    !v.is_null() && !matches!(v.as_str(), Some("in" | "out" | "inout"))
+                })
+                || raw.bad_bases.contains(&feature)
+                || raw.metadata_annotation_targets.contains(&feature)
+                || self
+                    .metadata_of
+                    .get(&feature)
+                    .is_some_and(|v| !v.is_empty())
+            {
+                return None;
+            }
+            // An absent direction does not make a Return/Subject/Parameter
+            // membership nonpositional. Admit only these exact ordinary kinds.
+            let membership = row.owning_relationship?;
+            let kind = self.elements[membership].ty;
+            if kind == "EndFeatureMembership" && !self.positional_is_end(feature) {
+                return None;
+            }
+            if if context.ordinary_only {
+                !matches!(
+                    kind,
+                    "FeatureMembership"
+                        | "EndFeatureMembership"
+                        | "ParameterMembership"
+                        | "ReturnParameterMembership"
+                        | "OwningMembership"
+                )
+            } else {
+                kind != "OwningMembership" && !conforms(kind, "FeatureMembership")
+            } {
+                return None;
+            }
+            let owner = super::semantic_ownership::checked_relationship_carrier(
+                self, raw, membership, steps,
+            )??;
+            if !domains.owner_complete(owner)
+                || raw.metadata_annotation_targets.contains(&owner)
+                || self.metadata_of.get(&owner).is_some_and(|v| !v.is_empty())
+                || super::membership_evidence::member(self, raw, owner, membership, steps)
+                    != Some(feature)
+            {
+                return None;
+            }
+            owners.insert(feature, owner);
+            let positional = self.positional_is_end(feature) || self.is_parameter(feature);
+            if positional {
+                roles.insert(feature);
+                let external = !dependency.reaches_budget(
+                    context.owner,
+                    owner,
+                    context.bases,
+                    &mut Some(&mut *steps),
+                )?;
+                if external || context.ordinary_only || !context.allow_prerequisites {
+                    let ordinary_end = row.ty == "Feature"
+                        && self.positional_is_end(feature)
+                        && !self.is_parameter(feature)
+                        && row.props.get("direction").is_none_or(|v| v.is_null())
+                        && matches!(kind, "FeatureMembership" | "EndFeatureMembership")
+                        && self.elements[owner].ty == "Class";
+                    let ordinary_parameter = if row.ty == "Feature"
+                        && !self.positional_is_end(feature)
+                        && matches!(self.elements[owner].ty, "Behavior" | "Function")
+                        && matches!(
+                            kind,
+                            "FeatureMembership"
+                                | "ParameterMembership"
+                                | "ReturnParameterMembership"
+                        ) {
+                        let direction = super::membership_evidence::parameter_direction(
+                            self, raw, feature, steps,
+                        )??;
+                        match kind {
+                            "ParameterMembership" => direction == "in",
+                            "ReturnParameterMembership" => {
+                                self.elements[owner].ty == "Function" && direction == "out"
+                            }
+                            _ => matches!(direction, "in" | "out" | "inout"),
+                        }
+                    } else {
+                        false
+                    };
+                    if !ordinary_end && !ordinary_parameter {
+                        return None;
+                    }
+                }
+                if external {
+                    if !context.allow_prerequisites {
+                        return None;
+                    }
+                    external_roles.insert(feature);
+                    required.push(owner);
+                }
+            } else if context.ordinary_only
+                && row.props.get("direction").is_some_and(|v| !v.is_null())
+            {
+                return None;
+            }
+            let owned = super::semantic_ownership::owned_relationships(self, feature)?;
+            let incoming = inverse
+                .relationships
+                .get(&feature)
+                .map_or(&[][..], Vec::as_slice);
+            charge(
+                &mut Some(&mut *steps),
+                owned.len().saturating_add(incoming.len()),
+            )?;
+            let relationships: Vec<_> = owned.iter().chain(incoming.iter().copied()).collect();
+            let mut seen_relationships = HashSet::new();
+            let mut authored_targets = Vec::new();
+            let mut targets = Vec::new();
+            for relationship in relationships {
+                if !conforms(self.elements[relationship].ty, "Redefinition")
+                    || !seen_relationships.insert(relationship)
+                {
+                    continue;
+                }
+                let carrier = super::semantic_ownership::checked_relationship_carrier(
+                    self,
+                    raw,
+                    relationship,
+                    steps,
+                )?;
+                if carrier != Some(feature) {
+                    return None;
+                }
+                let target = super::type_relations::endpoint_with_carrier(
+                    self,
+                    feature,
+                    carrier,
+                    relationship,
+                    &["specific", "subsettingFeature", "redefiningFeature"],
+                    &["general", "subsettedFeature", "redefinedFeature"],
+                    "Feature",
+                    steps,
+                )?;
+                if relationship < self.explicit_len() {
+                    authored_targets.push(target);
+                }
+                targets.push(target);
+                todo.push(target);
+            }
+            authored.insert(feature, authored_targets);
+            redefinitions.insert(feature, targets);
+        }
+        // The central reducer consumes resolved recorded edges. Prove those
+        // selectors match the exact current authored closure we just inspected.
+        if proof.recorded.is_none() {
+            proof.recorded = Some(RecordedRedefinitions::build(self, steps)?);
+        }
+        if !proof.recorded.as_ref()?.sources_match(&authored, steps)? {
+            return None;
+        }
+        if !external_roles.is_empty() || !context.allow_prerequisites {
+            let mut closure = Reachability::sparse();
+            let mut acyclic = HashMap::new();
+            for root in roots {
+                let reached =
+                    closure.reachable_budget(root, &redefinitions, &mut Some(&mut *steps))?;
+                charge(&mut Some(&mut *steps), reached.len().saturating_mul(2))?;
+                let needs_order = reached.iter().any(|source| {
+                    if context.allow_prerequisites {
+                        external_roles.contains(source)
+                    } else {
+                        roles.contains(source)
+                    }
+                });
+                if needs_order
+                    && reached.iter().any(|source| {
+                        authored
+                            .get(source)
+                            .is_some_and(|targets| !targets.is_empty())
+                    })
+                {
+                    // A role-free relay generates no positional candidate of
+                    // its own. Its reachable foreign roles are scheduled before
+                    // reduction. A positional authored source is safe only when
+                    // every authored target belongs to a strict actual ancestor,
+                    // whose generated edges already exist before add_edge runs.
+                    charge(&mut Some(&mut *steps), reached.len())?;
+                    for &source in reached {
+                        let targets = authored.get(&source).map_or(&[][..], Vec::as_slice);
+                        charge(&mut Some(&mut *steps), targets.len())?;
+                        if roles.contains(&source) {
+                            for target in targets {
+                                let owner = owners[&source];
+                                let target_owner = owners[target];
+                                if owner == target_owner
+                                    || !dependency.reaches_budget(
+                                        owner,
+                                        target_owner,
+                                        context.bases,
+                                        &mut Some(&mut *steps),
+                                    )?
+                                {
+                                    return None;
+                                }
+                            }
+                        }
+                    }
+                    acyclic_redefinition_closure(root, &redefinitions, &mut acyclic, steps)?;
+                }
+            }
+        }
+        charge(&mut Some(&mut *steps), required.len())?;
+        let mut unique = HashSet::new();
+        required.retain(|owner| unique.insert(*owner));
+        for &owner in &required {
+            self.positional_role_prerequisite_domain(
+                raw,
+                owner,
+                context.bases,
+                context.incomplete,
+                steps,
+                proof,
+            )?;
+        }
+        Some(required)
+    }
+
+    /// Validate the complete foreign owner/base domain before scheduling it.
+    /// Shared plain-package imports and ordered authored closures are admitted
+    /// only when every reachable positional owner belongs to real ancestry.
+    fn positional_role_prerequisite_domain(
+        &mut self,
+        raw: &super::structural_index::StoredStructure,
+        root: usize,
+        bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: &mut usize,
+        proof: &mut ImportProof,
+    ) -> Option<()> {
+        charge(&mut Some(&mut *steps), 1)?;
+        if !matches!(self.elements[root].ty, "Class" | "Behavior" | "Function") {
+            return None;
+        }
+        if proof.role_domains.contains(&root) {
+            return Some(());
+        }
+        let domains = raw.membership_domains(self, steps)?;
+        let imports = raw.import_domains(self, steps)?;
+        let mut visited = HashSet::new();
+        let mut todo = vec![root];
+        while let Some(owner) = todo.pop() {
+            charge(&mut Some(&mut *steps), 1)?;
+            if proof.role_domains.contains(&owner) || !visited.insert(owner) {
+                continue;
+            }
+            if !matches!(
+                self.elements[owner].ty,
+                "Class" | "Classifier" | "Behavior" | "Function"
+            ) || incomplete.contains(&owner)
+                || raw.bad_bases.contains(&owner)
+                || !domains.owner_complete(owner)
+                || !imports.owner_complete(owner)
+                || raw.metadata_annotation_targets.contains(&owner)
+                || self.metadata_of.get(&owner).is_some_and(|v| !v.is_empty())
+                || self
+                    .elem_scope
+                    .get(&owner)
+                    .is_some_and(|&s| !self.scopes[s].filters.is_empty())
+            {
+                return None;
+            }
+            let base = bases.get(&owner).map_or(&[][..], Vec::as_slice);
+            charge(&mut Some(&mut *steps), base.len())?;
+            todo.extend(base.iter().copied());
+            let relationships = super::semantic_ownership::owned_relationships(self, owner)?;
+            charge(&mut Some(&mut *steps), relationships.len())?;
+            let relationships: Vec<_> = relationships.iter().collect();
+            let mut features = Vec::new();
+            let mut visible_imports = false;
+            for relationship in relationships {
+                if super::semantic_ownership::checked_relationship_carrier(
+                    self,
+                    raw,
+                    relationship,
+                    steps,
+                )? != Some(owner)
+                {
+                    return None;
+                }
+                let kind = self.elements[relationship].ty;
+                if conforms(kind, "Conjugation") || conforms(kind, "ElementFilterMembership") {
+                    return None;
+                }
+                if conforms(kind, "Import") {
+                    super::import_memberships::checked_import_target(
+                        self,
+                        raw,
+                        owner,
+                        relationship,
+                        steps,
+                    )?;
+                    match self.elements[relationship].props.get("visibility") {
+                        None => {}
+                        Some(value) => match value.as_str() {
+                            Some("private") => {}
+                            Some("public" | "protected") => visible_imports = true,
+                            _ => return None,
+                        },
+                    }
+                }
+                if conforms(kind, "Membership") {
+                    let member =
+                        super::membership_evidence::member(self, raw, owner, relationship, steps)?;
+                    if conforms(self.elements[member].ty, "Feature") {
+                        features.push(PositionalMembership {
+                            relationship,
+                            member,
+                        });
+                    }
+                }
+            }
+            if visible_imports {
+                // Reuse the exact visibility-specific selector without entering
+                // Type proofs. Selector completeness does not replace the checked
+                // caller's independent lookup-provider certificate.
+                let selected = super::operations::namespaces::imports::type_imports(
+                    self,
+                    raw,
+                    owner,
+                    &[],
+                    steps,
+                )
+                .ok()?;
+                self.positional_import_source_dependencies(
+                    raw,
+                    &selected,
+                    ImportSourceContext {
+                        owner,
+                        bases,
+                        incomplete,
+                        ordinary_only: true,
+                        allow_prerequisites: false,
+                    },
+                    steps,
+                    proof,
+                )?;
+            }
+            self.positional_import_source_dependencies(
+                raw,
+                &(features, Vec::new()),
+                ImportSourceContext {
+                    owner,
+                    bases,
+                    incomplete,
+                    ordinary_only: false,
+                    allow_prerequisites: false,
+                },
+                steps,
+                proof,
+            )?;
+        }
+        charge(&mut Some(&mut *steps), visited.len())?;
+        proof.role_domains.extend(visited);
+        Some(())
+    }
+
+    /// Existing dependency-free selector, retained unchanged for LegacyV2 and
+    /// as the allocation-free no-import / admitted-leaf fast path in CanonicalV3.
+    fn positional_leaf_imports(
+        &mut self,
+        owner: usize,
+        bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<(Vec<PositionalMembership>, Vec<PositionalMembership>)> {
+        charge(steps, self.elements[owner].owned_relationships.len())?;
+        let imports: Vec<_> = self.elements[owner]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&r| {
+                conforms(self.elements[r].ty, "Import")
+                    && self.import_admitted(r, super::LookupAccess::Protected)
+            })
+            .collect();
+        if imports.is_empty() {
+            return Some(Default::default());
+        }
+        if self
+            .elem_scope
+            .get(&owner)
+            .is_some_and(|&s| !self.scopes[s].filters.is_empty())
+        {
+            return None;
+        }
+        let mut candidates = Vec::new();
+        for import in imports {
+            charge(steps, 1)?;
+            if self.elements[import]
+                .props
+                .get("isRecursive")
+                .and_then(|v| v.as_bool())
+                == Some(true)
+            {
+                return None;
+            }
+            let protected = self.elements[import]
+                .props
+                .get("visibility")
+                .and_then(|v| v.as_str())
+                == Some("protected");
+            let memberships = if conforms(self.elements[import].ty, "MembershipImport") {
+                let membership = self.positional_reference(import, "importedMembership")?;
+                let declaring = self.positional_reference(membership, "owningRelatedElement")?;
+                if !self.positional_import_leaf(declaring, bases, incomplete, steps)? {
+                    return None;
+                }
+                vec![membership]
+            } else {
+                let target = self.positional_reference(import, "importedNamespace")?;
+                if !self.positional_import_leaf(target, bases, incomplete, steps)? {
+                    return None;
+                }
+                let access = if self.elements[import]
+                    .props
+                    .get("isImportAll")
+                    .and_then(|v| v.as_bool())
+                    == Some(true)
+                {
+                    super::LookupAccess::All
+                } else {
+                    super::LookupAccess::Public
+                };
+                charge(steps, self.elements[target].owned_relationships.len())?;
+                self.elements[target]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .filter(|&r| {
+                        conforms(self.elements[r].ty, "Membership")
+                            && self.import_admitted(r, access)
+                    })
+                    .collect()
+            };
+            charge(steps, memberships.len())?;
+            candidates.extend(memberships.into_iter().map(|m| (m, protected)));
+        }
+        // Type::nonPrivateMemberships composes visibility-specific imports,
+        // not Namespace::importedMemberships' collision-pruned projection.
+        // Position follows these membership identities even when names collide.
+        let mut result = (Vec::new(), Vec::new());
+        for (membership, protected) in candidates {
+            charge(steps, 1)?;
+            // Aliases participate in inherited redefinition filtering even
+            // though only FeatureMemberships can become positional slots.
+            let member = self.stored_membership_member(membership)?;
+            let membership = PositionalMembership {
+                relationship: membership,
+                member,
+            };
+            if protected {
+                result.1.push(membership);
+            } else {
+                result.0.push(membership);
+            }
+        }
+        Some(result)
+    }
+
+    fn positional_import_leaf(
+        &self,
+        owner: usize,
+        bases: &HashMap<usize, Vec<usize>>,
+        incomplete: &HashSet<usize>,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<bool> {
+        charge(
+            steps,
+            self.elements[owner]
+                .owned_relationships
+                .len()
+                .saturating_add(1),
+        )?;
+        Some(
+            !incomplete.contains(&owner)
+                && bases.get(&owner).is_none_or(Vec::is_empty)
+                && !self.elements[owner].owned_relationships.iter().any(|&r| {
+                    conforms(self.elements[r].ty, "Import")
+                        || conforms(self.elements[r].ty, "Specialization")
+                })
+                && self
+                    .elem_scope
+                    .get(&owner)
+                    .is_none_or(|&s| self.scopes[s].filters.is_empty()),
+        )
+    }
+
+    fn positional_reference(&mut self, e: usize, key: &str) -> Option<usize> {
+        let id = self.elements[e].props.get(key)?.as_reference()?;
+        self.element_index_of_uuid(id)
+    }
+
+    pub(super) fn positional_is_end(&self, e: usize) -> bool {
+        self.elements[e]
+            .props
+            .get("isEnd")
+            .and_then(|v| v.as_bool())
+            == Some(true)
+    }
+
+    pub(super) fn positional_is_result(&self, e: usize) -> bool {
+        self.elements[e]
+            .owning_relationship
+            .is_some_and(|r| conforms(self.elements[r].ty, "ReturnParameterMembership"))
+    }
+
+    fn positional_owned_memberships(
+        &mut self,
+        owner: usize,
+        steps: &mut Option<&mut usize>,
+    ) -> Option<Vec<PositionalMembership>> {
+        charge(
+            steps,
+            self.elements[owner]
+                .owned_relationships
+                .len()
+                .saturating_mul(2),
+        )?;
+        let relationships: Vec<_> = self.elements[owner]
+            .owned_relationships
+            .iter()
+            .copied()
+            .filter(|&r| {
+                conforms(self.elements[r].ty, "Membership")
+                    && self.import_admitted(r, super::LookupAccess::Protected)
+            })
+            .collect();
+        relationships
+            .into_iter()
+            .map(|relationship| {
+                Some(PositionalMembership {
+                    relationship,
+                    member: self.stored_membership_member(relationship)?,
+                })
+            })
+            .collect()
+    }
+
+    pub(super) fn semantic_redefinition_targets(
+        &mut self,
+        e: usize,
+        include_implied: bool,
+    ) -> Vec<usize> {
+        let mut targets = self.indexed_redefinition_targets(e);
+        if include_implied
+            && self.semantic_ready
+            && self.dynamic_evidence_current(e)
+            && self.result_redefinition_evidence_current(e)
+        {
+            if self.effective_positional_redefinitions().is_none() {
+                self.ensure_positional_redefinitions();
+            }
+            for &target in self
+                .effective_positional_redefinitions()
+                .and_then(|plan| plan.targets.get(&e))
+                .into_iter()
+                .flatten()
+            {
+                if !targets.contains(&target) {
+                    targets.push(target);
+                }
+            }
+        }
+        targets
+    }
+}
+
+// Structural cycle evidence for newly admitted authored/positional closures.
+// This validates the inspected graph; the common planner still derives all edges.
+fn acyclic_redefinition_closure(
+    root: usize,
+    graph: &HashMap<usize, Vec<usize>>,
+    state: &mut HashMap<usize, u8>,
+    steps: &mut usize,
+) -> Option<()> {
+    let mut todo = vec![(root, false)];
+    while let Some((source, exiting)) = todo.pop() {
+        charge(&mut Some(&mut *steps), 1)?;
+        if exiting {
+            state.insert(source, 2);
+            continue;
+        }
+        match state.get(&source) {
+            Some(1) => return None,
+            Some(2) => continue,
+            _ => {}
+        }
+        state.insert(source, 1);
+        todo.push((source, true));
+        if let Some(targets) = graph.get(&source) {
+            charge(&mut Some(&mut *steps), targets.len())?;
+            todo.extend(targets.iter().rev().map(|&target| (target, false)));
+        }
+    }
+    Some(())
+}
+
+fn add_edge(
+    source: usize,
+    target: usize,
+    graph: &mut HashMap<usize, Vec<usize>>,
+    added: &mut HashMap<usize, Vec<usize>>,
+    traversal: &mut Reachability,
+    steps: &mut Option<&mut usize>,
+) -> Option<()> {
+    if !traversal.reaches_budget(source, target, graph, steps)? {
+        charge(steps, 1)?;
+        graph.entry(source).or_default().push(target);
+        added.entry(source).or_default().push(target);
+    }
+    Some(())
+}
+
+fn charge_sort(steps: &mut Option<&mut usize>, size: usize) -> Option<()> {
+    charge(steps, size.saturating_mul(size.max(1).ilog2() as usize + 2))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn canonical_recursive_and_cyclic_package_selectors_support_positional_publication() {
+        for provider in [
+            "class Marker; package P {package Q {alias Alias for Marker;}} class A {public import P::**; end feature own;}",
+            "package P {class Marker; public import Q::*;} package Q {public import P::*;} class A {public import P::*; end feature own;}",
+        ] {
+            for format in [
+                crate::model::GraphFormat::LegacyV2,
+                crate::model::GraphFormat::CanonicalV3,
+            ] {
+                let mut model = crate::model::Model::with_graph_format(format);
+                let source =
+                    format!("{provider} class B specializes A {{end feature replacement;}}");
+                let unit = model.add_source("package-selector-publication.kerml", &source);
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+                let mut r = super::super::ResolvedModel::build(&model);
+                let owner = r.resolve_qualified("B").unwrap().0;
+                let own = r.resolve_qualified("A::own").unwrap().0;
+                let replacement = r.resolve_qualified("B::replacement").unwrap().0;
+                // This tests the central positional selector independently of
+                // the stricter checked Type scope-completeness certificate.
+                // The imported memberships contain no positional Features.
+                assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+                let plan = r.b.positional_redefinitions.as_ref().unwrap();
+                if format == crate::model::GraphFormat::CanonicalV3 {
+                    assert!(!plan.incomplete.contains(&owner), "{source}");
+                    assert_eq!(plan.targets.get(&replacement), Some(&vec![own]), "{source}");
+                } else {
+                    assert!(plan.incomplete.contains(&owner), "{source}");
+                    assert!(!plan.targets.contains_key(&replacement), "{source}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn expanded_import_publication_refuses_stale_recorded_redefinition_targets() {
+        let mut model =
+            crate::model::Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+        let unit = model.add_source("import-recorded-redefinition.kerml", "class Target {feature original;} class Other {feature different;} class External specializes Target {feature selected redefines Target::original;} class Provider {public import External::selected; end feature own;} class Child specializes Provider {end feature replacement;}");
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = super::super::ResolvedModel::build(&model);
+        let selected = r.resolve_qualified("External::selected").unwrap().0;
+        let different = r.resolve_qualified("Other::different").unwrap().0;
+        let own = r.resolve_qualified("Provider::own").unwrap().0;
+        let child = r.resolve_qualified("Child").unwrap().0;
+        let replacement = r.resolve_qualified("Child::replacement").unwrap().0;
+        let (bases, incomplete) = r.b.positional_direct_bases();
+        let healthy = r
+            .b
+            .plan_positional_redefinitions_with_bases_and_budget(&bases, &incomplete, Some(&mut 0))
+            .unwrap();
+        assert_eq!(healthy.targets.get(&replacement), Some(&vec![own]));
+        let index =
+            r.b.spec_targets
+                .iter()
+                .position(|&(source, kind, _, _)| source == selected && kind == "Redefinition")
+                .unwrap();
+        let original = r.b.spec_resolved[index];
+        r.b.spec_resolved[index] = Some(different);
+        let refused = r
+            .b
+            .plan_positional_redefinitions_with_bases_and_budget(&bases, &incomplete, Some(&mut 0))
+            .unwrap();
+        assert!(refused.incomplete.contains(&child));
+        assert!(!refused.targets.contains_key(&replacement));
+        r.b.spec_resolved[index] = original;
+        let recovered = r
+            .b
+            .plan_positional_redefinitions_with_bases_and_budget(&bases, &incomplete, Some(&mut 0))
+            .unwrap();
+        assert_eq!(recovered.targets.get(&replacement), Some(&vec![own]));
+    }
+
+    #[test]
+    fn reduction_workspace_does_not_reuse_changed_recorded_redefinitions() {
+        let mut model = crate::model::Model::new();
+        model.add_source(
+            "workspace-redefinition.kerml",
+            "function A {in p;} function B specializes A {in q redefines A::p;}",
+        );
+        assert!(!model.has_errors());
+        let mut r = super::super::ResolvedModel::build(&model);
+        let (bases, incomplete) = r.b.positional_direct_bases();
+        let mut workspace = PositionalWorkspace::default();
+        r.b.plan_positional_redefinitions_with_workspace(
+            &bases,
+            &incomplete,
+            Some(&mut 0),
+            &mut workspace,
+        )
+        .unwrap();
+        let index =
+            r.b.spec_targets
+                .iter()
+                .position(|(_, kind, _, _)| *kind == "Redefinition")
+                .unwrap();
+        let source = r.b.spec_targets[index].0;
+        let rows = r.b.elements.observe_revision();
+        assert!(
+            workspace
+                .reduction
+                .as_ref()
+                .unwrap()
+                .redefinitions
+                .contains_key(&source)
+        );
+        r.b.spec_resolved[index] = None;
+        assert!(r.b.elements.revision().unwrap().same_as(&rows));
+        let reused =
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut 0),
+                &mut workspace,
+            )
+            .unwrap();
+        let fresh = r
+            .b
+            .plan_positional_redefinitions_with_bases_and_budget(&bases, &incomplete, Some(&mut 0))
+            .unwrap();
+        assert_eq!(reused.targets, fresh.targets);
+        assert_eq!(reused.incomplete, fresh.incomplete);
+        assert!(
+            !workspace
+                .reduction
+                .as_ref()
+                .unwrap()
+                .redefinitions
+                .contains_key(&source)
+        );
+    }
+
+    #[test]
+    fn transaction_workspace_recomputes_candidate_and_import_dependencies() {
+        let mut model = crate::model::Model::new();
+        model.add_source("workspace.kerml", "package P {feature x;} function A {public import P::*; in p; return result;} function B {in q; return r;}");
+        assert!(!model.has_errors());
+        let mut r = super::super::ResolvedModel::build(&model);
+        let find = |name: &str| {
+            r.b.elements
+                .iter()
+                .position(|e| e.props.get("declaredName").and_then(|v| v.as_str()) == Some(name))
+                .unwrap()
+        };
+        let (a, b, p) = (find("A"), find("B"), find("P"));
+        let (mut bases, mut incomplete) = r.b.positional_direct_bases();
+        let mut workspace = PositionalWorkspace::default();
+        let mut first_steps = 0;
+        let first =
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut first_steps),
+                &mut workspace,
+            )
+            .unwrap();
+        let mut warm_steps = 0;
+        let warm =
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut warm_steps),
+                &mut workspace,
+            )
+            .unwrap();
+        assert_eq!(first.targets, warm.targets);
+        assert_eq!(first.incomplete, warm.incomplete);
+        assert!(warm_steps < first_steps);
+        super::super::structural_index::StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        let indexed = r
+            .b
+            .plan_positional_redefinitions_with_bases_and_budget(&bases, &incomplete, Some(&mut 0))
+            .unwrap();
+        assert_eq!(indexed.targets, first.targets);
+        assert_eq!(indexed.incomplete, first.incomplete);
+        let mut retried_workspace = PositionalWorkspace::default();
+        let mut exhausted = crate::eval::MAX_STEPS - 1;
+        assert!(
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut exhausted),
+                &mut retried_workspace
+            )
+            .is_none()
+        );
+        let retried =
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut 0),
+                &mut retried_workspace,
+            )
+            .unwrap();
+        assert_eq!(retried.targets, first.targets);
+        assert_eq!(retried.incomplete, first.incomplete);
+        bases.entry(b).or_default().push(a);
+        for qualify_provider in [false, true] {
+            if qualify_provider {
+                incomplete.insert(p);
+            }
+            let reused =
+                r.b.plan_positional_redefinitions_with_workspace(
+                    &bases,
+                    &incomplete,
+                    Some(&mut 0),
+                    &mut workspace,
+                )
+                .unwrap();
+            let fresh =
+                r.b.plan_positional_redefinitions_with_bases_and_budget(
+                    &bases,
+                    &incomplete,
+                    Some(&mut 0),
+                )
+                .unwrap();
+            assert_eq!(reused.targets, fresh.targets);
+            assert_eq!(reused.incomplete, fresh.incomplete);
+            if qualify_provider {
+                assert!(reused.incomplete.contains(&a));
+            }
+        }
+        r.b.elements[a]
+            .props
+            .insert("isAbstract", serde_json::json!(true));
+        assert!(
+            r.b.plan_positional_redefinitions_with_workspace(
+                &bases,
+                &incomplete,
+                Some(&mut 0),
+                &mut workspace
+            )
+            .is_none()
+        );
+        assert!(
+            r.b.plan_positional_redefinitions_with_bases_and_budget(
+                &bases,
+                &incomplete,
+                Some(&mut 0)
+            )
+            .is_some()
+        );
+    }
+
+    #[test]
+    fn bounded_supplied_planning_matches_unbounded_and_refuses_the_entire_budget_prefix() {
+        let mut model = crate::model::Model::new();
+        model.add_source("budget.kerml", "function A {in p; return result;} function B specializes A {in q; return r;} function C specializes B {in s; return t;} feature call=C(1);");
+        assert!(!model.has_errors());
+        let mut r = super::super::ResolvedModel::build(&model);
+        r.b.ensure_positional_redefinitions();
+        let published = r.b.positional_redefinitions.clone().unwrap();
+        let (bases, incomplete) = r.b.positional_direct_bases();
+        let mut measured = r.b.clone();
+        let mut used = 0;
+        let complete = measured
+            .plan_positional_redefinitions_with_bases_and_budget(
+                &bases,
+                &incomplete,
+                Some(&mut used),
+            )
+            .unwrap();
+        assert_eq!(complete.targets, published.targets);
+        assert_eq!(complete.incomplete, published.incomplete);
+        assert!(used > 1 && used < crate::eval::MAX_STEPS);
+        let mut interrupted = r.b.clone();
+        let mut budget = crate::eval::MAX_STEPS - used + 1;
+        assert!(
+            interrupted
+                .plan_positional_redefinitions_with_bases_and_budget(
+                    &bases,
+                    &incomplete,
+                    Some(&mut budget)
+                )
+                .is_none()
+        );
+        assert!(budget > crate::eval::MAX_STEPS);
+        assert_eq!(
+            interrupted
+                .positional_redefinitions
+                .as_ref()
+                .unwrap()
+                .targets,
+            published.targets
+        );
+        assert_eq!(
+            interrupted
+                .positional_redefinitions
+                .as_ref()
+                .unwrap()
+                .incomplete,
+            published.incomplete
+        );
+        let mut fresh = 0;
+        let retried = interrupted
+            .plan_positional_redefinitions_with_bases_and_budget(
+                &bases,
+                &incomplete,
+                Some(&mut fresh),
+            )
+            .unwrap();
+        assert_eq!(retried.targets, complete.targets);
+        assert_eq!(retried.incomplete, complete.incomplete);
+    }
+
+    #[test]
+    fn traversal_charges_edges_before_growing_pending_work_and_recovers() {
+        let mut traversal = Reachability::new(4);
+        let graph = HashMap::from([(0, vec![1, 2]), (1, vec![3]), (2, vec![3]), (3, vec![0])]);
+        let mut work = crate::eval::MAX_STEPS - 2;
+        assert!(
+            traversal
+                .reachable_budget(0, &graph, &mut Some(&mut work))
+                .is_none()
+        );
+        assert!(work > crate::eval::MAX_STEPS);
+        assert!(
+            traversal.todo.is_empty(),
+            "edge extension must follow its charge"
+        );
+        assert_eq!(
+            traversal
+                .reachable_budget(0, &graph, &mut Some(&mut 0))
+                .unwrap()
+                .len(),
+            4
+        );
+    }
+
+    #[test]
+    fn supplied_static_bases_reproduce_the_legacy_positional_plan() {
+        let mut model = crate::model::Model::new();
+        model.add_source("positional.kerml", "function Base {in a; return b;} function Child specializes Base {in x; return y;} feature call=Child(1);");
+        assert!(!model.has_errors());
+        let mut r = super::super::ResolvedModel::build(&model);
+        let expected = r.b.plan_positional_redefinitions();
+        let (bases, incomplete) = r.b.positional_direct_bases();
+        let retained = r.b.supported_implied.clone().unwrap();
+        let actual =
+            r.b.plan_positional_redefinitions_with_bases(&bases, &incomplete);
+        assert_eq!(actual.targets, expected.targets);
+        assert_eq!(actual.incomplete, expected.incomplete);
+        assert!(std::sync::Arc::ptr_eq(
+            &retained,
+            r.b.supported_implied.as_ref().unwrap()
+        ));
+    }
+
+    #[test]
+    fn supplied_local_callee_bases_do_not_publish_candidate_positional_rows() {
+        let mut model = crate::model::Model::new();
+        model.add_source(
+            "positional.kerml",
+            "function F {in p; return result;} feature call=F(1);",
+        );
+        assert!(!model.has_errors());
+        let mut r = super::super::ResolvedModel::build(&model);
+        let function = r.resolve_qualified("F").unwrap().0;
+        let parameter = r.resolve_qualified("F::p").unwrap().0;
+        let invocation =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap();
+        let argument =
+            r.b.owned_member_elems(invocation, true)
+                .into_iter()
+                .find(|&f| r.b.is_parameter(f) && !r.b.positional_is_result(f))
+                .unwrap();
+        r.b.ensure_positional_redefinitions();
+        let published = r.b.positional_redefinitions.clone().unwrap();
+        let (mut bases, incomplete) = r.b.positional_direct_bases();
+        assert!(
+            !bases
+                .get(&invocation)
+                .is_some_and(|v| v.contains(&function))
+        );
+        bases.entry(invocation).or_default().push(function);
+        let candidate =
+            r.b.plan_positional_redefinitions_with_bases(&bases, &incomplete);
+        assert!(
+            candidate
+                .targets
+                .get(&argument)
+                .is_some_and(|v| v.contains(&parameter))
+        );
+        assert_eq!(
+            r.b.positional_redefinitions.as_ref().unwrap().targets,
+            published.targets
+        );
+        assert_eq!(
+            r.b.positional_redefinitions.as_ref().unwrap().incomplete,
+            published.incomplete
+        );
+    }
+
+    #[test]
+    fn wide_scratch_tables_do_not_follow_a_run_of_tiny_nodes() {
+        let mut members: HashSet<_> = (0..4096).collect();
+        let mut counts: HashMap<_, _> = (0..4096).map(|e| (e, 1)).collect();
+        reset_scratch_set(&mut members);
+        reset_scratch_map(&mut counts);
+        assert!(members.is_empty() && counts.is_empty());
+        for e in 0..1000 {
+            members.insert(e);
+            counts.insert(e, 1);
+            reset_scratch_set(&mut members);
+            reset_scratch_map(&mut counts);
+            assert!(members.is_empty() && counts.is_empty());
+            assert!(members.capacity() <= 128 && counts.capacity() <= 128);
+        }
+    }
+
+    #[test]
+    fn reusable_traversal_matches_transitive_closure_for_every_three_node_graph() {
+        let mut traversal = Reachability::new(3);
+        for bits in 0..512 {
+            let mut graph = HashMap::new();
+            let mut expected = [[false; 3]; 3];
+            for (source, row) in expected.iter_mut().enumerate() {
+                row[source] = true;
+                for (target, reachable) in row.iter_mut().enumerate() {
+                    if bits & (1 << (source * 3 + target)) != 0 {
+                        graph.entry(source).or_insert_with(Vec::new).push(target);
+                        *reachable = true;
+                    }
+                }
+            }
+            for intermediate in 0..3 {
+                for source in 0..3 {
+                    for target in 0..3 {
+                        expected[source][target] |=
+                            expected[source][intermediate] && expected[intermediate][target];
+                    }
+                }
+            }
+            for (source, expected) in expected.iter().enumerate() {
+                let reached = traversal.reachable(source, &graph);
+                assert_eq!(reached.len(), expected.iter().filter(|&&v| v).count());
+                for (target, expected) in expected.iter().enumerate() {
+                    assert_eq!(
+                        reached.contains(&target),
+                        *expected,
+                        "graph {bits}, {source}->{target}"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn traversal_observes_graph_growth_and_generation_wrap() {
+        let mut traversal = Reachability::new(4);
+        let mut graph = HashMap::from([(0, vec![1, 2]), (1, vec![3]), (2, vec![3])]);
+        assert_eq!(traversal.reachable(3, &graph), [3]);
+        assert_eq!(traversal.reachable(0, &graph).len(), 4);
+        graph.insert(3, vec![0]);
+        assert_eq!(traversal.reachable(3, &graph).len(), 4);
+        traversal.generation = usize::MAX;
+        // Stale first-generation marks must not survive the wrap.
+        traversal.marks.fill(1);
+        graph.clear();
+        assert_eq!(traversal.reachable(0, &graph), [0]);
+        assert_eq!(traversal.reachable(3, &graph), [3]);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/positional_delta.rs b/crates/sysmlv2-model/src/json/positional_delta.rs
new file mode 100644
index 0000000..a4d913e
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/positional_delta.rs
@@ -0,0 +1,194 @@
+//! Certificate for adding dynamic positional rows behind an immutable prefix.
+//! It does not admit callee endpoints, derive bases or publish/cache a plan.
+use super::positional::PositionalRedefinitions;
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, PartialEq, Eq)]
+pub(super) enum Refusal {
+    WorkLimit,
+    LostCompleteness,
+    ChangedStaticOrder,
+    InvalidSource,
+    DuplicateTarget,
+}
+
+fn charge(steps: &mut usize, amount: usize) -> Result<(), Refusal> {
+    *steps = steps.saturating_add(amount);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(Refusal::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+
+/// Compare every static positional row against the complete candidate run.
+/// Each old target vector must be an exact prefix: a semantic tail cannot
+/// insert new targets before/between immutable static rows. New completeness
+/// failures anywhere refuse the batch, including scopes reached via imports.
+/// Required owners are all dynamic specialization sources, including calls
+/// with no arguments/results. They must not be incomplete merely because the
+/// candidate happened to emit no positional row for them.
+///
+/// source_owner must return the checked exact owning Type of a positional
+/// Feature, charging any traversal to the supplied shared steps. A scope-only
+/// owner lookup is insufficient for scope-less invocation arguments.
+/// Both plans must come from the same immutable authored snapshot and shared
+/// planner. Only the returned additions may enter a bind-invalidated tail;
+/// the candidate plan itself remains unpublished until the entire dynamic
+/// batch (endpoints, generated IDs, ownership and caches) can commit atomically.
+pub(super) fn certify(
+    static_plan: &PositionalRedefinitions,
+    candidate: &PositionalRedefinitions,
+    required_owners: &[usize],
+    mut source_owner: impl FnMut(usize, &mut usize) -> Option<usize>,
+    steps: &mut usize,
+) -> Result<HashMap<usize, Vec<usize>>, Refusal> {
+    charge(steps, required_owners.len())?;
+    for owner in required_owners {
+        if candidate.incomplete.contains(owner) {
+            return Err(Refusal::LostCompleteness);
+        }
+    }
+    charge(steps, candidate.incomplete.len())?;
+    if candidate
+        .incomplete
+        .iter()
+        .any(|owner| !static_plan.incomplete.contains(owner))
+    {
+        return Err(Refusal::LostCompleteness);
+    }
+    for (&source, old) in &static_plan.targets {
+        charge(steps, old.len().saturating_add(1))?;
+        let next = candidate
+            .targets
+            .get(&source)
+            .map_or(&[][..], Vec::as_slice);
+        if !next.starts_with(old) {
+            return Err(Refusal::ChangedStaticOrder);
+        }
+    }
+    let mut delta = HashMap::new();
+    for (&source, targets) in &candidate.targets {
+        // Charge all target validation and copying before allocating either
+        // the uniqueness set or the output slice. No partial delta escapes.
+        charge(steps, targets.len().saturating_mul(2).saturating_add(1))?;
+        let mut seen = HashSet::new();
+        if targets.iter().any(|target| !seen.insert(*target)) {
+            return Err(Refusal::DuplicateTarget);
+        }
+        let before = static_plan.targets.get(&source).map_or(0, Vec::len);
+        if targets.len() > before {
+            let owner = source_owner(source, steps);
+            charge(steps, 0)?;
+            let owner = owner.ok_or(Refusal::InvalidSource)?;
+            if candidate.incomplete.contains(&owner) {
+                return Err(Refusal::LostCompleteness);
+            }
+            delta.insert(source, targets[before..].to_vec());
+        }
+    }
+    Ok(delta)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn plan(rows: &[(usize, &[usize])], incomplete: &[usize]) -> PositionalRedefinitions {
+        PositionalRedefinitions {
+            targets: rows.iter().map(|(s, t)| (*s, t.to_vec())).collect(),
+            incomplete: incomplete.iter().copied().collect(),
+        }
+    }
+    fn run(
+        a: &PositionalRedefinitions,
+        b: &PositionalRedefinitions,
+        required: &[usize],
+    ) -> Result<HashMap<usize, Vec<usize>>, Refusal> {
+        certify(a, b, required, |s, _| Some(s / 10), &mut 0)
+    }
+    #[test]
+    fn suffix_additions_preserve_every_static_row() {
+        let old = plan(&[(10, &[2, 3]), (20, &[4])], &[]);
+        let next = plan(&[(10, &[2, 3, 5]), (20, &[4]), (30, &[6])], &[]);
+        assert_eq!(
+            run(&old, &next, &[1]),
+            Ok(HashMap::from([(10, vec![5]), (30, vec![6])]))
+        );
+        assert_eq!(run(&old, &old, &[]), Ok(HashMap::new()));
+    }
+    #[test]
+    fn loss_reorder_retarget_and_middle_insert_are_refused() {
+        let old = plan(&[(10, &[2, 3])], &[]);
+        for next in [
+            plan(&[], &[]),
+            plan(&[(10, &[3, 2])], &[]),
+            plan(&[(10, &[2, 4])], &[]),
+            plan(&[(10, &[2, 4, 3])], &[]),
+        ] {
+            assert_eq!(run(&old, &next, &[]), Err(Refusal::ChangedStaticOrder));
+        }
+    }
+    #[test]
+    fn incompleteness_without_output_is_not_empty_success() {
+        let old = plan(&[], &[1]);
+        assert_eq!(run(&old, &old, &[1]), Err(Refusal::LostCompleteness));
+        assert_eq!(
+            run(&plan(&[], &[]), &plan(&[], &[9]), &[]),
+            Err(Refusal::LostCompleteness)
+        );
+        assert_eq!(
+            run(&old, &plan(&[(10, &[2])], &[1]), &[]),
+            Err(Refusal::LostCompleteness)
+        );
+        assert_eq!(
+            run(&old, &plan(&[(10, &[2])], &[]), &[1]),
+            Ok(HashMap::from([(10, vec![2])]))
+        );
+    }
+    #[test]
+    fn invalid_targets_and_sources_refuse() {
+        assert_eq!(
+            run(&plan(&[], &[]), &plan(&[(10, &[2, 2])], &[]), &[]),
+            Err(Refusal::DuplicateTarget)
+        );
+        assert_eq!(
+            certify(
+                &plan(&[], &[]),
+                &plan(&[(10, &[2])], &[]),
+                &[],
+                |_, _| None,
+                &mut 0
+            ),
+            Err(Refusal::InvalidSource)
+        );
+    }
+    #[test]
+    fn exhausted_comparison_returns_no_prefix_and_does_not_poison_retry() {
+        let old = plan(&[], &[]);
+        let next = plan(&[(10, &[2, 3])], &[]);
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert_eq!(
+            certify(&old, &next, &[], |_, _| Some(1), &mut steps),
+            Err(Refusal::WorkLimit)
+        );
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(run(&old, &next, &[]).is_ok());
+    }
+    #[test]
+    fn successful_owner_callback_cannot_hide_exhausted_shared_work() {
+        let old = plan(&[], &[]);
+        let next = plan(&[(10, &[2])], &[]);
+        let mut steps = 0;
+        let result = certify(
+            &old,
+            &next,
+            &[],
+            |_, work| {
+                *work = crate::eval::MAX_STEPS + 1;
+                Some(1)
+            },
+            &mut steps,
+        );
+        assert_eq!(result, Err(Refusal::WorkLimit));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/provider_completeness.rs b/crates/sysmlv2-model/src/json/provider_completeness.rs
new file mode 100644
index 0000000..81c88be
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/provider_completeness.rs
@@ -0,0 +1,1046 @@
+//! Query-local proofs for supported inheritance and import providers.
+use super::Builder;
+use crate::metaclass::conforms;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+#[cfg(test)]
+mod mixed_tests;
+mod recursive;
+#[cfg(test)]
+mod recursive_tests;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+enum Dependency {
+    Scope(usize),
+    Recursive(usize, bool),
+    Package(usize),
+}
+
+/// An absence proof must include dependencies skipped by inherited lookup.
+/// Kept local to one query: no stale positive result survives graph changes.
+#[derive(Default)]
+pub(crate) struct ProviderCompleteness {
+    publication: Option<super::publication::Revision>,
+    known: HashMap<(usize, usize), bool>,
+    active: HashSet<usize>,
+    // Shared immutable topology, retained once for this proof query. Incoming
+    // standalone Annotation rows are not represented completely by metadata_of.
+    annotations: Option<Arc<super::structural_index::StoredStructure>>,
+    metadata_generation: Option<Arc<()>>,
+    planner_state: Option<(bool, bool)>,
+    retained_plan: Option<Arc<super::implied::SupportedImpliedSpecializations>>,
+    transient_incomplete: bool,
+    recursive: recursive::Proof,
+    scope_revision: Option<crate::layered::Revision>,
+    recursive_import_domains: Option<Arc<super::structural_index::ImportDomains>>,
+}
+
+impl ProviderCompleteness {
+    pub(super) fn reset_with_budget(&mut self, steps: &mut usize) -> Option<()> {
+        if !self.invalidate_known(steps) {
+            return None;
+        }
+        self.recursive.charge_roots_drop(steps)?;
+        *self = Self::default();
+        Some(())
+    }
+
+    pub(crate) fn scope(&mut self, b: &mut Builder, scope: usize, steps: &mut usize) -> bool {
+        // Resolver caches and element-to-scope maps have no content revision.
+        // Never reuse semantic facts depending on recursive evidence across calls.
+        if self.recursive.touched && !self.invalidate_known(steps) {
+            return false;
+        }
+        let scopes = b.scopes.observe_revision();
+        if self
+            .scope_revision
+            .as_ref()
+            .is_some_and(|old| !old.same_as(&scopes))
+            && !self.invalidate_known(steps)
+        {
+            return false;
+        }
+        self.scope_revision = Some(scopes);
+        let epoch = b.publication.revision();
+        match &self.publication {
+            Some(previous) if !previous.same_as(&epoch) => return false,
+            None => self.publication = Some(epoch),
+            _ => {}
+        }
+        if b.positional_planning || !self.prepare_annotations(b, steps) {
+            return false;
+        }
+        let state = (b.semantic_ready, b.positional_redefinitions.is_some());
+        let same_plan = match (&self.retained_plan, &b.supported_implied) {
+            (None, None) => true,
+            (Some(old), Some(current)) => Arc::ptr_eq(old, current),
+            _ => false,
+        };
+        if self.planner_state != Some(state) || !same_plan {
+            if !self.invalidate_known(steps) {
+                return false;
+            }
+            self.planner_state = Some(state);
+            self.retained_plan = b.supported_implied.clone();
+        }
+        if let Some(&complete) = self.known.get(&(scope, 0)) {
+            *steps = steps.saturating_add(1);
+            return *steps <= crate::eval::MAX_STEPS && complete;
+        }
+        if !charge_provenance(b, steps) {
+            return false;
+        }
+        self.transient_incomplete = false;
+        neutral(b, |b| {
+            if b.effective_positional_redefinitions().is_none()
+                && !b.ensure_positional_redefinitions_with_budget(steps)
+            {
+                return false;
+            }
+            self.planner_state = Some((b.semantic_ready, b.positional_redefinitions.is_some()));
+            self.retained_plan = b.supported_implied.clone();
+            self.scope_inner(b, scope, 0, steps)
+        })
+    }
+
+    fn invalidate_known(&mut self, steps: &mut usize) -> bool {
+        *steps = steps
+            .saturating_add(self.known.capacity())
+            .saturating_add(self.active.capacity());
+        if *steps > crate::eval::MAX_STEPS {
+            return false;
+        }
+        if !self.recursive.clear(steps) {
+            return false;
+        }
+        self.known.clear();
+        self.active.clear();
+        true
+    }
+
+    fn prepare_annotations(&mut self, b: &mut Builder, steps: &mut usize) -> bool {
+        let same_metadata = match (
+            &self.metadata_generation,
+            &b.metadata_association_generation,
+        ) {
+            (None, None) => true,
+            (Some(old), Some(current)) => Arc::ptr_eq(old, current),
+            _ => false,
+        };
+        if !same_metadata {
+            if !self.invalidate_known(steps) {
+                return false;
+            }
+            self.annotations = None;
+            self.metadata_generation = b.metadata_association_generation.clone();
+        }
+        if b.metadata_associations_incomplete {
+            if !self.invalidate_known(steps) {
+                return false;
+            }
+            return false;
+        }
+        if self
+            .annotations
+            .as_ref()
+            .is_some_and(|index| index.is_current(b))
+        {
+            *steps = steps.saturating_add(1);
+            return *steps <= crate::eval::MAX_STEPS;
+        }
+        // No scope result survives an identity/ownership/annotation mutation.
+        // Failed publication leaves no partial absence certificate to reuse.
+        if !self.invalidate_known(steps) {
+            return false;
+        }
+        self.annotations = None;
+        let Some(index) = super::structural_index::StoredStructure::for_annotations(b, steps)
+        else {
+            return false;
+        };
+        self.recursive_import_domains = if index.has_recursive_import {
+            let Some(domains) = index.import_domains(b, steps) else {
+                return false;
+            };
+            Some(domains)
+        } else {
+            None
+        };
+        self.annotations = Some(index);
+        true
+    }
+
+    fn scope_inner(
+        &mut self,
+        b: &mut Builder,
+        scope: usize,
+        depth: usize,
+        steps: &mut usize,
+    ) -> bool {
+        *steps = steps.saturating_add(1);
+        if depth > super::MAX_RESOLUTION_DEPTH || *steps > crate::eval::MAX_STEPS {
+            return false;
+        }
+        if let Some(&complete) = self.known.get(&(scope, depth)) {
+            return complete;
+        }
+        if !self.active.insert(scope) {
+            return false;
+        }
+        let complete = self
+            .dependencies(b, scope, depth, false, steps)
+            .is_some_and(|dependencies| self.complete_dependencies(b, dependencies, depth, steps));
+        self.active.remove(&scope);
+        // Exhaustion is query-local, not evidence that this scope is incomplete.
+        // A later comparison can retry with a fresh budget on the same provider.
+        if *steps <= crate::eval::MAX_STEPS && (complete || !self.transient_incomplete) {
+            self.known.insert((scope, depth), complete);
+        }
+        complete
+    }
+
+    fn complete_dependencies(
+        &mut self,
+        b: &mut Builder,
+        dependencies: Vec<Dependency>,
+        depth: usize,
+        steps: &mut usize,
+    ) -> bool {
+        dependencies.into_iter().all(|dependency| match dependency {
+            Dependency::Scope(s) => self.scope_inner(b, s, depth + 1, steps),
+            Dependency::Recursive(s, all) => self.recursive_scope(b, s, depth + 1, all, steps),
+            Dependency::Package(s) => self.package_scope(b, s, depth + 1, None, steps),
+        })
+    }
+
+    fn reference(b: &mut Builder, relationship: usize, key: &str) -> Option<usize> {
+        let id = b.elements[relationship].props.get(key)?.as_reference()?;
+        b.element_index_of_uuid(id)
+    }
+
+    fn dependencies(
+        &mut self,
+        b: &mut Builder,
+        scope: usize,
+        depth: usize,
+        literal_package: bool,
+        steps: &mut usize,
+    ) -> Option<Vec<Dependency>> {
+        if b.metadata_associations_incomplete {
+            return None;
+        }
+        if self
+            .recursive_import_domains
+            .as_ref()
+            .is_some_and(|domains| !domains.localized())
+        {
+            return None;
+        }
+        let context = &b.scopes[scope];
+        let inverse_recursive = context.owner.is_some_and(|owner| {
+            self.recursive_import_domains
+                .as_ref()
+                .is_some_and(|domains| domains.recursive_owner(owner))
+        });
+        self.recursive.touched |= inverse_recursive;
+        if context.owner.is_some_and(|owner| {
+            self.recursive_import_domains
+                .as_ref()
+                .is_some_and(|domains| !domains.owner_complete(owner))
+        }) {
+            return None;
+        }
+        let relationships = context
+            .owner
+            .map_or(0, |e| b.elements[e].owned_relationships.len());
+        *steps = steps
+            .saturating_add(relationships)
+            .saturating_add(context.imports.len())
+            .saturating_add(context.member_imports.len())
+            .saturating_add(context.aliases.len())
+            .saturating_add(context.bases.len())
+            .saturating_add(context.implied_bases.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        // Chains and filters need a richer proof. No
+        // inference is preferable to treating skipped results as absence.
+        if !context.filters.is_empty()
+            || !context.chain_bases.is_empty()
+            || context.imports.iter().any(|i| !i.filters.is_empty())
+            || context.member_imports.iter().any(|i| !i.filters.is_empty())
+        {
+            return None;
+        }
+        let owner = context.owner;
+        if owner.is_some_and(|owner| {
+            !b.dynamic_evidence_current(owner) || !b.result_redefinition_evidence_current(owner)
+        }) {
+            return None;
+        }
+        // Semantic metadata may add bases that the current resolver omits when
+        // an annotation is incomplete. Their absence needs a separate proof.
+        if owner.is_some_and(|e| b.metadata_of.get(&e).is_some_and(|m| !m.is_empty())) {
+            return None;
+        }
+        let annotations = self.annotations.as_ref()?;
+        if !annotations.is_current(b)
+            || !annotations.ids_unique
+            || annotations.annotations_incomplete
+            || owner.is_some_and(|e| annotations.metadata_annotation_targets.contains(&e))
+        {
+            // Annotation-dependent supertype absence is not implemented. A
+            // separately witnessed positive path remains usable by callers.
+            return None;
+        }
+        let namespaces: Vec<_> = context
+            .imports
+            .iter()
+            .enumerate()
+            .map(|(i, entry)| (i, entry.relationship, entry.recursive))
+            .collect();
+        let members: Vec<_> = context
+            .member_imports
+            .iter()
+            .map(|i| i.relationship)
+            .collect();
+        let aliases: Vec<_> = context.aliases.iter().map(|(_, _, r)| *r).collect();
+        let relationships = owner
+            .map(|e| b.elements[e].owned_relationships.clone())
+            .unwrap_or_default();
+        let mut dependencies = Vec::new();
+        let mut recursive_domain = literal_package
+            || inverse_recursive
+            || namespaces.iter().any(|&(_, _, recursive)| recursive);
+        for r in relationships {
+            if conforms(b.elements[r].ty, "Import")
+                && b.elements[r]
+                    .props
+                    .get("isRecursive")
+                    .is_some_and(|v| v.as_bool() != Some(false))
+            {
+                recursive_domain = true;
+            }
+            if conforms(b.elements[r].ty, "Specialization") {
+                let id = super::implied::specialization_target(&b.elements[r])?;
+                let target = b.element_index_of_uuid(id)?;
+                if !conforms(b.elements[target].ty, "Type") {
+                    return None;
+                }
+                dependencies.push(Dependency::Scope(*b.elem_scope.get(&target)?));
+            }
+        }
+        if recursive_domain {
+            self.recursive.touched = true;
+            self.recursive_import_domain(b, scope, depth, literal_package, steps)?;
+        }
+        for (index, r, recursive) in namespaces {
+            if recursive_domain {
+                let (target, all) = self.literal_namespace_import(b, scope, index, depth, steps)?;
+                dependencies.push(if recursive {
+                    Dependency::Recursive(target, all)
+                } else {
+                    Dependency::Package(target)
+                });
+                continue;
+            }
+            // A stale resolver entry cannot erase a raw recursive obligation.
+            if b.elements[r]
+                .props
+                .get("isRecursive")
+                .is_some_and(|v| v.as_bool() != Some(false))
+            {
+                return None;
+            }
+            let target = Self::reference(b, r, "importedNamespace")?;
+            if !conforms(b.elements[target].ty, "Namespace") {
+                return None;
+            }
+            dependencies.push(Dependency::Scope(*b.elem_scope.get(&target)?));
+        }
+        for r in members {
+            let membership = Self::reference(b, r, "importedMembership")?;
+            if !conforms(b.elements[membership].ty, "Membership") {
+                return None;
+            }
+            b.stored_membership_member(membership)?;
+            // A membership import contributes this exact member, not its
+            // declaring namespace's unrelated imports or other members.
+        }
+        for alias in aliases {
+            b.stored_membership_member(alias)?;
+        }
+        let bases = bounded_base_scopes(b, scope, steps);
+        if bases.is_none() && b.base_cache[scope].is_none() {
+            // Later resolver warming can supply the missing identity evidence.
+            // Do not freeze this coverage limitation as a negative scope memo.
+            self.transient_incomplete = true;
+        }
+        dependencies.extend(bases?.into_iter().map(Dependency::Scope));
+        *steps = steps.saturating_add(
+            dependencies
+                .len()
+                .saturating_mul(dependencies.len().max(1).ilog2() as usize + 2),
+        );
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        dependencies.sort_unstable();
+        dependencies.dedup();
+        Some(dependencies)
+    }
+}
+
+/// Reuse completed resolver evidence without entering its unbudgeted cold
+/// name walk. Cold semantic bases use the shared stored/retained identity graph.
+/// A non-library implied base the resolver alone reads has no such
+/// certificate; an uncached context requiring it remains unsupported.
+fn bounded_base_scopes(b: &mut Builder, scope: usize, steps: &mut usize) -> Option<Vec<usize>> {
+    if let Some((cached, _)) = &b.base_cache[scope] {
+        *steps = steps.saturating_add(cached.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        return bounded_dynamic_base_scopes(b, scope, cached.clone(), steps);
+    }
+    let context = &b.scopes[scope];
+    if context.bases.is_empty() && context.implied_bases.is_empty() {
+        return bounded_dynamic_base_scopes(b, scope, Vec::new(), steps);
+    }
+    if context
+        .implied_bases
+        .iter()
+        .any(|name| name.segments.len() < 2)
+    {
+        return None;
+    }
+    let owner = context.owner?;
+    let bases = b.semantic_inheritance_bases(owner, b.semantic_ready, steps)?;
+    *steps = steps.saturating_add(bases.len());
+    if *steps > crate::eval::MAX_STEPS {
+        return None;
+    }
+    let scopes = bases
+        .into_iter()
+        .filter_map(|base| b.elem_scope.get(&base).copied())
+        .filter(|&base| base != scope)
+        .collect();
+    bounded_dynamic_base_scopes(b, scope, scopes, steps)
+}
+
+/// Overlay only admitted dynamic dependencies. Cached resolver inputs stay
+/// static; missing target scopes cannot certify an empty provider dependency.
+fn bounded_dynamic_base_scopes(
+    b: &Builder,
+    scope: usize,
+    mut bases: Vec<usize>,
+    steps: &mut usize,
+) -> Option<Vec<usize>> {
+    let Some(owner) = b.scopes.get(scope)?.owner else {
+        return Some(bases);
+    };
+    if !b.dynamic_evidence_current(owner) {
+        return None;
+    }
+    let Some(plan) = b.effective_dynamic_plan() else {
+        return Some(bases);
+    };
+    let added = plan
+        .added_bases
+        .get(&owner)
+        .map(Vec::as_slice)
+        .unwrap_or(&[]);
+    *steps = steps.saturating_add(added.len());
+    if *steps > crate::eval::MAX_STEPS {
+        return None;
+    }
+    for &target in added {
+        *steps = steps.saturating_add(2).saturating_add(bases.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        if !crate::metaclass::conforms(b.elements.get(target)?.ty, "Type") {
+            return None;
+        }
+        let target_scope = *b.elem_scope.get(&target)?;
+        if b.scopes.get(target_scope)?.owner != Some(target) {
+            return None;
+        }
+        if target_scope != scope && !bases.contains(&target_scope) {
+            bases.push(target_scope);
+        }
+    }
+    Some(bases)
+}
+
+/// Account for every saved provenance allocation before changing lookup state.
+fn charge_provenance(b: &Builder, steps: &mut usize) -> bool {
+    *steps = steps
+        .saturating_add(b.used_imports.capacity())
+        .saturating_add(b.current_misses.len())
+        .saturating_add(b.root_misses.capacity());
+    if *steps > crate::eval::MAX_STEPS {
+        return false;
+    }
+    for text in b.current_misses.iter().chain(b.root_misses.iter()) {
+        *steps = steps.saturating_add(text.len());
+        if *steps > crate::eval::MAX_STEPS {
+            return false;
+        }
+    }
+    true
+}
+
+/// Proofs may warm resolver caches, but must not change the caller's lookup
+/// context or import-use/miss provenance. Stabilize implied planning first.
+fn neutral<T>(b: &mut Builder, f: impl FnOnce(&mut Builder) -> T) -> T {
+    let saved = (
+        b.exclude.take(),
+        std::mem::replace(&mut b.declared_only, false),
+        b.redefinition_lookup_owner.take(),
+        b.redefinition_lookup_base.take(),
+        std::mem::replace(&mut b.recorded_lookup_suppressed, false),
+        b.identity_origin_unit,
+        std::mem::replace(&mut b.probing, false),
+        b.widen.take(),
+    );
+    let used = b.used_imports.clone();
+    let imports = std::mem::take(&mut b.query_imports);
+    let misses = b.current_misses.clone();
+    let roots = b.root_misses.clone();
+    let result = f(b);
+    (
+        b.exclude,
+        b.declared_only,
+        b.redefinition_lookup_owner,
+        b.redefinition_lookup_base,
+        b.recorded_lookup_suppressed,
+        b.identity_origin_unit,
+        b.probing,
+        b.widen,
+    ) = saved;
+    b.used_imports = used;
+    b.query_imports = imports;
+    b.current_misses = misses;
+    b.root_misses = roots;
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::json::{LookupAccess, ResolvedModel};
+    use crate::model::Model;
+
+    #[test]
+    fn accepted_scope_dependencies_overlay_cold_and_cached_static_inputs_with_budget() {
+        for unsupported in [false, true] {
+            for warm in [false, true] {
+                let mut model = Model::new();
+                let body = if unsupported { "filter true;" } else { "" };
+                model.add_source("accepted-scope.kerml", &format!(
+                    "classifier Caller; classifier Callee {{{body}}} function F {{return result;}} feature call=F();"
+                ));
+                assert!(!model.has_errors());
+                let mut r = ResolvedModel::build(&model);
+                let caller = r.resolve_qualified("Caller").unwrap().0;
+                let callee = r.resolve_qualified("Callee").unwrap().0;
+                let scope = *r.b.elem_scope.get(&caller).unwrap();
+                let callee_scope = *r.b.elem_scope.get(&callee).unwrap();
+                let invocation = r
+                    .user_elements()
+                    .find(|&e| r.element_type(e) == "InvocationExpression")
+                    .unwrap();
+                r.implied_relationships(invocation);
+                assert!(r.b.effective_dynamic_plan().is_some());
+                // The parser currently gives Invocation no textual body scope.
+                // Exercise the accepted overlay seam with real existing scopes;
+                // no scope is fabricated or added to production admission.
+                let snapshot = Arc::make_mut(r.b.dynamic_graph.as_mut().unwrap());
+                let plan = Arc::make_mut(snapshot.plan.as_mut().unwrap());
+                plan.added_bases.insert(caller, vec![callee]);
+                plan.affected_owners.insert(caller);
+                assert!(r.b.scopes[scope].bases.is_empty());
+                // Isolate the otherwise-empty static-provider case after the
+                // accepted identity slice has been supplied by the test seam.
+                r.b.scopes[scope].implied_bases.clear();
+                r.b.base_cache[scope] = warm.then(|| (Vec::new(), 0));
+                let before = r.b.base_cache[scope].clone();
+                let mut near_limit = crate::eval::MAX_STEPS;
+                assert!(bounded_base_scopes(&mut r.b, scope, &mut near_limit).is_none());
+                assert!(near_limit > crate::eval::MAX_STEPS);
+                assert_eq!(r.b.base_cache[scope], before);
+                assert_eq!(
+                    bounded_base_scopes(&mut r.b, scope, &mut 0),
+                    Some(vec![callee_scope])
+                );
+                assert_eq!(r.b.base_cache[scope], before);
+                let mut proof = ProviderCompleteness::default();
+                let mut exhausted = crate::eval::MAX_STEPS;
+                assert!(!proof.scope(&mut r.b, scope, &mut exhausted));
+                assert_eq!(proof.scope(&mut r.b, scope, &mut 0), !unsupported);
+                assert_eq!(proof.scope(&mut r.b, scope, &mut 0), !unsupported);
+                assert_eq!(r.b.base_cache[scope], before);
+                let mut scopes = crate::layered::LayeredMap::default();
+                for (&element, &scope) in r.b.elem_scope.iter() {
+                    if element != callee {
+                        scopes.insert(element, scope);
+                    }
+                }
+                r.b.elem_scope = scopes;
+                assert!(bounded_base_scopes(&mut r.b, scope, &mut 0).is_none());
+            }
+        }
+    }
+
+    #[test]
+    fn held_provider_observes_retained_replacement_even_after_table_rebuild() {
+        let mut model = Model::new();
+        model.add_source("retained-provider.kerml", "classifier A;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let old = proof.retained_plan.clone().unwrap();
+        let state = proof.planner_state;
+        // Exercise retained-authority replacement independently of the public
+        // name setter's stronger central publication epoch invalidation.
+        r.b.supported_implied = None;
+        r.b.positional_redefinitions = None;
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert_eq!(
+            state,
+            Some((r.b.semantic_ready, r.b.positional_redefinitions.is_some()))
+        );
+        assert!(!Arc::ptr_eq(&old, r.b.supported_implied.as_ref().unwrap()));
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert!(!proof.scope(&mut r.b, scope, &mut steps));
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(Arc::ptr_eq(&old, proof.retained_plan.as_ref().unwrap()));
+        assert_eq!(proof.planner_state, state);
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        assert!(Arc::ptr_eq(
+            proof.retained_plan.as_ref().unwrap(),
+            r.b.supported_implied.as_ref().unwrap()
+        ));
+    }
+
+    #[test]
+    fn held_provider_refuses_a_new_publication_epoch_without_refreshing_old_facts() {
+        let mut model = Model::new();
+        model.add_source("provider-epoch.kerml", "classifier A;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let old = proof.retained_plan.clone().unwrap();
+        let epoch = proof.publication.clone().unwrap();
+        r.set_library_names(&HashMap::new());
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert!(!proof.scope(&mut r.b, scope, &mut steps));
+        assert_eq!(steps, crate::eval::MAX_STEPS - 1);
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        assert!(Arc::ptr_eq(&old, proof.retained_plan.as_ref().unwrap()));
+        assert!(epoch.same_as(proof.publication.as_ref().unwrap()));
+        assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    }
+
+    #[test]
+    fn positive_provider_does_not_accept_a_legacy_in_progress_sentinel() {
+        let mut model = Model::new();
+        model.add_source("sentinel.kerml", "classifier A;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let plan = r.b.positional_redefinitions.replace(Default::default());
+        r.b.positional_planning = true;
+        assert!(!r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&true));
+        r.b.positional_planning = false;
+        r.b.positional_redefinitions = plan;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+
+    #[test]
+    fn held_provider_charges_invalidation_before_discarding_cached_scopes() {
+        let mut model = Model::new();
+        let mut source = "classifier Root;".to_string();
+        for n in 0..40 {
+            source.push_str(&format!(" classifier C{n} specializes Root;"));
+        }
+        model.add_source("invalidation.kerml", &source);
+        let mut r = ResolvedModel::build(&model);
+        let mut proof = ProviderCompleteness::default();
+        let mut last = 0;
+        for n in 0..40 {
+            let owner = r.resolve_qualified(&format!("C{n}")).unwrap().0;
+            last = *r.b.elem_scope.get(&owner).unwrap();
+            assert!(proof.scope(&mut r.b, last, &mut 0));
+        }
+        let entries = proof.known.len();
+        assert!(entries >= 40);
+        let planner_state = proof.planner_state;
+        r.b.positional_redefinitions = None;
+        let mut steps = crate::eval::MAX_STEPS - 3;
+        assert!(!proof.scope(&mut r.b, last, &mut steps));
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert_eq!(proof.planner_state, planner_state);
+        assert_eq!(
+            proof.known.len(),
+            entries,
+            "refused clear leaves old facts inaccessible for retry"
+        );
+        assert!(proof.scope(&mut r.b, last, &mut 0));
+        let metadata = proof.metadata_generation.clone();
+        r.b.metadata_association_generation = Some(Arc::new(()));
+        let entries = proof.known.len();
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(!proof.scope(&mut r.b, last, &mut steps));
+        assert_eq!(proof.known.len(), entries);
+        assert!(match (&metadata, &proof.metadata_generation) {
+            (None, None) => true,
+            (Some(a), Some(b)) => Arc::ptr_eq(a, b),
+            _ => false,
+        });
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(proof.scope(&mut r.b, last, &mut 0));
+    }
+
+    #[test]
+    fn cold_identity_bases_match_warm_explicit_redefinition_and_library_providers() {
+        for (source, name) in [
+            ("classifier A; classifier B specializes A;", "B"),
+            ("feature A; feature B redefines A;", "B"),
+            ("class C;", "C"),
+        ] {
+            let mut model = Model::new();
+            model.add_library_source(
+                "provider-library.kerml",
+                "standard library package Occurrences {class Occurrence;}",
+            );
+            assert!(
+                model
+                    .add_source("provider-bases.kerml", source)
+                    .diagnostics
+                    .is_empty()
+            );
+            let mut r = ResolvedModel::build(&model);
+            let owner = r.resolve_qualified(name).unwrap().0;
+            let scope = *r.b.elem_scope.get(&owner).unwrap();
+            r.b.base_cache.fill(None);
+            let cold = ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0);
+            assert!(cold, "{source}");
+            assert!(r.b.base_cache[scope].is_none());
+            r.b.base_scopes_split(scope);
+            let warm = ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0);
+            assert_eq!(cold, warm, "{source}");
+        }
+    }
+
+    #[test]
+    fn cold_resolver_only_base_is_not_a_semantic_certificate() {
+        let mut model = Model::new();
+        model.add_source(
+            "parameter-context.kerml",
+            "function A {in p;} function B specializes A {in p;}",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let p = r.resolve_qualified("B::p").unwrap().0;
+        let scope = *r.b.elem_scope.get(&p).unwrap();
+        // Lowering records no non-library implied base of its own any more;
+        // install precisely the resolver-only input whose cold proof is
+        // unsupported.
+        r.b.scopes[scope].implied_bases = vec![super::super::lib_qn("p")];
+        r.b.base_cache[scope] = None;
+        let mut proof = ProviderCompleteness::default();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        assert!(!proof.known.contains_key(&(scope, 0)));
+        assert!(r.b.base_cache[scope].is_none());
+        // A completed lookup supplies concrete scopes whose raw dependencies
+        // still receive the ordinary provider checks; no empty sentinel is used.
+        r.b.base_scopes_split(scope);
+        let cached = r.b.base_cache[scope].as_ref().unwrap().0.clone();
+        let mut steps = 0;
+        assert_eq!(
+            bounded_base_scopes(&mut r.b, scope, &mut steps),
+            Some(cached)
+        );
+    }
+
+    #[test]
+    fn cold_preparation_refuses_without_a_partial_table_and_retries() {
+        let mut model = Model::new();
+        model.add_source(
+            "cold.kerml",
+            "function A {in x; return y;} function B specializes A {in x; return y;}",
+        );
+        let mut r = ResolvedModel::build(&model);
+        let owner = r.resolve_qualified("B").unwrap().0;
+        let scope = *r.b.elem_scope.get(&owner).unwrap();
+        r.b.positional_redefinitions = None;
+        r.b.base_cache[scope] = None;
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.prepare_annotations(&mut r.b, &mut 0));
+        r.b.used_imports.insert(owner);
+        r.b.current_misses.push("caller".into());
+        let mut steps = crate::eval::MAX_STEPS - 12;
+        assert!(!proof.scope(&mut r.b, scope, &mut steps));
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(r.b.positional_redefinitions.is_none());
+        assert!(!r.b.positional_planning);
+        assert!(proof.known.is_empty());
+        assert_eq!(r.b.current_misses, ["caller"]);
+        assert!(r.b.used_imports.contains(&owner));
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let plan = r.b.positional_redefinitions.as_ref().unwrap();
+        assert!(!plan.targets.is_empty());
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&true));
+        assert!(
+            r.b.base_cache[scope].is_none(),
+            "bounded proof does not run the cold resolver"
+        );
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+
+    #[test]
+    fn private_planner_guard_prevents_legacy_reentry_and_preserves_readiness() {
+        let mut model = Model::new();
+        model.add_source("guard.kerml", "function A {in x; return y;}");
+        let mut r = ResolvedModel::build(&model);
+        r.b.positional_redefinitions = None;
+        r.b.positional_planning = true;
+        r.b.ensure_positional_redefinitions();
+        assert!(!r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(r.b.positional_redefinitions.is_none());
+        r.b.positional_planning = false;
+        r.b.semantic_ready = false;
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(r.b.positional_redefinitions.is_none());
+        r.b.semantic_ready = true;
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(r.b.positional_redefinitions.is_some());
+    }
+
+    #[test]
+    fn exhausted_dependency_proof_can_retry_with_a_fresh_budget() {
+        let mut model = Model::new();
+        model.add_source("retry.kerml", "classifier A; classifier B specializes A;");
+        let mut r = ResolvedModel::build(&model);
+        let b = r.resolve_qualified("B").unwrap().0;
+        let scope = *r.b.elem_scope.get(&b).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        let mut steps = crate::eval::MAX_STEPS - 1;
+        assert!(!proof.scope(&mut r.b, scope, &mut steps));
+        assert!(steps > crate::eval::MAX_STEPS);
+        assert!(!proof.known.contains_key(&(scope, 0)));
+        steps = 0;
+        assert!(proof.scope(&mut r.b, scope, &mut steps));
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&true));
+    }
+
+    #[test]
+    fn cold_and_memoized_proofs_preserve_context_and_obey_budget() {
+        let mut model = Model::new();
+        let unit = model.add_source(
+            "providers.kerml",
+            "package Good { feature n = 4; }
+             type Complete { public import Good::*; }
+             type Missing { public import Absent::*; }",
+        );
+        assert!(unit.diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&model);
+        let complete = r.resolve_qualified("Complete").unwrap().0;
+        let missing = r.resolve_qualified("Missing").unwrap().0;
+        let b = &mut r.b;
+        let complete_scope = *b.elem_scope.get(&complete).unwrap();
+        let missing_scope = *b.elem_scope.get(&missing).unwrap();
+        b.exclude = Some(complete);
+        b.declared_only = true;
+        b.redefinition_lookup_owner = Some(complete);
+        b.redefinition_lookup_base = Some(missing);
+        b.recorded_lookup_suppressed = true;
+        b.identity_origin_unit = Some(0);
+        b.probing = true;
+        b.widen = Some((complete_scope, LookupAccess::All));
+        b.used_imports.insert(complete);
+        b.query_imports.push((missing, LookupAccess::All));
+        b.current_misses.push("caller miss".into());
+        b.root_misses.insert("caller root".into());
+        let context = |b: &Builder| {
+            (
+                b.exclude,
+                b.declared_only,
+                b.redefinition_lookup_owner,
+                b.redefinition_lookup_base,
+                b.recorded_lookup_suppressed,
+                b.identity_origin_unit,
+                b.probing,
+                b.widen,
+                b.used_imports.clone(),
+                b.query_imports.clone(),
+                b.current_misses.clone(),
+                b.root_misses.clone(),
+            )
+        };
+        let before = context(b);
+        let mut proof = ProviderCompleteness::default();
+        let mut steps = 0;
+        for (scope, expected) in [
+            (complete_scope, true),
+            (missing_scope, false),
+            (complete_scope, true),
+            (missing_scope, false),
+        ] {
+            assert_eq!(proof.scope(b, scope, &mut steps), expected);
+            assert_eq!(context(b), before);
+            assert!(proof.active.is_empty());
+        }
+        steps = crate::eval::MAX_STEPS;
+        assert!(!proof.scope(b, complete_scope, &mut steps));
+        assert_eq!(context(b), before);
+        assert_eq!(steps, crate::eval::MAX_STEPS + 1);
+    }
+}
+
+#[cfg(test)]
+mod annotation_completeness_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    #[test]
+    fn duplicate_loaded_identities_refuse_absence_until_repaired() {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("identities.kerml", "class A; class B; class C;")
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let original = r.b.elements[c].id;
+        r.b.elements[c].id = r.b.elements[b].id;
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[c].id = original;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+
+    #[test]
+    fn warm_scope_proof_observes_annotation_retarget_and_repair() {
+        let mut model = Model::new();
+        let p = model.add_source(
+            "annotation-lifecycle.kerml",
+            "metaclass M; classifier A; classifier B; @M about B;",
+        );
+        assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let scope = *r.b.elem_scope.get(&a).unwrap();
+        let rel =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "Annotation")
+                .unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&true));
+        let before = Arc::clone(proof.annotations.as_ref().unwrap());
+        let owner = before.carrier(&r.b, rel).unwrap().unwrap();
+        let source_id = r.b.elements[owner].id;
+        let target_id = r.b.elements[a].id;
+        let original = r.b.elements[rel].props.clone();
+        r.b.elements[rel].props.insert(
+            "annotatedElement",
+            serde_json::json!({"@id":target_id.to_string()}),
+        );
+        r.b.elements[rel]
+            .props
+            .insert("target", serde_json::json!([{"@id":target_id.to_string()}]));
+        r.b.elements[rel].props.insert(
+            "relatedElement",
+            serde_json::json!([{"@id":source_id.to_string()}, {"@id":target_id.to_string()}]),
+        );
+        // A warm positive memo may not survive a same-length annotation mutation.
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        let after = proof.annotations.as_ref().unwrap();
+        assert!(!Arc::ptr_eq(&before, after));
+        assert!(!after.annotations_incomplete);
+        assert!(after.metadata_annotation_targets.contains(&a));
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&false));
+        r.b.elements[rel].props = original;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(!proof.scope(&mut r.b, scope, &mut exhausted));
+        assert!(
+            !proof
+                .annotations
+                .as_ref()
+                .is_some_and(|index| index.is_current(&r.b))
+        );
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        assert_eq!(proof.known.get(&(scope, 0)), Some(&true));
+        assert!(
+            !proof
+                .annotations
+                .as_ref()
+                .unwrap()
+                .metadata_annotation_targets
+                .contains(&a)
+        );
+    }
+}
+
+#[cfg(test)]
+mod annotation_budget_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn repeated_fresh_providers_share_annotation_topology_under_one_near_limit_budget() {
+        let mut model = Model::new();
+        let mut source = String::from("class Target;");
+        for i in 0..5000 {
+            source.push_str(&format!("class Padding{i};"));
+        }
+        let parsed = model.add_source("provider-cost.kerml", &source);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let target = r.resolve_qualified("Target").unwrap().0;
+        let scope = *r.b.elem_scope.get(&target).unwrap();
+        assert!(r.b.elements.len() > 10_000);
+        let mut cold = 0;
+        assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut cold));
+        assert!(
+            cold >= r.b.elements.len(),
+            "cold construction remains charged"
+        );
+        let shared = r.b.stored_structure.as_ref().unwrap().clone();
+        let reads = 500;
+        let start = crate::eval::MAX_STEPS - reads * 8;
+        let mut steps = start;
+        for _ in 0..reads {
+            // Mirrors parameter_context's new provider per argument-target query.
+            assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut steps));
+            assert!(Arc::ptr_eq(&shared, r.b.stored_structure.as_ref().unwrap()));
+        }
+        assert!(
+            steps - start <= reads * 8,
+            "cached raw topology must not spend model size per call"
+        );
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(!ProviderCompleteness::default().scope(&mut r.b, scope, &mut exhausted));
+        assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/provider_completeness/mixed_tests.rs b/crates/sysmlv2-model/src/json/provider_completeness/mixed_tests.rs
new file mode 100644
index 0000000..dbd4c3d
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/provider_completeness/mixed_tests.rs
@@ -0,0 +1,244 @@
+use super::{recursive_tests::fixture, *};
+const TREE: &str = "package Tree {package Nested {alias Leaf for $::Marker;}} package Extra {alias Added for $::Other;}";
+
+#[test]
+fn mixed_recursive_and_ordinary_imports_preserve_member_and_namespace_lookup() {
+    for ordinary in ["$::Other", "$::Extra::*", "$::Extra::**", "$::Extra::*::**"] {
+        for recursive in ["$::Tree::**", "$::Tree::*::**"] {
+            let import = format!("{recursive}; private import {ordinary}");
+            let (mut r, scope) = fixture(TREE, &import);
+            let marker = r.resolve_qualified("Marker").unwrap().0;
+            let other = r.resolve_qualified("Other").unwrap().0;
+            let mut proof = ProviderCompleteness::default();
+            r.b.import_cache[scope] = None;
+            let used = r.b.used_imports.clone();
+            assert!(proof.scope(&mut r.b, scope, &mut 0), "{import}");
+            assert!(r.b.import_cache[scope].is_none());
+            assert_eq!(r.b.used_imports, used);
+            assert_eq!(r.b.lookup(scope, "Leaf", 0).map(|v| v.0), Some(marker));
+            let added = if ordinary == "$::Other" {
+                "Other"
+            } else {
+                "Added"
+            };
+            assert_eq!(r.b.lookup(scope, added, 0).map(|v| v.0), Some(other));
+            let mut exhausted = crate::eval::MAX_STEPS;
+            assert!(!proof.scope(&mut r.b, scope, &mut exhausted));
+            assert!(proof.scope(&mut r.b, scope, &mut 0));
+        }
+    }
+}
+
+#[test]
+fn recursive_package_contents_admit_acyclic_internal_imports_and_global_aliases() {
+    for internal in [
+        "$::Marker",
+        "$::Relay::*",
+        "$::Relay::**",
+        "$::Relay::*::**",
+    ] {
+        let tree = format!(
+            "package Relay {{alias Imported for $::Marker;}} package Tree {{alias Local for $::Other; public import {internal};}}"
+        );
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        let marker = r.resolve_qualified("Marker").unwrap().0;
+        let other = r.resolve_qualified("Other").unwrap().0;
+        assert!(
+            ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            "{internal}"
+        );
+        let name = if internal == "$::Marker" {
+            "Marker"
+        } else {
+            "Imported"
+        };
+        assert_eq!(r.b.lookup(scope, name, 0).map(|v| v.0), Some(marker));
+        assert_eq!(r.b.lookup(scope, "Local", 0).map(|v| v.0), Some(other));
+    }
+    let (mut r, scope) = fixture(
+        "package Relay {alias Imported for $::Marker;} package Tree {private import $::Relay::*;}",
+        "$::Tree::*::**",
+    );
+    assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    assert!(r.b.lookup(scope, "Imported", 0).is_none());
+    let (mut r, scope) = fixture(
+        "package Relay {alias Imported for $::Marker;} package Tree {private import $::Relay::*;}",
+        "all $::Tree::*::**",
+    );
+    assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    assert!(r.b.lookup(scope, "Imported", 0).is_some());
+}
+
+#[test]
+fn ordinary_imports_in_recursive_domains_require_complete_current_mirrors_and_raw_rows() {
+    for ordinary in ["$::Other", "$::Extra::*"] {
+        let (mut r, scope) = fixture(TREE, &format!("$::Tree::*::**; private import {ordinary}"));
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let namespaces = r.b.scopes[scope].imports.clone();
+        let members = r.b.scopes[scope].member_imports.clone();
+        let relationship = if ordinary == "$::Other" {
+            r.b.scopes[scope].member_imports.pop().unwrap().relationship
+        } else {
+            r.b.scopes[scope].imports.pop().unwrap().relationship
+        };
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].imports = namespaces.clone();
+        r.b.scopes[scope].member_imports = members.clone();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let owner = r.b.scopes[scope].owner.unwrap();
+        let relationships = r.b.elements[owner].owned_relationships.clone();
+        r.b.elements[owner].owned_relationships = relationships
+            .iter()
+            .copied()
+            .filter(|&r| r != relationship)
+            .collect();
+        r.b.scopes[scope]
+            .imports
+            .retain(|entry| entry.relationship != relationship);
+        r.b.scopes[scope]
+            .member_imports
+            .retain(|entry| entry.relationship != relationship);
+        r.b.import_cache[scope] = None;
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[owner].owned_relationships = relationships;
+        r.b.scopes[scope].imports = namespaces;
+        r.b.scopes[scope].member_imports = members;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[relationship]
+            .props
+            .insert("isRecursive", serde_json::json!(true));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[relationship]
+            .props
+            .insert("isRecursive", serde_json::json!(false));
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.import_scopes(scope);
+        let cache = r.b.import_cache[scope].clone();
+        r.b.import_cache[scope] = Some(std::sync::Arc::new(vec![]));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.import_cache[scope] = cache;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+}
+
+#[test]
+fn ordinary_package_visits_do_not_certify_recursive_children_or_cache_unsupported_aliases() {
+    // Both dependency kinds visit Tree. Its child is irrelevant to ordinary
+    // lookup but requires a separate recursive certificate, in either order.
+    for imports in [
+        "$::Tree::*; private import $::Tree::*::**",
+        "$::Tree::*::**; private import $::Tree::*",
+    ] {
+        let (mut r, scope) = fixture(
+            "package Tree {package Nested {alias Leaf for Missing;}}",
+            imports,
+        );
+        assert!(!ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    }
+    for tree in [
+        "package Tree {public import $::Tree::*;}",
+        "package Tree {public import $::Relay::*;} package Relay {public import $::Tree::*;}",
+        "package Tree {package Child {public import $::Tree::*;}}",
+        "package Tree {public import $::Relay::*;} package Relay {alias Leaf for Marker;}",
+        "package Tree {public import $::Relay::*;} package Relay {filter true;}",
+        "package Tree {public import Relay::*;} package Relay {alias Leaf for $::Marker;}",
+    ] {
+        let (mut r, scope) = fixture(tree, "$::Tree::*::**");
+        assert!(
+            !ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            "{tree}"
+        );
+    }
+}
+
+#[test]
+fn internal_import_depth_and_diamond_ambiguity_match_lookup() {
+    for hops in [0, 20, 21, 22, 23] {
+        let mut tree = "package Tree {public import $::P0::*;}".to_owned();
+        for i in 0..hops {
+            tree.push_str(&format!("package P{i} {{public import $::P{}::*;}}", i + 1));
+        }
+        tree.push_str(&format!("package P{hops} {{alias Leaf for $::Marker;}}"));
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        let expected = hops <= crate::json::MAX_RESOLUTION_DEPTH - 3;
+        assert_eq!(
+            ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            expected,
+            "hops={hops}"
+        );
+        assert_eq!(
+            r.b.lookup(scope, "Leaf", 0).is_some(),
+            expected,
+            "lookup hops={hops}"
+        );
+    }
+    for same in [true, false] {
+        let tree = format!(
+            "package End {{alias Leaf for $::Marker;}} package OtherEnd {{alias Leaf for $::Other;}} package Left {{public import $::End::*;}} package Right {{public import $::{}::*;}} package Tree {{public import $::Left::*; public import $::Right::*;}}",
+            if same { "End" } else { "OtherEnd" }
+        );
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+        assert_eq!(r.b.lookup(scope, "Leaf", 0).is_some(), same);
+    }
+}
+
+#[test]
+fn completed_ordinary_package_memos_cannot_hide_recursive_children_or_active_cycles() {
+    for tree in [
+        "package Tree {package Nested {alias Leaf for Missing;}}",
+        "package Tree {package Child {public import $::Tree::*;}}",
+    ] {
+        let (mut r, scope) = fixture(tree, "$::Tree::*");
+        let owner = r.resolve_qualified("Tree").unwrap().0;
+        let tree_scope = *r.b.elem_scope.get(&owner).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        assert!(proof.package_scope(&mut r.b, tree_scope, 0, None, &mut 0));
+        // Child imports Tree at depth two. Prime that exact memo key so the
+        // active-cycle guard, rather than a cache miss, must reject the route.
+        assert!(proof.package_scope(&mut r.b, tree_scope, 2, None, &mut 0));
+        assert!(
+            !proof.package_scope(&mut r.b, tree_scope, 0, Some(false), &mut 0),
+            "{tree}"
+        );
+    }
+}
+
+#[test]
+fn ordinary_membership_imports_preserve_dynamic_qualified_depth_and_current_target() {
+    for hops in [19, 20, 21, 22] {
+        let mut tree =
+            "package Definitions {class Target;} package Tree {public import $::P0::*;}".to_owned();
+        for i in 0..hops {
+            tree.push_str(&format!("package P{i} {{public import $::P{}::*;}}", i + 1));
+        }
+        tree.push_str(&format!(
+            "package P{hops} {{public import $::Definitions::Target;}}"
+        ));
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        assert_eq!(
+            ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            hops <= 20,
+            "proof hops={hops}"
+        );
+        assert_eq!(
+            r.b.lookup(scope, "Target", 0).is_some(),
+            hops <= 20,
+            "lookup hops={hops}"
+        );
+    }
+    let (mut r, scope) = fixture(TREE, "$::Tree::*::**; private import $::Other");
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let member = r.b.scopes[scope].member_imports[0].clone();
+    r.b.scopes[scope].member_imports[0].target.segments[0].value = "Marker".to_owned();
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.scopes[scope].member_imports[0] = member.clone();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    r.b.scopes[scope].member_imports[0].is_public = !member.is_public;
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.scopes[scope].member_imports[0] = member;
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
diff --git a/crates/sysmlv2-model/src/json/provider_completeness/recursive.rs b/crates/sysmlv2-model/src/json/provider_completeness/recursive.rs
new file mode 100644
index 0000000..235f7da
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/provider_completeness/recursive.rs
@@ -0,0 +1,519 @@
+//! Recursive lookup certificates for literal named package trees.
+use super::{Builder, ProviderCompleteness};
+use crate::json::{Binding, LookupAccess, structural_index::StoredStructure};
+use crate::metaclass::conforms;
+use std::{collections::HashMap, sync::Arc};
+
+mod qualified;
+
+type RootNames = (Arc<StoredStructure>, HashMap<String, Vec<usize>>);
+
+#[derive(Default)]
+pub(super) struct Proof {
+    pub touched: bool,
+    known: HashMap<(usize, usize, Option<bool>), bool>,
+    // Raw declaration names only, never lookup outcomes. Revalidated against
+    // current bindings on every use, and rebuilt after any element mutation.
+    roots: Option<RootNames>,
+    // Per-call raw owning declaration groups. Current bindings are still
+    // compared on every path; no semantic input survives a top-level call.
+    qualified: HashMap<usize, HashMap<String, Vec<Binding>>>,
+}
+fn charge(steps: &mut usize, n: usize) -> Option<()> {
+    *steps = steps.saturating_add(n);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+impl Proof {
+    pub(super) fn charge_roots_drop(&self, steps: &mut usize) -> Option<()> {
+        if let Some((_, names)) = &self.roots {
+            charge(steps, names.capacity())?;
+            for (name, members) in names {
+                charge(steps, name.len().saturating_add(members.len()))?;
+            }
+        }
+        Some(())
+    }
+    fn charge_qualified_drop(&self, steps: &mut usize) -> Option<()> {
+        charge(steps, self.qualified.capacity())?;
+        for names in self.qualified.values() {
+            charge(steps, names.capacity())?;
+            for (name, bindings) in names {
+                charge(steps, name.len().saturating_add(bindings.len()))?;
+            }
+        }
+        Some(())
+    }
+    pub(super) fn clear(&mut self, steps: &mut usize) -> bool {
+        if charge(steps, self.known.capacity()).is_none() {
+            return false;
+        }
+        if self.charge_qualified_drop(steps).is_none() {
+            return false;
+        }
+        self.qualified.clear();
+        self.known.clear();
+        // Involvement stays sticky: an early failure may still depend on a
+        // recursive resolver input even before that edge is visited again.
+        true
+    }
+}
+impl ProviderCompleteness {
+    pub(super) fn recursive_import_domain(
+        &mut self,
+        b: &Builder,
+        scope: usize,
+        depth: usize,
+        literal_package: bool,
+        steps: &mut usize,
+    ) -> Option<()> {
+        let context = b.scopes.get(scope)?;
+        let owner = context.owner?;
+        // Package aliases were already checked against complete raw Memberships.
+        // Other importing owners still need their own alias-domain certificate.
+        if !literal_package && !context.aliases.is_empty() {
+            return None;
+        }
+        let raw = Arc::clone(self.annotations.as_ref()?);
+        if !raw.import_domains(b, steps)?.owner_complete(owner) {
+            return None;
+        }
+        let cached = b.import_cache.get(scope)?.as_deref().map(Vec::as_slice);
+        charge(
+            steps,
+            cached
+                .map_or(0, |entries| entries.len())
+                .saturating_add(context.imports.len())
+                .saturating_add(context.member_imports.len()),
+        )?;
+        if cached.is_some_and(|entries| entries.len() != context.imports.len()) {
+            return None;
+        }
+        let mut namespaces = HashMap::new();
+        let mut members = HashMap::new();
+        let mut caches = HashMap::new();
+        for entry in &context.imports {
+            if namespaces.insert(entry.relationship, entry).is_some() {
+                return None;
+            }
+        }
+        for entry in &context.member_imports {
+            if members.insert(entry.relationship, entry).is_some() {
+                return None;
+            }
+        }
+        for entry in cached.unwrap_or(&[]) {
+            if caches.insert(entry.relationship, entry).is_some() {
+                return None;
+            }
+        }
+        charge(steps, b.elements[owner].owned_relationships.len())?;
+        for &relationship in &b.elements[owner].owned_relationships {
+            if !literal_package
+                && conforms(b.elements[relationship].ty, "Membership")
+                && !conforms(b.elements[relationship].ty, "OwningMembership")
+            {
+                return None;
+            }
+            if !conforms(b.elements[relationship].ty, "Import") {
+                continue;
+            }
+            let target = crate::json::import_memberships::checked_import_target(
+                b,
+                &raw,
+                owner,
+                relationship,
+                steps,
+            )?;
+            let public = b.elements[relationship]
+                .props
+                .get("visibility")
+                .and_then(|v| v.as_str())
+                == Some("public");
+            let mut mirrored = None;
+            if target.membership.is_some() {
+                let member = members.remove(&relationship)?;
+                if member.is_import_all != target.all
+                    || member.is_public != public
+                    || !member.filters.is_empty()
+                {
+                    return None;
+                }
+                if b.elements[target.element].owning_relationship != target.membership {
+                    return None;
+                }
+                if !target.recursive {
+                    self.direct_global_path(
+                        b,
+                        &raw,
+                        &member.target,
+                        target.element,
+                        b.unit_of_elem(relationship),
+                        depth + 1,
+                        steps,
+                    )?;
+                }
+                mirrored = Some(member);
+            }
+            if target.membership.is_none() || target.recursive {
+                let entry = namespaces.remove(&relationship)?;
+                if let Some(member) = mirrored {
+                    for segment in member.target.segments.iter().chain(&entry.target.segments) {
+                        charge(steps, segment.value.len().saturating_add(1))?;
+                    }
+                    if member.target != entry.target {
+                        return None;
+                    }
+                }
+                let cache = caches.remove(&relationship);
+                let target_scope = *b.elem_scope.get(&target.element)?;
+                if b.scopes.get(target_scope)?.owner != Some(target.element)
+                    || entry.recursive != target.recursive
+                    || entry.is_import_all != target.all
+                    || entry.is_public != public
+                    || !entry.filters.is_empty()
+                    || (cached.is_some() && cache.is_none())
+                    || cache.is_some_and(|cache| {
+                        cache.scope != target_scope
+                            || cache.recursive != target.recursive
+                            || cache.is_import_all != target.all
+                            || cache.is_public != public
+                            || !cache.filters.is_empty()
+                    })
+                {
+                    return None;
+                }
+            }
+        }
+        (namespaces.is_empty() && members.is_empty() && caches.is_empty()).then_some(())
+    }
+
+    pub(super) fn literal_namespace_import(
+        &mut self,
+        b: &Builder,
+        scope: usize,
+        index: usize,
+        depth: usize,
+        steps: &mut usize,
+    ) -> Option<(usize, bool)> {
+        self.recursive.touched = true;
+        let context = b.scopes.get(scope)?;
+        let entry = context.imports.get(index)?;
+        let owner = context.owner?;
+        let raw = Arc::clone(self.annotations.as_ref()?);
+        let target = crate::json::import_memberships::checked_import_target(
+            b,
+            &raw,
+            owner,
+            entry.relationship,
+            steps,
+        )?;
+        let public = b.elements[entry.relationship]
+            .props
+            .get("visibility")
+            .and_then(|v| v.as_str())
+            == Some("public");
+        if target.recursive != entry.recursive
+            || target.all != entry.is_import_all
+            || public != entry.is_public
+        {
+            return None;
+        }
+        // Namespace cache construction starts resolution at zero. The mirrored
+        // MembershipImport additionally resolves its selected member at the
+        // caller's depth + 1, which is the stricter bound.
+        let target_depth = if target.membership.is_some() {
+            depth + 1
+        } else {
+            0
+        };
+        self.direct_global_path(
+            b,
+            &raw,
+            &entry.target,
+            target.element,
+            b.unit_of_elem(entry.relationship),
+            target_depth,
+            steps,
+        )?;
+        if target
+            .membership
+            .is_some_and(|m| b.elements[target.element].owning_relationship != Some(m))
+        {
+            return None;
+        }
+        let target_scope = *b.elem_scope.get(&target.element)?;
+        if b.scopes.get(target_scope)?.owner != Some(target.element) {
+            return None;
+        }
+        // The whole entry/mirror/cache domain has already been checked once.
+        // Cold targets need no cache: all admitted target paths terminate in
+        // directly witnessed global bindings without invoking name resolution.
+        Some((target_scope, target.all))
+    }
+
+    pub(super) fn recursive_scope(
+        &mut self,
+        b: &mut Builder,
+        scope: usize,
+        depth: usize,
+        all: bool,
+        steps: &mut usize,
+    ) -> bool {
+        self.package_scope(b, scope, depth, Some(all), steps)
+    }
+
+    pub(super) fn package_scope(
+        &mut self,
+        b: &mut Builder,
+        scope: usize,
+        depth: usize,
+        recursive: Option<bool>,
+        steps: &mut usize,
+    ) -> bool {
+        self.recursive.touched = true;
+        if charge(steps, 1).is_none() || depth > crate::json::MAX_RESOLUTION_DEPTH {
+            return false;
+        }
+        let key = (scope, depth, recursive);
+        // A completed nonrecursive visit must not hide an active recursive
+        // route to the same scope. Cyclic providers need their own proof.
+        if self.active.contains(&scope) {
+            return false;
+        }
+        if let Some(&result) = self.recursive.known.get(&key) {
+            return result;
+        }
+        if !self.active.insert(scope) {
+            return false;
+        }
+        let complete = self
+            .recursive_children(b, scope, depth, recursive.unwrap_or(false), steps)
+            .is_some_and(|children| {
+                self.dependencies(b, scope, depth, true, steps)
+                    .is_some_and(|dependencies| {
+                        self.complete_dependencies(b, dependencies, depth, steps)
+                    })
+                    && recursive.is_none_or(|all| {
+                        children
+                            .into_iter()
+                            .all(|child| self.recursive_scope(b, child, depth + 1, all, steps))
+                    })
+            });
+        self.active.remove(&scope);
+        if *steps <= crate::eval::MAX_STEPS && (complete || !self.transient_incomplete) {
+            self.recursive.known.insert(key, complete);
+        }
+        complete
+    }
+
+    fn recursive_children(
+        &mut self,
+        b: &Builder,
+        scope: usize,
+        depth: usize,
+        all: bool,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        let context = b.scopes.get(scope)?;
+        let owner = context.owner?;
+        if !matches!(
+            b.elements.get(owner)?.ty,
+            "Namespace" | "Package" | "LibraryPackage"
+        ) || b.elem_scope.get(&owner) != Some(&scope)
+            || !context.filters.is_empty()
+            || !context.bases.is_empty()
+            || !context.implied_bases.is_empty()
+            || !context.chain_bases.is_empty()
+            || !context.implied_ends.is_empty()
+            || context.effective_names.iter().next().is_some()
+        {
+            return None;
+        }
+        let raw = Arc::clone(self.annotations.as_ref()?);
+        if !raw.import_domains(b, steps)?.owner_complete(owner) {
+            return None;
+        }
+        let members = crate::json::operations::namespaces::memberships_builder(
+            b,
+            &raw,
+            owner,
+            steps,
+            "recursive package lookup",
+        )
+        .ok()?;
+        charge(steps, b.elements[owner].owned_relationships.len())?;
+        if b.elements[owner].owned_relationships.iter().any(|&r| {
+            conforms(b.elements[r].ty, "Specialization")
+                || b.elements[r].ty == "ElementFilterMembership"
+        }) {
+            return None;
+        }
+        let mut expected: HashMap<String, Vec<Binding>> = HashMap::new();
+        let mut aliases = HashMap::new();
+        let mut children = Vec::new();
+        for m in members {
+            charge(steps, 1)?;
+            if !conforms(b.elements[m.relationship].ty, "OwningMembership") {
+                if b.elements[m.relationship].ty != "Membership" {
+                    return None;
+                }
+                for key in ["memberName", "memberShortName"] {
+                    if let Some(value) = b.elements[m.relationship]
+                        .props
+                        .get(key)
+                        .filter(|v| !v.is_null())
+                    {
+                        let name = value.as_str()?;
+                        charge(steps, name.len())?;
+                        aliases.insert((m.relationship, name.to_owned()), m.member);
+                    }
+                }
+                continue;
+            }
+            let element = &b.elements[m.member];
+            let sub_scope = b.elem_scope.get(&m.member).copied();
+            let namespace = conforms(element.ty, "Namespace");
+            if namespace {
+                if !matches!(element.ty, "Namespace" | "Package" | "LibraryPackage") {
+                    return None;
+                }
+                let sub = sub_scope?;
+                if b.scopes.get(sub)?.owner != Some(m.member) || b.scopes[sub].parent != Some(scope)
+                {
+                    return None;
+                }
+                if all || m.visibility == "public" {
+                    children.push(sub);
+                }
+            } else if sub_scope.is_some() {
+                return None;
+            }
+            let visibility = match m.visibility {
+                "public" => LookupAccess::Public,
+                "protected" => LookupAccess::Protected,
+                "private" => LookupAccess::All,
+                _ => return None,
+            };
+            let mut named = false;
+            for key in ["declaredName", "declaredShortName"] {
+                if let Some(value) = element.props.get(key).filter(|v| !v.is_null()) {
+                    let name = value.as_str()?;
+                    charge(steps, name.len())?;
+                    named = true;
+                    expected.entry(name.to_owned()).or_default().push(Binding {
+                        elem: m.member,
+                        sub_scope,
+                        visibility,
+                    });
+                }
+            }
+            if namespace && !named {
+                return None;
+            }
+        }
+        // Exact bags, including duplicate names: no omitted child or extra
+        // namespace-valued alias can silently change recursive traversal.
+        for (name, bindings) in context.names.iter() {
+            charge(steps, name.len().saturating_add(bindings.len()))?;
+            let expected = expected.remove(name)?;
+            if expected != bindings {
+                return None;
+            }
+        }
+        if !expected.is_empty() {
+            return None;
+        }
+        charge(steps, context.aliases.len())?;
+        for (alias_index, (name, qn, relationship)) in context.aliases.iter().enumerate() {
+            charge(steps, name.len())?;
+            let member = aliases.remove(&(*relationship, name.clone()))?;
+            self.direct_global_path(
+                b,
+                &raw,
+                qn,
+                member,
+                b.alias_origins
+                    .get(&(scope, alias_index))
+                    .copied()
+                    .unwrap_or_else(|| b.unit_of_scope(scope)),
+                depth + 1,
+                steps,
+            )?;
+        }
+        if !aliases.is_empty() {
+            return None;
+        }
+        Some(children)
+    }
+
+    fn direct_root_alias(
+        &mut self,
+        b: &Builder,
+        raw: &Arc<StoredStructure>,
+        name: &str,
+        member: usize,
+        steps: &mut usize,
+    ) -> Option<()> {
+        if !self
+            .recursive
+            .roots
+            .as_ref()
+            .is_some_and(|(old, _)| old.is_current(b))
+        {
+            self.recursive.charge_roots_drop(steps)?;
+            charge(steps, b.elements.len())?;
+            let mut names: HashMap<String, Vec<usize>> = HashMap::new();
+            for (root, element) in b.elements.iter().enumerate() {
+                if element.ty != "Namespace" || element.owning_relationship.is_some() {
+                    continue;
+                }
+                for m in crate::json::operations::namespaces::memberships_builder(
+                    b,
+                    raw,
+                    root,
+                    steps,
+                    "recursive alias root names",
+                )
+                .ok()?
+                {
+                    if !conforms(b.elements[m.relationship].ty, "OwningMembership") {
+                        continue;
+                    }
+                    for key in ["declaredName", "declaredShortName"] {
+                        if let Some(value) =
+                            b.elements[m.member].props.get(key).filter(|v| !v.is_null())
+                        {
+                            let name = value.as_str()?;
+                            charge(steps, name.len())?;
+                            names.entry(name.to_owned()).or_default().push(m.member);
+                        }
+                    }
+                }
+            }
+            self.recursive.roots = Some((Arc::clone(raw), names));
+        }
+        charge(steps, name.len())?;
+        if conforms(b.elements[member].ty, "Namespace") && b.elem_scope.get(&member).is_none() {
+            return None;
+        }
+        let expected = self.recursive.roots.as_ref()?.1.get(name)?;
+        let bindings = b.scopes[0].names.get(name)?;
+        charge(steps, expected.len().saturating_add(bindings.len()))?;
+        if expected.is_empty()
+            || expected.len() != bindings.len()
+            || expected.iter().any(|&e| e != member)
+            || bindings.iter().any(|binding| {
+                binding.elem != member
+                    || binding.sub_scope != b.elem_scope.get(&member).copied()
+                    || binding.sub_scope.is_some_and(|s| {
+                        b.scopes
+                            .get(s)
+                            .is_none_or(|scope| scope.owner != Some(member))
+                    })
+            })
+        {
+            return None;
+        }
+        Some(())
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/provider_completeness/recursive/qualified.rs b/crates/sysmlv2-model/src/json/provider_completeness/recursive/qualified.rs
new file mode 100644
index 0000000..0e6cc3c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/provider_completeness/recursive/qualified.rs
@@ -0,0 +1,122 @@
+//! Direct declaration paths witnessed from an already recorded endpoint.
+use super::{Builder, ProviderCompleteness, StoredStructure, charge};
+use crate::json::{Binding, LookupAccess, QualifiedName, semantic_ownership};
+use crate::metaclass::conforms;
+use std::{collections::HashMap, sync::Arc};
+
+impl ProviderCompleteness {
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn direct_global_path(
+        &mut self,
+        b: &Builder,
+        raw: &Arc<StoredStructure>,
+        name: &QualifiedName,
+        member: usize,
+        unit: usize,
+        depth: usize,
+        steps: &mut usize,
+    ) -> Option<()> {
+        if !name.is_global
+            || name.segments.is_empty()
+            || depth.saturating_add(name.segments.len() - 1) > crate::json::MAX_RESOLUTION_DEPTH
+        {
+            return None;
+        }
+        // Walk recorded ownership backwards, not resolver alternatives. Each
+        // qualifier must supply the exact direct binding that lookup visits
+        // before aliases, imports, inheritance or effective names.
+        let mut member = member;
+        for (index, segment) in name.segments.iter().enumerate().rev() {
+            if b.id_spelled_targets
+                .contains_key(&(unit, segment.span.start, segment.span.end))
+            {
+                return None;
+            }
+            if index == 0 {
+                return self.direct_root_alias(b, raw, &segment.value, member, steps);
+            }
+            charge(steps, segment.value.len().saturating_add(1))?;
+            let relationship = b.elements.get(member)?.owning_relationship?;
+            let owner =
+                semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)??;
+            if !matches!(
+                b.elements.get(owner)?.ty,
+                "Namespace" | "Package" | "LibraryPackage"
+            ) {
+                return None;
+            }
+            let scope = *b.elem_scope.get(&owner)?;
+            let context = b.scopes.get(scope)?;
+            if context.owner != Some(owner) {
+                return None;
+            }
+            let sub_scope = b.elem_scope.get(&member).copied();
+            if (conforms(b.elements[member].ty, "Namespace") && sub_scope.is_none())
+                || sub_scope.is_some_and(|sub| {
+                    b.scopes
+                        .get(sub)
+                        .is_none_or(|s| s.owner != Some(member) || s.parent != Some(scope))
+                })
+            {
+                return None;
+            }
+            if let std::collections::hash_map::Entry::Vacant(entry) =
+                self.recursive.qualified.entry(scope)
+            {
+                let memberships = crate::json::operations::namespaces::memberships_builder(
+                    b,
+                    raw,
+                    owner,
+                    steps,
+                    "qualified recursive target",
+                )
+                .ok()?;
+                let mut names: HashMap<String, Vec<Binding>> = HashMap::new();
+                for m in memberships {
+                    charge(steps, 1)?;
+                    if !conforms(b.elements[m.relationship].ty, "OwningMembership") {
+                        continue;
+                    }
+                    let visibility = match m.visibility {
+                        "public" => LookupAccess::Public,
+                        "protected" => LookupAccess::Protected,
+                        "private" => LookupAccess::All,
+                        _ => return None,
+                    };
+                    for key in ["declaredName", "declaredShortName"] {
+                        if let Some(value) =
+                            b.elements[m.member].props.get(key).filter(|v| !v.is_null())
+                        {
+                            let declared = value.as_str()?;
+                            charge(steps, declared.len().saturating_add(1))?;
+                            names.entry(declared.to_owned()).or_default().push(Binding {
+                                elem: m.member,
+                                sub_scope: b.elem_scope.get(&m.member).copied(),
+                                visibility,
+                            });
+                        }
+                    }
+                }
+                entry.insert(names);
+            }
+            let expected = self.recursive.qualified.get(&scope)?.get(&segment.value)?;
+            let bindings = context.names.get(&segment.value)?;
+            charge(steps, expected.len().saturating_add(bindings.len()))?;
+            // Public-only groups have identical lookup under every caller
+            // access level, including import all. Hidden collisions need a
+            // separate origin/access certificate and remain qualified.
+            if expected.is_empty()
+                || expected != bindings
+                || expected.iter().any(|binding| {
+                    binding.elem != member
+                        || binding.sub_scope != sub_scope
+                        || binding.visibility != LookupAccess::Public
+                })
+            {
+                return None;
+            }
+            member = owner;
+        }
+        None
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/provider_completeness/recursive_tests.rs b/crates/sysmlv2-model/src/json/provider_completeness/recursive_tests.rs
new file mode 100644
index 0000000..eb3ce95
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/provider_completeness/recursive_tests.rs
@@ -0,0 +1,495 @@
+use super::*;
+use crate::{json::ResolvedModel, model::Model};
+pub(super) fn fixture(tree: &str, import: &str) -> (ResolvedModel, usize) {
+    let mut model = Model::new();
+    let parsed = model.add_source(
+        "recursive-providers.kerml",
+        &format!("class Marker; class Other; {tree} package Consumer {{private import {import};}}"),
+    );
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    let owner = r.resolve_qualified("Consumer").unwrap().0;
+    let scope = *r.b.elem_scope.get(&owner).unwrap();
+    (r, scope)
+}
+const TREE: &str = "package Tree {package Nested {alias Leaf for $::Marker;}}";
+#[test]
+fn recursive_import_forms_certify_named_trees_and_preserve_lookup_state() {
+    for import in ["$::Tree::**", "$::Tree::*::**", "all $::Tree::*::**"] {
+        let (mut r, scope) = fixture(TREE, import);
+        let marker = r.resolve_qualified("Marker").unwrap().0;
+        let mut proof = ProviderCompleteness::default();
+        r.b.probing = true;
+        let misses = r.b.current_misses.clone();
+        assert!(proof.scope(&mut r.b, scope, &mut 0), "{import}");
+        assert!(r.b.probing);
+        assert_eq!(r.b.current_misses, misses);
+        r.b.probing = false;
+        assert_eq!(r.b.lookup(scope, "Leaf", 0).map(|v| v.0), Some(marker));
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(!proof.scope(&mut r.b, scope, &mut exhausted));
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+}
+#[test]
+fn recursive_tree_depth_matches_lookup_including_terminal_alias_cost() {
+    for nested in [0, 21, 22, 23, 24] {
+        let mut tree = "package Tree {".to_owned();
+        for i in 0..nested {
+            tree.push_str(&format!("package N{i} {{"));
+        }
+        tree.push_str("alias Leaf for $::Marker;");
+        tree.push_str(&"}".repeat(nested + 1));
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        let expected = nested <= crate::json::MAX_RESOLUTION_DEPTH - 2;
+        let mut proof = ProviderCompleteness::default();
+        assert_eq!(
+            proof.scope(&mut r.b, scope, &mut 0),
+            expected,
+            "nested={nested}"
+        );
+        assert_eq!(
+            r.b.lookup(scope, "Leaf", 0).is_some(),
+            expected,
+            "lookup nested={nested}"
+        );
+    }
+}
+#[test]
+fn recursive_proofs_recheck_resolver_and_endpoint_mutations_then_recover() {
+    for import in ["$::Tree::**", "$::Tree::*::**"] {
+        let (mut r, scope) = fixture(TREE, import);
+        let tree = r.resolve_qualified("Tree").unwrap().0;
+        let tree_scope = *r.b.elem_scope.get(&tree).unwrap();
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].filters.push(usize::MAX);
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].filters.clear();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        // A cold direct global target is complete without warming lookup.
+        r.b.import_cache[scope] = None;
+        let targets = r.b.import_targets.clone();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        assert!(r.b.import_cache[scope].is_none());
+        assert_eq!(r.b.import_targets, targets);
+        r.b.import_scopes(scope);
+        let cache = r.b.import_cache[scope].clone();
+        r.b.import_cache[scope] = Some(std::sync::Arc::new(vec![]));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.import_cache[scope] = cache;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let mut extra = r.b.import_cache[scope].as_ref().unwrap()[0].clone();
+        extra.relationship = usize::MAX;
+        std::sync::Arc::make_mut(r.b.import_cache[scope].as_mut().unwrap()).push(extra);
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        std::sync::Arc::make_mut(r.b.import_cache[scope].as_mut().unwrap()).pop();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let entries = r.b.scopes[scope].imports.clone();
+        r.b.scopes[scope].imports.clear();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].imports = entries;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let root_names = r.b.scopes[0].names.clone();
+        r.b.scopes[0].names = Default::default();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[0].names = root_names;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let names = r.b.scopes[tree_scope].names.clone();
+        r.b.scopes[tree_scope].names = Default::default();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[tree_scope].names = names;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elem_scope.insert(tree, scope);
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elem_scope.insert(tree, tree_scope);
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let rel = r.b.scopes[scope].imports[0].relationship;
+        let props = r.b.elements[rel].props.clone();
+        r.b.elements[rel]
+            .props
+            .insert("isRecursive", serde_json::json!(false));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[rel].props = props;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].imports[0].recursive = false;
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[scope].imports[0].recursive = true;
+        // A failed mismatch still depends on resolver state, so must recover.
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+}
+#[test]
+fn unsupported_recursive_domains_refuse_without_hiding_ambiguity() {
+    for tree in [
+        "package Tree {class Local;}",
+        "package Tree {package {alias Leaf for $::Marker;}}",
+        "package Tree {package Nested {private import Marker;}}",
+        "package Tree {public import Tree::*;}",
+        "package Tree {alias Leaf for Marker;}",
+        "package Tree {alias Leaf for $::Missing;}",
+        "package Tree {filter true;}",
+    ] {
+        let (mut r, scope) = fixture(tree, "$::Tree::*::**");
+        assert!(
+            !ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            "{tree}"
+        );
+    }
+    let (mut r, scope) = fixture(
+        "package Tree {package A {alias Same for $::Marker;} package B {alias Same for $::Other;}}",
+        "$::Tree::*::**",
+    );
+    assert!(ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0));
+    assert!(r.b.lookup(scope, "Same", 0).is_none());
+}
+
+#[test]
+fn inverse_recursive_imports_cannot_disappear_with_all_forward_views() {
+    for import in ["$::Tree::**", "$::Tree::*::**"] {
+        let (mut r, scope) = fixture(TREE, import);
+        let owner = r.b.scopes[scope].owner.unwrap();
+        let relationships = r.b.elements[owner].owned_relationships.clone();
+        let imports = r.b.scopes[scope].imports.clone();
+        let members = r.b.scopes[scope].member_imports.clone();
+        let cached = r.b.import_cache[scope].clone();
+        r.b.elements[owner].owned_relationships = Default::default();
+        r.b.scopes[scope].imports.clear();
+        r.b.scopes[scope].member_imports.clear();
+        r.b.import_cache[scope] = None;
+        let mut proof = ProviderCompleteness::default();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[owner].owned_relationships = relationships;
+        r.b.scopes[scope].imports = imports;
+        r.b.scopes[scope].member_imports = members;
+        r.b.import_cache[scope] = cached;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+}
+#[test]
+fn recursive_aliases_require_complete_raw_root_name_group_and_current_scope() {
+    let (mut r, scope) = fixture(TREE, "$::Tree::*::**");
+    let marker = r.resolve_qualified("Marker").unwrap().0;
+    let other = r.resolve_qualified("Other").unwrap().0;
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let original = r.b.elements[other].props.clone();
+    r.b.elements[other]
+        .props
+        .insert("declaredName", serde_json::json!("Marker"));
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.elements[other].props = original;
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let marker_scope = *r.b.elem_scope.get(&marker).unwrap();
+    let other_scope = *r.b.elem_scope.get(&other).unwrap();
+    let root_names = r.b.scopes[0].names.clone();
+    let mut wrong = crate::json::scope_table::Names::default();
+    for (name, bindings) in root_names.iter() {
+        for binding in bindings {
+            let mut binding = *binding;
+            if binding.elem == marker {
+                binding.sub_scope = Some(other_scope);
+            }
+            wrong.push(name.to_owned(), binding);
+        }
+    }
+    r.b.scopes[0].names = wrong;
+    r.b.elem_scope.insert(marker, other_scope);
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.scopes[0].names = root_names;
+    r.b.elem_scope.insert(marker, marker_scope);
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
+
+#[test]
+fn stored_import_relationship_targets_keep_membership_and_element_identities_distinct() {
+    for import in ["$::Tree::**", "$::Tree::*::**"] {
+        let (mut r, scope) = fixture(TREE, import);
+        let owner = r.b.scopes[scope].owner.unwrap();
+        let rel = r.b.scopes[scope].imports[0].relationship;
+        let tree = r.resolve_qualified("Tree").unwrap().0;
+        let target = if r.b.elements[rel].ty == "MembershipImport" {
+            r.b.elements[tree].owning_relationship.unwrap()
+        } else {
+            tree
+        };
+        let owner_id = r.b.elements[owner].id;
+        let target_id = r.b.elements[target].id;
+        let tree_id = r.b.elements[tree].id;
+        r.b.elements[rel]
+            .props
+            .insert("target", serde_json::json!([{"@id": target_id}]));
+        r.b.elements[rel].props.insert(
+            "relatedElement",
+            serde_json::json!([{"@id": owner_id}, {"@id": target_id}]),
+        );
+        r.b.elements[rel]
+            .props
+            .insert("importedElement", serde_json::json!({"@id": tree_id}));
+        let mut proof = ProviderCompleteness::default();
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        if target != tree {
+            r.b.elements[rel]
+                .props
+                .insert("target", serde_json::json!([{"@id": tree_id}]));
+            assert!(!proof.scope(&mut r.b, scope, &mut 0));
+            r.b.elements[rel]
+                .props
+                .insert("target", serde_json::json!([{"@id": target_id}]));
+            assert!(proof.scope(&mut r.b, scope, &mut 0));
+        }
+    }
+}
+
+#[test]
+fn recursive_root_name_cache_reset_charges_before_drop_and_can_retry() {
+    let (mut r, scope) = fixture(TREE, "$::Tree::*::**");
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let mut reset_cost = 0;
+    assert_eq!(proof.reset_with_budget(&mut reset_cost), Some(()));
+    assert!(reset_cost > 1);
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let mut exhausted = crate::eval::MAX_STEPS - reset_cost + 1;
+    assert_eq!(proof.reset_with_budget(&mut exhausted), None);
+    assert!(exhausted > crate::eval::MAX_STEPS);
+    assert_eq!(proof.reset_with_budget(&mut 0), Some(()));
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
+
+const QUALIFIED_TREE: &str = "package Definitions {class Target;} package Catalog {package Tree {package Nested {alias Leaf for $::Definitions::Target;}}}";
+#[test]
+fn qualified_recursive_targets_and_aliases_use_direct_membership_paths() {
+    for import in [
+        "$::Catalog::Tree::**",
+        "$::Catalog::Tree::*::**",
+        "all $::Catalog::Tree::*::**",
+    ] {
+        let (mut r, scope) = fixture(QUALIFIED_TREE, import);
+        let marker = r.resolve_qualified("Definitions::Target").unwrap().0;
+        let mut proof = ProviderCompleteness::default();
+        r.b.import_cache[scope] = None;
+        assert!(proof.scope(&mut r.b, scope, &mut 0), "{import}");
+        assert!(r.b.import_cache[scope].is_none());
+        assert_eq!(r.b.lookup(scope, "Leaf", 0).map(|v| v.0), Some(marker));
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(!proof.scope(&mut r.b, scope, &mut exhausted));
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+}
+
+#[test]
+fn qualified_target_witnesses_reject_hidden_ambiguity_stale_bindings_and_identity_overrides() {
+    let (mut r, scope) = fixture(QUALIFIED_TREE, "$::Catalog::Tree::**");
+    let tree = r.resolve_qualified("Catalog::Tree").unwrap().0;
+    let catalog = r.resolve_qualified("Catalog").unwrap().0;
+    let catalog_scope = *r.b.elem_scope.get(&catalog).unwrap();
+    let target = r.resolve_qualified("Definitions::Target").unwrap().0;
+    let definitions = r.resolve_qualified("Definitions").unwrap().0;
+    let definitions_scope = *r.b.elem_scope.get(&definitions).unwrap();
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    for (member, parent) in [(tree, catalog_scope), (target, definitions_scope)] {
+        let relationship = r.b.elements[member].owning_relationship.unwrap();
+        let props = r.b.elements[relationship].props.clone();
+        r.b.elements[relationship]
+            .props
+            .insert("visibility", serde_json::json!("private"));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.elements[relationship].props = props;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let names = r.b.scopes[parent].names.clone();
+        r.b.scopes[parent].names = Default::default();
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[parent].names = names;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+        let sub = *r.b.elem_scope.get(&member).unwrap();
+        let original_parent = r.b.scopes[sub].parent;
+        r.b.scopes[sub].parent = Some(scope);
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.scopes[sub].parent = original_parent;
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+    let entry = r.b.scopes[scope].imports[0].clone();
+    for segment in &entry.target.segments {
+        let key = (
+            r.b.unit_of_elem(entry.relationship),
+            segment.span.start,
+            segment.span.end,
+        );
+        let id = r.b.elements[tree].id;
+        r.b.id_spelled_targets.insert(key, (id, id));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.id_spelled_targets.remove(&key);
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+    let nested = r.resolve_qualified("Catalog::Tree::Nested").unwrap().0;
+    let nested_scope = *r.b.elem_scope.get(&nested).unwrap();
+    let alias = r.b.scopes[nested_scope].aliases[0].1.clone();
+    let unit =
+        r.b.alias_origins
+            .get(&(nested_scope, 0))
+            .copied()
+            .unwrap_or_else(|| r.b.unit_of_scope(nested_scope));
+    for segment in &alias.segments {
+        let key = (unit, segment.span.start, segment.span.end);
+        let id = r.b.elements[target].id;
+        r.b.id_spelled_targets.insert(key, (id, id));
+        assert!(!proof.scope(&mut r.b, scope, &mut 0));
+        r.b.id_spelled_targets.remove(&key);
+        assert!(proof.scope(&mut r.b, scope, &mut 0));
+    }
+    // The raw name group must agree even if the resolver omits its collision.
+    let (mut r, scope) = fixture(
+        "package Catalog {package Tree {} package Other {}}",
+        "$::Catalog::Tree::*::**",
+    );
+    let other = r.resolve_qualified("Catalog::Other").unwrap().0;
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let props = r.b.elements[other].props.clone();
+    r.b.elements[other]
+        .props
+        .insert("declaredName", serde_json::json!("Tree"));
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.elements[other].props = props;
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
+
+#[test]
+fn qualified_recursive_paths_keep_dynamic_and_cached_resolution_depth_distinct() {
+    for form in ["**", "*::**"] {
+        for depth in [22, 23, 24] {
+            let (mut r, scope) = fixture(
+                "package Catalog {package Tree {}}",
+                &format!("$::Catalog::Tree::{form}"),
+            );
+            let mut proof = ProviderCompleteness::default();
+            assert!(proof.scope(&mut r.b, scope, &mut 0));
+            assert!(proof.invalidate_known(&mut 0));
+            let expected = if form == "**" {
+                depth <= 22
+            } else {
+                depth <= 23
+            };
+            assert_eq!(
+                proof.scope_inner(&mut r.b, scope, depth, &mut 0),
+                expected,
+                "{form} depth={depth}"
+            );
+            if form == "**" {
+                assert_eq!(r.b.lookup(scope, "Tree", depth).is_some(), expected);
+            }
+        }
+    }
+    for nested in [20, 21, 22] {
+        let tree = format!(
+            "package Definitions {{class Target;}} package Tree {{{}alias Leaf for $::Definitions::Target;{}}}",
+            "package Nested {".repeat(nested),
+            "}".repeat(nested)
+        );
+        let (mut r, scope) = fixture(&tree, "$::Tree::*::**");
+        let expected = nested <= 21;
+        assert_eq!(
+            ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            expected
+        );
+        assert_eq!(r.b.lookup(scope, "Leaf", 0).is_some(), expected);
+    }
+}
+
+#[test]
+fn qualified_recursive_paths_do_not_infer_indirect_or_hidden_qualifiers() {
+    for tree in [
+        "package Actual {package Tree {}} alias Catalog for $::Actual;",
+        "class Catalog {package Tree {}}",
+        "package Catalog {private package Tree {}}",
+        "package Catalog {protected package Tree {}}",
+        "package Actual {package Tree {}} package Catalog {public import $::Actual::*;}",
+    ] {
+        let (mut r, scope) = fixture(tree, "$::Catalog::Tree::*::**");
+        assert!(
+            !ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            "{tree}"
+        );
+    }
+}
+
+#[test]
+fn qualified_namespace_cache_targets_obey_their_own_cold_path_limit() {
+    for segments in [24, 25, 26] {
+        let path = (0..segments).map(|i| format!("N{i}")).collect::<Vec<_>>();
+        let tree = path
+            .iter()
+            .map(|n| format!("package {n} {{"))
+            .collect::<String>()
+            + &"}".repeat(segments);
+        let import = format!("$::{}::*::**", path.join("::"));
+        let (mut r, scope) = fixture(&tree, &import);
+        r.b.import_cache[scope] = None;
+        let mut proof = ProviderCompleteness::default();
+        assert_eq!(proof.scope(&mut r.b, scope, &mut 0), segments <= 25);
+        assert!(r.b.import_cache[scope].is_none());
+        assert_eq!(!r.b.import_scopes(scope).is_empty(), segments <= 25);
+    }
+}
+
+#[test]
+fn qualified_scope_name_indexes_charge_reset_and_recover_after_exhaustion() {
+    let (mut r, scope) = fixture(QUALIFIED_TREE, "$::Catalog::Tree::*::**");
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let mut cost = 0;
+    assert_eq!(proof.reset_with_budget(&mut cost), Some(()));
+    assert!(cost > 1);
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let mut exhausted = crate::eval::MAX_STEPS - cost + 1;
+    assert_eq!(proof.reset_with_budget(&mut exhausted), None);
+    assert!(exhausted > crate::eval::MAX_STEPS);
+    assert_eq!(proof.reset_with_budget(&mut 0), Some(()));
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
+
+#[test]
+fn qualified_paths_preserve_short_names_and_direct_binding_precedence() {
+    for (tree, import) in [
+        (
+            "package <C> Catalog {package <T> Tree {alias Leaf for $::Marker;}}",
+            "$::C::T::*::**",
+        ),
+        (
+            "package Catalog {package Mid {package Tree {alias Leaf for $::Marker;}}}",
+            "$::Catalog::Mid::Tree::*::**",
+        ),
+        (
+            "package Catalog {package Tree {alias Leaf for $::Marker;} alias Tree for $::Other; private import $::Other;}",
+            "$::Catalog::Tree::*::**",
+        ),
+        (
+            "package Definitions {class <T> Target;} package Tree {alias Leaf for $::Definitions::T;}",
+            "$::Tree::*::**",
+        ),
+    ] {
+        let (mut r, scope) = fixture(tree, import);
+        assert!(
+            ProviderCompleteness::default().scope(&mut r.b, scope, &mut 0),
+            "{tree}"
+        );
+        assert!(r.b.lookup(scope, "Leaf", 0).is_some());
+    }
+    let (mut r, scope) = fixture(
+        "package Catalog {package Tree {} package Other {}}",
+        "$::Catalog::Tree::*::**",
+    );
+    let other = r.resolve_qualified("Catalog::Other").unwrap().0;
+    let mut proof = ProviderCompleteness::default();
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+    let props = r.b.elements[other].props.clone();
+    r.b.elements[other]
+        .props
+        .insert("declaredShortName", serde_json::json!("Tree"));
+    assert!(!proof.scope(&mut r.b, scope, &mut 0));
+    r.b.elements[other].props = props;
+    assert!(proof.scope(&mut r.b, scope, &mut 0));
+}
diff --git a/crates/sysmlv2-model/src/json/publication.rs b/crates/sysmlv2-model/src/json/publication.rs
new file mode 100644
index 0000000..18ea3cc
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/publication.rs
@@ -0,0 +1,124 @@
+//! Publication permission and reentrancy, separate from logical semantic readiness.
+//! This substrate adds no new materialization demand sites.
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Status {
+    Ready,
+    Construction,
+    Reentrant,
+}
+
+#[derive(Default)]
+pub(super) struct Control {
+    enabled: bool,
+    active: Option<Arc<AtomicBool>>,
+    revision: Option<Arc<()>>,
+}
+impl Clone for Control {
+    fn clone(&self) -> Self {
+        Self {
+            enabled: self.enabled,
+            active: None,
+            revision: self.revision.clone(),
+        }
+    }
+}
+#[derive(Clone, Default)]
+pub(super) struct Revision(Option<Arc<()>>);
+impl Revision {
+    pub(super) fn next() -> Self {
+        Self(Some(Arc::new(())))
+    }
+    pub(super) fn same_as(&self, other: &Self) -> bool {
+        match (&self.0, &other.0) {
+            (None, None) => true,
+            (Some(a), Some(b)) => Arc::ptr_eq(a, b),
+            _ => false,
+        }
+    }
+}
+pub(super) struct Guard(Arc<AtomicBool>);
+impl Drop for Guard {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::Release);
+    }
+}
+impl Control {
+    pub(super) fn enable(&mut self) {
+        self.enabled = true;
+    }
+    pub(super) fn suppress(&mut self) {
+        self.enabled = false;
+    }
+    pub(super) fn begin(&mut self, semantic_ready: bool) -> Result<Guard, Status> {
+        if !semantic_ready || !self.enabled {
+            return Err(Status::Construction);
+        }
+        let active = self
+            .active
+            .get_or_insert_with(|| Arc::new(AtomicBool::new(false)));
+        if active.swap(true, Ordering::AcqRel) {
+            return Err(Status::Reentrant);
+        }
+        Ok(Guard(Arc::clone(active)))
+    }
+    pub(super) fn revision(&self) -> Revision {
+        Revision(self.revision.clone())
+    }
+    pub(super) fn install(&mut self, revision: Revision) {
+        self.revision = revision.0;
+    }
+    pub(super) fn published(&mut self) {
+        self.install(Revision::next());
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn readiness_permission_and_reentrancy_are_distinct() {
+        let mut c = Control::default();
+        assert!(matches!(c.begin(true), Err(Status::Construction)));
+        c.enable();
+        assert!(matches!(c.begin(false), Err(Status::Construction)));
+        let g = c.begin(true).unwrap();
+        assert!(matches!(c.begin(true), Err(Status::Reentrant)));
+        drop(g);
+        assert!(c.begin(true).is_ok());
+        c.suppress();
+        assert!(matches!(c.begin(true), Err(Status::Construction)));
+    }
+    #[test]
+    fn unwind_releases_phase_without_publishing_or_reusing_revision() {
+        let mut c = Control::default();
+        c.enable();
+        let before = c.revision();
+        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let _g = c.begin(true).unwrap();
+            panic!("preparation failed");
+        }));
+        assert!(before.same_as(&c.revision()));
+        let _g = c.begin(true).unwrap();
+        c.published();
+        assert!(!before.same_as(&c.revision()));
+        let first = c.revision();
+        c.published();
+        assert!(!first.same_as(&c.revision()));
+    }
+    #[test]
+    fn clone_holds_snapshot_but_does_not_share_an_active_transaction() {
+        let mut c = Control::default();
+        c.enable();
+        c.published();
+        let _g = c.begin(true).unwrap();
+        let mut copy = c.clone();
+        assert!(c.revision().same_as(&copy.revision()));
+        let _copy_guard = copy.begin(true).unwrap();
+        copy.published();
+        assert!(!c.revision().same_as(&copy.revision()));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/recorded_lookup.rs b/crates/sysmlv2-model/src/json/recorded_lookup.rs
new file mode 100644
index 0000000..5b20130
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/recorded_lookup.rs
@@ -0,0 +1,1232 @@
+//! Recorded-only inherited name selection for complete explicit heritage.
+//! Complex import, filter, chain and implied-heritage contexts retain the
+//! contextual resolver until those dependencies share a complete recorded plan.
+
+use super::{Builder, LookupAccess, LookupResult, MissTable};
+use crate::layered::{LayeredMap, LayeredVec};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+#[derive(Clone, PartialEq, Debug)]
+struct Member {
+    target: usize,
+    scope: Option<usize>,
+    names: Vec<String>,
+    visibility: LookupAccess,
+    alias: bool,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+struct Node {
+    bases: Vec<usize>,
+    owned: Vec<usize>,
+    owned_features: Vec<usize>,
+}
+
+#[derive(Clone, Default)]
+pub(super) struct Graph {
+    nodes: LayeredVec<Option<Node>>,
+    members: LayeredMap<usize, Member>,
+    header_bases: LayeredMap<usize, Vec<usize>>,
+    has_ordered_headers: bool,
+    features: LayeredMap<usize, ()>,
+    redefinitions: LayeredMap<usize, Option<Vec<usize>>>,
+    inherited: LayeredMap<usize, Option<Arc<Vec<usize>>>>,
+    suppressed: LayeredMap<usize, Arc<Vec<usize>>>,
+    ids: LayeredMap<uuid::Uuid, usize>,
+    element_count: usize,
+    absent_roots: HashSet<String>,
+    /// Root misses behind each scope's node inputs — the recorded outcomes
+    /// of its owner's specializations and alias memberships, whether or not
+    /// a node resulted — and the implied roots the node takes as absent.
+    /// A selection through the graph depends on every node it read.
+    input_misses: MissTable,
+    /// Root misses behind each feature's recorded redefinition targets.
+    redefinition_misses: MissTable,
+    /// Root misses behind each scope's header bases.
+    header_misses: MissTable,
+    /// Root misses behind each memoized inherited projection (`inherited`),
+    /// complete or not.
+    collected_misses: MissTable,
+}
+
+/// Note the misses behind the graph entry `key` of `table` among `misses`.
+fn note(misses: &mut Vec<String>, table: &MissTable, key: usize) {
+    if let Some(entry) = table.get(key) {
+        super::note_misses(misses, entry.iter());
+    }
+}
+
+/// Keep `misses` as the misses behind the graph entry `key` of `table`.
+fn keep(table: &mut MissTable, key: usize, misses: Vec<String>) {
+    table.set(key, &misses);
+}
+
+/// A short-lived proof that an alias spelling can be followed without import
+/// walks. It uses stored explicit bases and declaration tables, never the
+/// contextual resolver or its semantic caches.
+struct AliasProof<'a> {
+    b: &'a Builder,
+    graph: &'a mut Graph,
+    active: HashSet<usize>,
+    bindings: HashMap<(usize, String, u8), Option<Option<usize>>>,
+    /// Root misses behind everything the proofs read: the nodes their
+    /// selections went through, the implied roots they took as absent, and
+    /// the names they looked up and did not find at the root.
+    misses: Vec<String>,
+}
+
+impl AliasProof<'_> {
+    fn target(&mut self, origin: usize, qn: &super::QualifiedName, depth: usize) -> Option<usize> {
+        if depth > super::MAX_RESOLUTION_DEPTH {
+            return None;
+        }
+        let first = qn.segments.first()?;
+        let mut scope = if qn.is_global { 0 } else { origin };
+        let mut target = loop {
+            match self.binding(scope, &first.value, LookupAccess::All, depth)? {
+                Some(target) => break target,
+                None if scope == 0 => {
+                    super::note_misses(&mut self.misses, [&first.value]);
+                    return None;
+                }
+                None => scope = self.b.scopes[scope].parent?,
+            }
+        };
+        for (step, segment) in qn.segments.iter().enumerate().skip(1) {
+            let scope = *self.b.elem_scope.get(&target)?;
+            let access = if self.b.scope_is_within(origin, scope) {
+                LookupAccess::All
+            } else if self.can_access_protected(origin, scope) {
+                LookupAccess::Protected
+            } else {
+                LookupAccess::Public
+            };
+            target = self.binding(scope, &segment.value, access, depth + step)??;
+        }
+        Some(target)
+    }
+
+    // Some(None) proves the spelling absent here, permitting a lexical
+    // parent step. None means contextual resolution may contribute a binding.
+    fn binding(
+        &mut self,
+        scope: usize,
+        name: &str,
+        access: LookupAccess,
+        depth: usize,
+    ) -> Option<Option<usize>> {
+        if depth > super::MAX_RESOLUTION_DEPTH {
+            return None;
+        }
+        let key = (scope, name.to_owned(), access as u8);
+        if let Some(result) = self.bindings.get(&key) {
+            return *result;
+        }
+        // An active cycle is not an import-free resolution proof.
+        self.bindings.insert(key.clone(), None);
+        let result = self.binding_uncached(scope, name, access, depth);
+        self.bindings.insert(key, result);
+        result
+    }
+
+    fn binding_uncached(
+        &mut self,
+        scope: usize,
+        name: &str,
+        access: LookupAccess,
+        depth: usize,
+    ) -> Option<Option<usize>> {
+        let context = &self.b.scopes[scope];
+        for names in [&context.names, &context.effective_names] {
+            let mut bindings = names
+                .get(name)
+                .into_iter()
+                .flatten()
+                .filter(|binding| access.admits(binding.visibility));
+            if let Some(binding) = bindings.next() {
+                if bindings.any(|other| other.elem != binding.elem) {
+                    return None;
+                }
+                return Some(Some(binding.elem));
+            }
+        }
+        let mut aliases = context
+            .aliases
+            .iter()
+            .filter(|(n, _, rel)| n == name && self.b.import_admitted(*rel, access));
+        if let Some((_, qn, rel)) = aliases.next() {
+            if aliases.any(|(_, _, other)| other != rel) || !self.active.insert(*rel) {
+                return None;
+            }
+            let target = self.target(scope, qn, depth + 1);
+            self.active.remove(rel);
+            return target.map(Some);
+        }
+        if context.implied_ends.iter().any(|(n, _, _)| *n == name)
+            || !context.imports.is_empty()
+            || !context.member_imports.is_empty()
+            || !context.filters.is_empty()
+            || !context.chain_bases.is_empty()
+            || context.owner.is_some_and(|owner| {
+                self.b
+                    .metadata_of
+                    .get(&owner)
+                    .is_some_and(|m| !m.is_empty())
+            })
+            || !Graph::implied_roots_absent(self.b, scope)
+        {
+            return None;
+        }
+        let absent = Graph::implied_roots(context);
+        super::note_misses(&mut self.misses, &absent);
+        self.graph.absent_roots.extend(absent);
+        if context.bases.is_empty() {
+            return Some(None);
+        }
+        let (hits, _) = self
+            .graph
+            .select(scope, name, access, None, false, &mut self.misses)?;
+        let mut result = LookupResult::Missing;
+        for hit in hits {
+            if let LookupResult::Found(target, _, Some(alias)) = hit {
+                let owner = self.b.elements[alias]
+                    .props
+                    .get("owningRelatedElement")?
+                    .as_reference()
+                    .and_then(|id| self.graph.ids.get(&id).copied())?;
+                let origin = *self.b.elem_scope.get(&owner)?;
+                let (_, qn, _) = self.b.scopes[origin]
+                    .aliases
+                    .iter()
+                    .find(|(_, _, rel)| *rel == alias)?;
+                if !self.active.insert(alias) {
+                    return None;
+                }
+                let certified = self.target(origin, qn, depth + 1);
+                self.active.remove(&alias);
+                if certified != Some(target) {
+                    return None;
+                }
+            }
+            result = self.b.merge_lookup(result, hit);
+        }
+        match result {
+            LookupResult::Found(target, _, _) => Some(Some(target)),
+            LookupResult::Missing => Some(None),
+            LookupResult::Ambiguous => None,
+        }
+    }
+
+    fn can_access_protected(&mut self, mut origin: usize, target: usize) -> bool {
+        let mut seen = HashSet::new();
+        loop {
+            let mut pending = vec![origin];
+            while let Some(scope) = pending.pop() {
+                if !seen.insert(scope) {
+                    continue;
+                }
+                note(&mut self.misses, &self.graph.input_misses, scope);
+                if let Some(node) = self.graph.nodes.get(scope).and_then(Option::as_ref) {
+                    if node.bases.contains(&target) {
+                        return true;
+                    }
+                    pending.extend(node.bases.iter().copied());
+                }
+            }
+            let Some(parent) = self.b.scopes[origin].parent else {
+                return false;
+            };
+            origin = parent;
+        }
+    }
+}
+
+impl Graph {
+    /// A single-base chain with no redeclarations, aliases or redefinitions
+    /// cannot change when selection moves before name matching.
+    pub(super) fn needed(b: &Builder) -> bool {
+        let has_redefinition = b.elements.iter().any(|e| conforms(e.ty, "Redefinition"));
+        let candidate = b.scopes.iter().any(|s| {
+            !s.aliases.is_empty()
+                || s.bases.len() > 1
+                || (!s.bases.is_empty()
+                    && s.owner.is_some_and(|owner| {
+                        b.elements[owner]
+                            .owned_relationships
+                            .iter()
+                            .any(|&r| conforms(b.elements[r].ty, "Membership"))
+                    }))
+        });
+        has_redefinition
+            || (candidate && (0..b.scopes.len()).any(|s| Self::scope_inputs(b, s).is_some()))
+    }
+
+    fn scope_inputs(b: &Builder, s: usize) -> Option<(usize, Vec<usize>)> {
+        let scope = &b.scopes[s];
+        let owner = scope.owner?;
+        if !b.dynamic_evidence_current(owner) || !b.result_redefinition_evidence_current(owner) {
+            return None;
+        }
+        if b.effective_dynamic_plan().is_some_and(|plan| {
+            plan.added_bases
+                .get(&owner)
+                .is_some_and(|bases| !bases.is_empty())
+        }) {
+            return None;
+        }
+        if !conforms(b.elements[owner].ty, "Type")
+            || conforms(b.elements[owner].ty, "Definition")
+            || conforms(b.elements[owner].ty, "Usage")
+            || !scope.imports.is_empty()
+            || !scope.member_imports.is_empty()
+            || !scope.filters.is_empty()
+            || !scope.chain_bases.is_empty()
+            || !scope.implied_ends.is_empty()
+            || b.metadata_of.get(&owner).is_some_and(|m| !m.is_empty())
+        {
+            return None;
+        }
+        // Only a provably absent global implied root can be ignored.
+        // No lexical resolution is allowed while building this snapshot.
+        if !Self::implied_roots_absent(b, s) {
+            return None;
+        }
+        let owned_features = b.owned_member_elems(owner, true);
+        // End, parameter and result slots can acquire positional edges
+        // without any loaded library. Their closures need the completed
+        // positional plan and stay outside this explicit-only snapshot.
+        if owned_features.iter().any(|&feature| {
+            b.elements[feature]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true)
+                || b.elements[feature].owning_relationship.is_some_and(|r| {
+                    conforms(b.elements[r].ty, "ParameterMembership")
+                        || conforms(b.elements[r].ty, "ReturnParameterMembership")
+                })
+        }) {
+            return None;
+        }
+        Some((owner, owned_features))
+    }
+
+    /// The global roots of a scope's implied bases: taking them as absent
+    /// depends on each staying a root miss, and on the root importing
+    /// nothing ([`super::ROOT_IMPORTS`]).
+    fn implied_roots(scope: &super::Scope) -> Vec<String> {
+        let mut roots: Vec<String> = scope
+            .implied_bases
+            .iter()
+            .filter_map(|qn| qn.segments.first().map(|n| n.value.clone()))
+            .collect();
+        if !roots.is_empty() {
+            roots.push(super::ROOT_IMPORTS.to_owned());
+        }
+        roots
+    }
+
+    /// Whether any node or alias proof takes implied roots as absent.
+    pub(super) fn takes_implied_roots_absent(&self) -> bool {
+        !self.absent_roots.is_empty()
+    }
+
+    fn implied_roots_absent(b: &Builder, scope: usize) -> bool {
+        b.scopes[scope].implied_bases.iter().all(|qn| {
+            qn.is_global
+                && qn.segments.first().is_some_and(|first| {
+                    let root = &b.scopes[0];
+                    root.names.get(&first.value).is_none()
+                        && root.effective_names.get(&first.value).is_none()
+                        && !root.aliases.iter().any(|(name, _, _)| name == &first.value)
+                        && root.imports.is_empty()
+                        && root.member_imports.is_empty()
+                })
+                && (b.external_implied_names.is_empty()
+                    || !b.external_implied_names.contains_key(
+                        &qn.segments
+                            .iter()
+                            .map(|s| s.value.as_str())
+                            .collect::<Vec<_>>()
+                            .join("::"),
+                    ))
+        })
+    }
+
+    pub(super) fn build(b: &Builder) -> Self {
+        let prefix = b
+            .recorded_lookup_prefix
+            .as_ref()
+            .filter(|g| g.compatible_prefix(b));
+        let start_element = prefix.map_or(0, |g| g.element_count);
+        let start_scope = prefix.map_or(0, |g| g.nodes.len());
+        let mut ids = prefix.map_or_else(LayeredMap::default, |g| g.ids.clone());
+        for (e, element) in b.elements.iter().enumerate().skip(start_element) {
+            ids.insert(element.id, e);
+        }
+        let target = |r: usize, key: &str| {
+            b.elements[r]
+                .props
+                .get(key)
+                .and_then(|v| v.as_reference())
+                .and_then(|id| ids.get(&id).copied())
+        };
+        let mut graph = prefix.map_or_else(Self::default, |g| g.as_ref().clone());
+        // Only a build that records its library outcomes reads the misses.
+        let attribute = b.lib_record.is_some();
+        graph.nodes.resize(b.scopes.len(), None);
+        graph.element_count = b.elements.len();
+        for (e, element) in b.elements.iter().enumerate().skip(start_element) {
+            if conforms(element.ty, "Feature") {
+                graph.features.insert(e, ());
+            }
+            let positional_source = conforms(element.ty, "Usage")
+                || element.props.get("isEnd").and_then(|v| v.as_bool()) == Some(true)
+                || element.owning_relationship.is_some_and(|r| {
+                    conforms(b.elements[r].ty, "ParameterMembership")
+                        || conforms(b.elements[r].ty, "ReturnParameterMembership")
+                });
+            let positional_source = positional_source
+                || element
+                    .props
+                    .get("direction")
+                    .and_then(|v| v.as_str())
+                    .is_some();
+            let mut targets = if positional_source {
+                None
+            } else {
+                Some(Vec::new())
+            };
+            let mut misses = Vec::new();
+            for &r in &element.owned_relationships {
+                if conforms(b.elements[r].ty, "Redefinition") {
+                    note(&mut misses, &b.ref_misses, r);
+                    match (targets.as_mut(), target(r, "redefinedFeature")) {
+                        (Some(targets), Some(t)) => targets.push(t),
+                        _ => targets = None,
+                    }
+                }
+            }
+            if targets.as_ref().is_none_or(|v| !v.is_empty()) {
+                graph.redefinitions.insert(e, targets);
+                keep(&mut graph.redefinition_misses, e, misses);
+            }
+        }
+        // Header starting contexts are independent of whether Membership
+        // selection is fully recorded. Each context may still need ordinary
+        // imports, implied heritage or positional lookup. Freeze their stored
+        // explicit endpoints with the rest of this pass's snapshot.
+        for (s, scope) in b.scopes.iter().enumerate().skip(start_scope) {
+            if let Some(owner) = scope.owner.filter(|&e| conforms(b.elements[e].ty, "Type")) {
+                let mut misses = Vec::new();
+                for &r in &b.elements[owner].owned_relationships {
+                    if conforms(b.elements[r].ty, "Specialization") {
+                        note(&mut misses, &b.ref_misses, r);
+                    }
+                }
+                let bases: Option<Vec<_>> = b.elements[owner]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .filter(|&r| conforms(b.elements[r].ty, "Specialization"))
+                    .map(|r| {
+                        [
+                            "general",
+                            "superclassifier",
+                            "type",
+                            "subsettedFeature",
+                            "redefinedFeature",
+                            "referencedFeature",
+                            "crossedFeature",
+                        ]
+                        .iter()
+                        .find_map(|key| target(r, key))
+                        .and_then(|e| b.elem_scope.get(&e).copied())
+                    })
+                    .collect();
+                keep(&mut graph.header_misses, s, misses);
+                if let Some(bases) = bases {
+                    if scope.chain_bases.is_empty() && bases.len() == scope.bases.len() {
+                        graph.header_bases.insert(s, bases);
+                    }
+                }
+            }
+            let Some((owner, owned_features)) = Self::scope_inputs(b, s) else {
+                continue;
+            };
+            let implied = Self::implied_roots(scope);
+            if attribute {
+                let mut inputs = implied.clone();
+                for &r in &b.elements[owner].owned_relationships {
+                    let relation = &b.elements[r];
+                    if conforms(relation.ty, "Specialization")
+                        || (conforms(relation.ty, "Membership")
+                            && !conforms(relation.ty, "OwningMembership"))
+                    {
+                        note(&mut inputs, &b.ref_misses, r);
+                    }
+                }
+                keep(&mut graph.input_misses, s, inputs);
+            }
+            graph.absent_roots.extend(implied);
+            let mut node = Node {
+                bases: Vec::new(),
+                owned: Vec::new(),
+                owned_features,
+            };
+            let mut complete = true;
+            let mut written_bases = 0;
+            for &r in &b.elements[owner].owned_relationships {
+                let relation = &b.elements[r];
+                if conforms(relation.ty, "Specialization") {
+                    written_bases += 1;
+                    let general = [
+                        "general",
+                        "superclassifier",
+                        "type",
+                        "subsettedFeature",
+                        "redefinedFeature",
+                        "referencedFeature",
+                        "crossedFeature",
+                    ]
+                    .iter()
+                    .find_map(|key| target(r, key));
+                    if let Some(t) = general {
+                        if let Some(&base) = b.elem_scope.get(&t) {
+                            node.bases.push(base);
+                        } else {
+                            complete = false;
+                        }
+                    } else {
+                        complete = false;
+                    }
+                }
+                if !conforms(relation.ty, "Membership") {
+                    continue;
+                }
+                let visibility = match relation.props.get("visibility").and_then(|v| v.as_str()) {
+                    Some("private") => continue,
+                    Some("protected") => LookupAccess::Protected,
+                    _ => LookupAccess::Public,
+                };
+                let member = if conforms(relation.ty, "OwningMembership") {
+                    relation.children.first().copied()
+                } else {
+                    target(r, "memberElement")
+                };
+                let Some(member) = member else {
+                    complete = false;
+                    continue;
+                };
+                let alias = !conforms(relation.ty, "OwningMembership");
+                let props = if alias {
+                    &relation.props
+                } else {
+                    &b.elements[member].props
+                };
+                let keys = if alias {
+                    ["memberName", "memberShortName"]
+                } else {
+                    ["declaredName", "declaredShortName"]
+                };
+                let names: Vec<_> = keys
+                    .iter()
+                    .filter_map(|key| props.get(key).and_then(|v| v.as_str()).map(str::to_owned))
+                    .collect();
+                // Unnamed Features can acquire effective names through several
+                // specialization rules. Leave those contexts to the resolver.
+                if names.is_empty() && graph.features.contains_key(&member) {
+                    complete = false;
+                }
+                graph.members.insert(
+                    r,
+                    Member {
+                        target: member,
+                        scope: b.elem_scope.get(&member).copied(),
+                        names,
+                        visibility,
+                        alias,
+                    },
+                );
+                node.owned.push(r);
+            }
+            if complete && written_bases == scope.bases.len() {
+                graph.nodes[s] = Some(node);
+            }
+        }
+        graph.ids = ids;
+        // Alias proofs read the same filtered inherited Membership projection
+        // as lookup. Invalidating a provider can invalidate another proof, so
+        // repeat monotonically; each non-final round removes at least one node.
+        // Whether a node survives depends on what its proof read; the proofs
+        // share their binding memo, so each proven node takes all of it.
+        let mut proof_misses = Vec::new();
+        let mut proven = Vec::new();
+        loop {
+            let mut invalid = Vec::new();
+            {
+                let mut proof = AliasProof {
+                    b,
+                    graph: &mut graph,
+                    active: HashSet::new(),
+                    bindings: HashMap::new(),
+                    misses: Vec::new(),
+                };
+                for (s, scope) in b.scopes.iter().enumerate().skip(start_scope) {
+                    if proof.graph.nodes[s].is_none() {
+                        continue;
+                    }
+                    for (_, qn, alias) in &scope.aliases {
+                        if !b.import_admitted(*alias, LookupAccess::Protected) {
+                            continue;
+                        }
+                        let Some(member) = proof.graph.members.get(alias).map(|m| m.target) else {
+                            continue;
+                        };
+                        proven.push(s);
+                        proof.active.insert(*alias);
+                        let certified = proof.target(s, qn, 0);
+                        proof.active.remove(alias);
+                        if certified != Some(member) {
+                            invalid.push(s);
+                            break;
+                        }
+                    }
+                }
+                super::note_misses(&mut proof_misses, &proof.misses);
+            }
+            if invalid.is_empty() {
+                break;
+            }
+            for scope in invalid {
+                graph.nodes[scope] = None;
+            }
+            // The immutable library prefix was certified before freezing;
+            // only the newly appended projections depend on these nodes.
+            graph.inherited = prefix.map_or_else(LayeredMap::default, |g| g.inherited.clone());
+            graph.suppressed = prefix.map_or_else(LayeredMap::default, |g| g.suppressed.clone());
+            graph.collected_misses.clear();
+        }
+        if attribute && !proof_misses.is_empty() {
+            proven.sort_unstable();
+            proven.dedup();
+            for s in proven {
+                let mut inputs = graph
+                    .input_misses
+                    .get(s)
+                    .map_or_else(Vec::new, |m| m.to_vec());
+                super::note_misses(&mut inputs, &proof_misses);
+                keep(&mut graph.input_misses, s, inputs);
+            }
+            // Projections the proofs memoized read these inputs before.
+            graph.inherited = prefix.map_or_else(LayeredMap::default, |g| g.inherited.clone());
+            graph.suppressed = prefix.map_or_else(LayeredMap::default, |g| g.suppressed.clone());
+            graph.collected_misses.clear();
+        }
+        // A redefinition resolves from the header bases of the Type owning
+        // its redefining feature once the graph is ready, which a lexical
+        // bootstrap cannot anticipate: such a header needs the later passes.
+        graph.has_ordered_headers |=
+            b.elements
+                .iter()
+                .enumerate()
+                .skip(start_element)
+                .any(|(feature, element)| {
+                    element
+                        .owned_relationships
+                        .iter()
+                        .any(|&r| conforms(b.elements[r].ty, "Redefinition"))
+                        && b.owner_elem(feature)
+                            .and_then(|owner| b.elem_scope.get(&owner))
+                            .is_some_and(|&scope| {
+                                graph.header_bases.get(&scope).is_some_and(|bases| {
+                                    !bases.is_empty() || graph.nodes[scope].is_some()
+                                })
+                            })
+                });
+        graph
+    }
+
+    fn compatible_prefix(&self, b: &Builder) -> bool {
+        self.element_count == b.lib_boundary
+            && self.element_count <= b.elements.len()
+            && self.nodes.len() <= b.scopes.len()
+            && b.external_implied_names.is_empty()
+            && b.scopes[0].imports.is_empty()
+            && b.scopes[0].member_imports.is_empty()
+            && b.scopes[0].filters.is_empty()
+            && self.absent_roots.iter().all(|name| {
+                let root = &b.scopes[0];
+                root.names.get(name).is_none()
+                    && root.effective_names.get(name).is_none()
+                    && !root.aliases.iter().any(|(n, _, _)| n == name)
+            })
+    }
+
+    /// After a pass that changed no outcome, the graph the pass read is the
+    /// one a build from these outcomes would make, apart from what the pass
+    /// memoized and collected while reading it: reset those as a build does.
+    pub(super) fn settle(&mut self, b: &Builder) {
+        let prefix = b
+            .recorded_lookup_prefix
+            .as_ref()
+            .filter(|g| g.compatible_prefix(b));
+        self.inherited = prefix.map_or_else(LayeredMap::default, |g| g.inherited.clone());
+        self.suppressed = prefix.map_or_else(LayeredMap::default, |g| g.suppressed.clone());
+        self.collected_misses.clear();
+        note_settled();
+    }
+
+    pub(super) fn freeze(&mut self) {
+        self.nodes.freeze();
+        self.members.freeze();
+        self.header_bases.freeze();
+        self.features.freeze();
+        self.redefinitions.freeze();
+        self.inherited.freeze();
+        self.suppressed.freeze();
+        self.ids.freeze();
+        // Builds on a prepared library never record resolution outcomes.
+        self.input_misses.clear();
+        self.redefinition_misses.clear();
+        self.header_misses.clear();
+        self.collected_misses.clear();
+    }
+
+    /// The rows by id, when the table is frozen whole.
+    pub(super) fn frozen_ids(&self) -> Option<Arc<crate::layered::IdMap<uuid::Uuid, usize>>> {
+        self.ids.frozen_arc().cloned()
+    }
+
+    pub(super) fn has_replay_context(&mut self) -> bool {
+        // Whether passes follow is not an outcome of any one reference.
+        let misses = &mut Vec::new();
+        self.has_ordered_headers
+            || (0..self.nodes.len()).any(|s| {
+                self.nodes[s]
+                    .as_ref()
+                    .is_some_and(|node| !node.bases.is_empty())
+                    && self.direct_bases(s, misses).is_some()
+            })
+    }
+
+    /// The header bases of `scope`; the root misses behind them (or behind
+    /// their absence) join `misses`.
+    pub(super) fn header_bases(
+        &self,
+        scope: usize,
+        misses: &mut Vec<String>,
+    ) -> Option<Vec<usize>> {
+        note(misses, &self.header_misses, scope);
+        self.header_bases.get(&scope).cloned()
+    }
+
+    /// The direct bases of `scope` when every inherited projection they
+    /// need is recorded; the root misses behind that answer join `misses`.
+    pub(super) fn direct_bases(
+        &mut self,
+        scope: usize,
+        misses: &mut Vec<String>,
+    ) -> Option<Vec<usize>> {
+        note(misses, &self.input_misses, scope);
+        let bases = self.nodes.get(scope)?.as_ref()?.bases.clone();
+        for &base in &bases {
+            self.collect(base, false, misses)?;
+        }
+        Some(bases)
+    }
+
+    fn closure(&self, source: usize, misses: &mut Vec<String>) -> Option<HashSet<usize>> {
+        let mut found = HashSet::new();
+        let mut todo = vec![source];
+        while let Some(e) = todo.pop() {
+            if !found.insert(e) {
+                continue;
+            }
+            if let Some(targets) = self.redefinitions.get(&e) {
+                note(misses, &self.redefinition_misses, e);
+                todo.extend(targets.as_ref()?.iter().copied());
+            }
+        }
+        Some(found)
+    }
+
+    /// The inherited projection of `root`; the root misses behind it — or
+    /// behind its absence — join `misses`.
+    fn collect(
+        &mut self,
+        root: usize,
+        skip_owned: bool,
+        misses: &mut Vec<String>,
+    ) -> Option<Arc<Vec<usize>>> {
+        if !skip_owned {
+            if let Some(result) = self.inherited.get(&root) {
+                note(misses, &self.collected_misses, root);
+                return result.clone();
+            }
+        }
+        let mut read = Vec::new();
+        let result = self.collect_uncached(root, skip_owned, &mut read);
+        super::note_misses(misses, &read);
+        if !skip_owned {
+            self.inherited.insert(root, result.clone());
+            keep(&mut self.collected_misses, root, read);
+        }
+        result
+    }
+
+    /// `read` gathers the root misses behind every node, projection and
+    /// redefinition the answer reads, including one it gave up on.
+    fn collect_uncached(
+        &mut self,
+        root: usize,
+        skip_owned: bool,
+        read: &mut Vec<String>,
+    ) -> Option<Arc<Vec<usize>>> {
+        if !skip_owned {
+            if let Some(value) = self.inherited.get(&root) {
+                note(read, &self.collected_misses, root);
+                return value.clone();
+            }
+        }
+        let mut state = HashMap::new();
+        let mut order = Vec::new();
+        let mut todo = vec![(root, false)];
+        while let Some((s, exiting)) = todo.pop() {
+            if s != root && self.inherited.contains_key(&s) {
+                note(read, &self.collected_misses, s);
+                continue;
+            }
+            if exiting {
+                state.insert(s, 2);
+                order.push(s);
+                continue;
+            }
+            match state.get(&s) {
+                Some(1) => return None,
+                Some(2) => continue,
+                _ => {}
+            }
+            note(read, &self.input_misses, s);
+            let node = self.nodes.get(s)?.as_ref()?;
+            state.insert(s, 1);
+            todo.push((s, true));
+            todo.extend(node.bases.iter().rev().map(|&base| (base, false)));
+        }
+        let mut result = None;
+        for s in order {
+            let node = self.nodes[s].as_ref()?.clone();
+            // What this scope's projection reads, kept with its memo.
+            let mut here = Vec::new();
+            note(&mut here, &self.input_misses, s);
+            let mut rows = Vec::new();
+            let mut seen = HashSet::new();
+            let mut suppressed = Vec::new();
+            let mut suppressed_seen = HashSet::new();
+            for base in node.bases {
+                note(&mut here, &self.collected_misses, base);
+                note(read, &self.collected_misses, base);
+                if let Some(prior) = self.suppressed.get(&base) {
+                    for &m in prior.iter() {
+                        if suppressed_seen.insert(m) {
+                            suppressed.push(m);
+                        }
+                    }
+                }
+                let base_node = self.nodes[base].as_ref()?;
+                let inherited = self.inherited.get(&base)?.as_ref()?;
+                for &m in base_node.owned.iter().chain(inherited.iter()) {
+                    if seen.insert(m) {
+                        rows.push(m);
+                    }
+                }
+            }
+            let mut owned_direct = HashSet::new();
+            if !(s == root && skip_owned) {
+                for feature in node.owned_features {
+                    if let Some(targets) = self.redefinitions.get(&feature) {
+                        note(&mut here, &self.redefinition_misses, feature);
+                        note(read, &self.redefinition_misses, feature);
+                        owned_direct.extend(targets.as_ref()?.iter().copied());
+                    }
+                }
+            }
+            let mut counts = HashMap::new();
+            for &m in &rows {
+                let e = self.members.get(&m)?.target;
+                if self.features.contains_key(&e) {
+                    *counts.entry(e).or_insert(0usize) += 1;
+                }
+            }
+            let mut removed = HashSet::new();
+            for (&e, &count) in &counts {
+                let Some(closure) = self.closure(e, &mut here) else {
+                    super::note_misses(read, &here);
+                    return None;
+                };
+                removed.extend(closure.iter().copied().filter(|&t| t != e || count > 1));
+                if !closure.is_disjoint(&owned_direct) {
+                    removed.insert(e);
+                }
+            }
+            super::note_misses(read, &here);
+            rows.retain(|m| {
+                let retain = !self
+                    .features
+                    .contains_key(&self.members.get(m).unwrap().target)
+                    || !removed.contains(&self.members.get(m).unwrap().target);
+                if !retain && suppressed_seen.insert(*m) {
+                    suppressed.push(*m);
+                }
+                retain
+            });
+            self.suppressed.insert(s, Arc::new(suppressed));
+            let rows = Arc::new(rows);
+            if s != root || !skip_owned {
+                self.inherited.insert(s, Some(Arc::clone(&rows)));
+                keep(&mut self.collected_misses, s, here);
+            }
+            if s == root {
+                result = Some(rows);
+            }
+        }
+        result
+    }
+
+    /// Inherited members of `scope` named `name`; the root misses behind the
+    /// answer — or behind its absence — join `misses`.
+    pub(super) fn select(
+        &mut self,
+        scope: usize,
+        name: &str,
+        access: LookupAccess,
+        exclude: Option<usize>,
+        skip_owned: bool,
+        misses: &mut Vec<String>,
+    ) -> Option<(Vec<LookupResult>, bool)> {
+        let rows = self.collect(scope, skip_owned, misses)?;
+        let hits: Vec<_> = rows
+            .iter()
+            .filter_map(|m| {
+                let member = &self.members.get(m).unwrap();
+                (Some(member.target) != exclude
+                    && access.inherited().admits(member.visibility)
+                    && member.names.iter().any(|n| n == name))
+                .then_some(LookupResult::Found(
+                    member.target,
+                    member.scope,
+                    member.alias.then_some(*m),
+                ))
+            })
+            .collect();
+        let suppressed = hits.is_empty()
+            && self.suppressed.get(&scope).is_some_and(|rows| {
+                rows.iter().any(|m| {
+                    let member = &self.members.get(m).unwrap();
+                    Some(member.target) != exclude
+                        && access.inherited().admits(member.visibility)
+                        && member.names.iter().any(|n| n == name)
+                })
+            });
+        Some((hits, suppressed))
+    }
+}
+
+/// Resolution mutates pending properties and query state, never declaration
+/// topology. Keep one bounded rollback point instead of cloning every element,
+/// source scope and expression table before each fixed-point pass.
+pub(super) struct Checkpoint {
+    properties: Vec<(usize, crate::properties::Properties)>,
+    spec_resolved: crate::layered::LayeredVec<Option<usize>>,
+    spec_misses: MissTable,
+    ref_misses: MissTable,
+    semantic_memo: crate::semantic_memo::SemanticMemo,
+    metadata: super::metadata_associations::Snapshot,
+    unresolved: Vec<(usize, super::QualifiedName)>,
+    ambiguous: Vec<(usize, super::QualifiedName)>,
+    blocked: Vec<super::BlockedSite>,
+    sites: Vec<super::RefSite>,
+    used: crate::layered::IdSet<usize>,
+    roots: HashSet<String>,
+    identity_pending: Vec<super::PendingRef>,
+    pub(super) lib_record: Option<Vec<(Option<uuid::Uuid>, Vec<String>)>>,
+    library_refs_to_users: bool,
+    query_imports: super::ImportWalks,
+    current_misses: Vec<String>,
+    exclude: Option<usize>,
+    declared_only: bool,
+    identity_origin: Option<usize>,
+    header_owner: Option<usize>,
+    header_base: Option<usize>,
+    suppressed: bool,
+    probing: bool,
+    widen: Option<(usize, LookupAccess)>,
+    element_count: usize,
+    scope_count: usize,
+}
+impl Checkpoint {
+    pub(super) fn capture(b: &Builder, pending: &[super::PendingRef]) -> Self {
+        let mut seen = HashSet::new();
+        Self {
+            properties: pending
+                .iter()
+                .filter(|p| seen.insert(p.elem))
+                .map(|p| (p.elem, b.elements[p.elem].props.clone()))
+                .collect(),
+            spec_resolved: b.spec_resolved.clone(),
+            spec_misses: b.spec_misses.clone(),
+            ref_misses: b.ref_misses.clone(),
+            semantic_memo: b.semantic_memo.clone(),
+            metadata: b.metadata_snapshot(),
+            unresolved: b.unresolved.clone(),
+            ambiguous: b.ambiguous.clone(),
+            blocked: b.blocked.clone(),
+            sites: b.ref_sites.clone(),
+            used: b.used_imports.clone(),
+            roots: b.root_misses.clone(),
+            identity_pending: b.id_binding_pending.clone(),
+            lib_record: b.lib_record.clone(),
+            library_refs_to_users: b.library_refs_to_users,
+            query_imports: b.query_imports.clone(),
+            current_misses: b.current_misses.clone(),
+            exclude: b.exclude,
+            declared_only: b.declared_only,
+            identity_origin: b.identity_origin_unit,
+            header_owner: b.redefinition_lookup_owner,
+            header_base: b.redefinition_lookup_base,
+            suppressed: b.recorded_lookup_suppressed,
+            probing: b.probing,
+            widen: b.widen,
+            element_count: b.elements.len(),
+            scope_count: b.scopes.len(),
+        }
+    }
+    pub(super) fn restore(&self, b: &mut Builder) {
+        debug_assert_eq!(b.elements.len(), self.element_count);
+        debug_assert_eq!(b.scopes.len(), self.scope_count);
+        for (e, props) in &self.properties {
+            b.elements[*e].props = props.clone();
+        }
+        b.restore_metadata_snapshot(&self.metadata);
+        b.spec_resolved = self.spec_resolved.clone();
+        b.spec_misses = self.spec_misses.clone();
+        b.ref_misses = self.ref_misses.clone();
+        b.semantic_memo = self.semantic_memo.clone();
+        b.unresolved = self.unresolved.clone();
+        b.ambiguous = self.ambiguous.clone();
+        b.blocked = self.blocked.clone();
+        b.ref_sites = self.sites.clone();
+        b.used_imports = self.used.clone();
+        b.root_misses = self.roots.clone();
+        b.id_binding_pending = self.identity_pending.clone();
+        b.lib_record = self.lib_record.clone();
+        b.library_refs_to_users = self.library_refs_to_users;
+        b.query_imports = self.query_imports.clone();
+        b.current_misses = self.current_misses.clone();
+        b.exclude = self.exclude;
+        b.declared_only = self.declared_only;
+        b.identity_origin_unit = self.identity_origin;
+        b.redefinition_lookup_owner = self.header_owner;
+        b.redefinition_lookup_base = self.header_base;
+        b.recorded_lookup_suppressed = self.suppressed;
+        b.probing = self.probing;
+        b.widen = self.widen;
+        b.pending.clear();
+        b.lib_hints = None;
+        b.replay_completions = None;
+        b.reset_lookup_caches();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{json::ResolvedModel, libcache::LibraryCache, model::Model};
+    use sysmlv2_syntax::ast::QualifiedName;
+
+    /// Replay passes may take a recorded library outcome again, but only a
+    /// target: a recorded miss is resolved afresh, so a library name that is
+    /// ambiguous (not missing) is reported as a cold build reports it.
+    #[test]
+    fn replayed_library_misses_keep_cold_classification() {
+        let library = "standard library package L { \
+            package A { class X; } package B { class X; } \
+            private import A::*; private import B::*; \
+            class P { feature f; } class Q :> P { feature redefines f; } \
+            class Y :> X; class Z :> Missing; }";
+        let user = "class C :> L::Q { feature redefines f; }";
+        let mut base = Model::new();
+        assert!(
+            base.add_library_source("lib.kerml", library)
+                .diagnostics
+                .is_empty()
+        );
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let build = |warm: bool| {
+            let mut model = Model::new();
+            model.add_library_source("lib.kerml", library);
+            if warm {
+                model.set_library_cache(cache.clone());
+            }
+            assert!(model.add_source("user.kerml", user).diagnostics.is_empty());
+            ResolvedModel::build(&model)
+        };
+        let names = |refs: &[(usize, QualifiedName)]| {
+            refs.iter()
+                .map(|(e, qn)| (*e, qn.to_ref_string()))
+                .collect::<Vec<_>>()
+        };
+        let (cold, warm) = (build(false), build(true));
+        assert_eq!(names(&cold.b.ambiguous).len(), 1, "`X` is ambiguous");
+        assert_eq!(names(&cold.b.unresolved).len(), 1, "`Missing` is missing");
+        assert_eq!(names(&warm.b.ambiguous), names(&cold.b.ambiguous));
+        assert_eq!(names(&warm.b.unresolved), names(&cold.b.unresolved));
+    }
+}
+
+#[cfg(test)]
+thread_local! {
+    static SETTLED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+#[cfg(test)]
+pub(super) fn settled_passes() -> usize {
+    SETTLED.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_settled() {
+    SETTLED.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+fn note_settled() {}
+
+#[cfg(test)]
+mod settle_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    /// A redefinition chain the bootstrap already resolves: the first redo
+    /// pass changes nothing, and the loop settles the graph it read instead
+    /// of building another; the settled graph is one built from the final
+    /// rows in every table, with and without a recording's miss tables.
+    #[test]
+    fn a_confirming_pass_settles_the_graph_it_read() {
+        for recording in [false, true] {
+            let mut model = Model::new();
+            let parsed = model.add_source(
+                "chain.kerml",
+                "class A { feature x; } class B :> A { feature :>> x; } \
+                 class C :> B { feature :>> x; } class D :> C { feature :>> x; }",
+            );
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            if recording {
+                model.record_library_cache();
+            }
+            let settled_before = settled_passes();
+            let r = ResolvedModel::build(&model);
+            assert!(
+                settled_passes() > settled_before,
+                "the build ended on a pass that changed nothing"
+            );
+            assert!(
+                r.b.recorded_lookup_graph.is_some(),
+                "the settled graph is kept"
+            );
+            let mut settled = r.b.recorded_lookup_graph.clone().unwrap();
+            let mut fresh = Graph::build(&r.b);
+            let mut misses = Vec::new();
+            assert_eq!(settled.has_replay_context(), fresh.has_replay_context());
+            assert_eq!(settled.element_count, fresh.element_count);
+            assert_eq!(settled.absent_roots, fresh.absent_roots);
+            assert_eq!(settled.has_ordered_headers, fresh.has_ordered_headers);
+            let scopes = r.b.scopes.len();
+            let elements = r.b.elements.len();
+            let table = |t: &MissTable, n: usize| {
+                (0..n)
+                    .map(|i| t.get(i).map(|m| m.to_vec()))
+                    .collect::<Vec<_>>()
+            };
+            for scope in 0..scopes {
+                assert_eq!(
+                    settled.nodes[scope], fresh.nodes[scope],
+                    "node of scope {scope}"
+                );
+                assert_eq!(
+                    settled.header_bases.get(&scope),
+                    fresh.header_bases.get(&scope),
+                    "header bases of scope {scope}"
+                );
+                assert_eq!(
+                    settled.header_bases(scope, &mut misses),
+                    fresh.header_bases(scope, &mut misses),
+                    "header bases read for scope {scope}"
+                );
+                assert_eq!(
+                    settled.direct_bases(scope, &mut misses),
+                    fresh.direct_bases(scope, &mut misses),
+                    "bases of scope {scope}"
+                );
+            }
+            // A recording's miss tables grow after the settle (the root-import
+            // pseudo miss joins every outcome's misses at the end of the
+            // build), so a graph built then differs from the settled one
+            // there by design: compared only where nothing is recorded.
+            if !recording {
+                assert_eq!(
+                    table(&settled.header_misses, scopes),
+                    table(&fresh.header_misses, scopes)
+                );
+                assert_eq!(
+                    table(&settled.input_misses, scopes),
+                    table(&fresh.input_misses, scopes)
+                );
+                assert_eq!(
+                    table(&settled.redefinition_misses, elements),
+                    table(&fresh.redefinition_misses, elements)
+                );
+            }
+            // (`inherited`, `suppressed` and `collected_misses` are memos the
+            // lookups after the settle fill again, as they would a fresh graph's.)
+            for e in 0..elements {
+                assert_eq!(settled.members.get(&e), fresh.members.get(&e), "member {e}");
+                assert_eq!(
+                    settled.redefinitions.get(&e),
+                    fresh.redefinitions.get(&e),
+                    "redefinitions of {e}"
+                );
+                assert_eq!(
+                    settled.features.contains_key(&e),
+                    fresh.features.contains_key(&e)
+                );
+            }
+            // `ids` is a build-time table of the identities the rows had when
+            // the graph was built, which the identity assignment after the
+            // settle rewrote for a fresh build: compared by count only.
+            assert_eq!(settled.ids.iter().count(), fresh.ids.iter().count());
+            // the chain's three redefinitions each resolved to a feature
+            let redefinitions: Vec<_> = (0..elements)
+                .filter(|&e| r.b.elements[e].ty == "Redefinition")
+                .collect();
+            assert_eq!(redefinitions.len(), 3);
+            for &e in &redefinitions {
+                let target = r.b.elements[e]
+                    .props
+                    .get("redefinedFeature")
+                    .and_then(|v| v.as_reference())
+                    .expect("resolved");
+                let target_row = fresh.ids.get(&target).copied().expect("a row");
+                assert_eq!(r.b.elements[target_row].ty, "Feature");
+            }
+            if recording {
+                assert!(
+                    (0..scopes).any(|s| settled.input_misses.get(s).is_some()),
+                    "a recording attributes misses"
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/redefinition_provenance.rs b/crates/sysmlv2-model/src/json/redefinition_provenance.rs
new file mode 100644
index 0000000..f2a7225
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/redefinition_provenance.rs
@@ -0,0 +1,145 @@
+//! Read-side provenance for explicit redefinition headers.
+use super::provider_completeness::ProviderCompleteness;
+use super::{LookupAccess, LookupResult, RefSite, ResolvedModel, recorded_lookup};
+use std::collections::HashMap;
+
+impl ResolvedModel {
+    /// Unqualified explicit redefinitions that resolve through an enclosing
+    /// namespace rather than within the selected direct general's members.
+    /// Each result contains the reference site and its unqualified spelling.
+    ///
+    /// This is an authoring heuristic, not a language validation error.
+    /// Only owners with recorded explicit general contexts are considered.
+    /// Qualified, unresolved, identity-spelled and incomplete contexts are
+    /// omitted. Selection follows header base order and preserves imported and
+    /// aliased members of the general itself. Import provenance is recomputed,
+    /// so library-cache replay does not change the result. Filters, recursive
+    /// imports, chained bases, cycles and exhausted proof budgets conservatively
+    /// suppress findings; exact member imports do not require unrelated providers.
+    pub fn redefinitions_outside_inheritance(&mut self) -> Vec<(RefSite, String)> {
+        let b = &mut self.b;
+        if !b.recorded_lookup_ready || b.recorded_lookup_incomplete {
+            return Vec::new();
+        }
+        let sites: HashMap<_, _> = b
+            .ref_sites
+            .iter()
+            .filter(|s| s.kind == "redefinedFeature" && s.plain)
+            .filter_map(|s| Some(((s.exclude?.0, s.span.start, s.span.end), s.clone())))
+            .collect();
+        let candidates: Vec<_> = b
+            .spec_targets
+            .iter()
+            .filter(|(e, kind, _, qn)| {
+                *e >= b.lib_boundary
+                    && *kind == "Redefinition"
+                    && !qn.is_global
+                    && qn.segments.len() == 1
+            })
+            .filter_map(|(e, _, _, qn)| {
+                sites
+                    .get(&(*e, qn.span.start, qn.span.end))
+                    .map(|s| (*e, qn.clone(), s.clone()))
+            })
+            .collect();
+        if candidates.is_empty() {
+            return Vec::new();
+        }
+        if b.recorded_lookup_graph.is_none() {
+            b.recorded_lookup_graph = Some(recorded_lookup::Graph::build(b));
+        }
+        // Queries may fill memo tables, but must not alter import-use or
+        // caller lookup context. Do not use visibility-probing mode: it
+        // deliberately widens access, which would misclassify private names.
+        let saved = (
+            b.exclude,
+            b.declared_only,
+            b.redefinition_lookup_owner,
+            b.redefinition_lookup_base,
+            b.recorded_lookup_suppressed,
+            b.identity_origin_unit,
+        );
+        let used = b.used_imports.clone();
+        let imports = b.query_imports.clone();
+        let misses = b.current_misses.clone();
+        let roots = b.root_misses.clone();
+        let mut out = Vec::new();
+        let mut completeness = ProviderCompleteness::default();
+        let mut proof_steps = 0;
+        for (feature, qn, site) in candidates {
+            b.exclude = None;
+            b.declared_only = false;
+            b.redefinition_lookup_owner = None;
+            b.redefinition_lookup_base = None;
+            b.recorded_lookup_suppressed = false;
+            b.identity_origin_unit = Some(site.unit);
+            let Some(owner) = b.owner_elem(feature) else {
+                continue;
+            };
+            let Some(&scope) = b.elem_scope.get(&owner) else {
+                continue;
+            };
+            let Some(bases) = b
+                .recorded_lookup_graph
+                .as_ref()
+                .unwrap()
+                .header_bases(scope, &mut Vec::new())
+            else {
+                continue;
+            };
+            if !completeness.scope(b, scope, &mut proof_steps) {
+                continue;
+            }
+            let inherited = b.inherited_bindings(scope, true);
+            if inherited.incomplete || inherited.truncated {
+                continue;
+            }
+            if bases.iter().any(|&base| {
+                let inherited = b.inherited_bindings(base, true);
+                inherited.incomplete || inherited.truncated
+            }) {
+                continue;
+            }
+            b.exclude = Some(feature);
+            if b.id_spelled_target(site.scope.0, &qn).is_some() {
+                continue;
+            }
+            for base in bases {
+                let hit = b.resolve_result(base, &qn, 0, false);
+                if let LookupResult::Found(target, _, _) = hit {
+                    if !crate::metaclass::conforms(b.elements[target].ty, "Feature") {
+                        continue;
+                    }
+                    // If the model no longer reproduces the stored endpoint,
+                    // do not infer intent from an approximate lookup.
+                    if target == site.target.0 {
+                        let stamp = b.next_stamp();
+                        if matches!(
+                            b.lookup_at(base, &qn.segments[0].value, 0, stamp, LookupAccess::All),
+                            LookupResult::Missing
+                        ) {
+                            let inherited = b.inherited_bindings(base, true);
+                            if !inherited.incomplete && !inherited.truncated {
+                                out.push((site.clone(), qn.segments[0].value.clone()));
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        (
+            b.exclude,
+            b.declared_only,
+            b.redefinition_lookup_owner,
+            b.redefinition_lookup_base,
+            b.recorded_lookup_suppressed,
+            b.identity_origin_unit,
+        ) = saved;
+        b.used_imports = used;
+        b.query_imports = imports;
+        b.current_misses = misses;
+        b.root_misses = roots;
+        out
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/replay_dependencies_tests.rs b/crates/sysmlv2-model/src/json/replay_dependencies_tests.rs
new file mode 100644
index 0000000..9168d5a
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/replay_dependencies_tests.rs
@@ -0,0 +1,413 @@
+//! A library resolution recording replays an outcome only while the root
+//! names its resolution missed stay missing. Resolution also reads state
+//! that outlives the reference being resolved — lookup caches, other
+//! references' recorded outcomes, the recorded lookup graph — so an outcome
+//! depends on the names missed while that state was computed, whichever
+//! reference computed it. Each case builds a library whose later references
+//! reach a root name only through such state, adds a model that supplies
+//! the name, and compares every replaying path with a cold build. The last
+//! cases vary whether resolution runs its later passes at all.
+
+use super::derived::{Derived, DerivedValue, Reference};
+use super::{ResolvedModel, library_to_compact_json, model_to_compact_json};
+use crate::libcache::LibraryCache;
+use crate::model::Model;
+use serde_json::Value;
+use std::path::{Path, PathBuf};
+
+/// A library directory under a fresh temporary root, removed on drop.
+struct LibraryDir {
+    root: PathBuf,
+}
+
+impl LibraryDir {
+    fn new(library: &str, extension: &str) -> Self {
+        let root = std::env::temp_dir().join(format!("sysml-replay-deps-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(root.join("library")).unwrap();
+        std::fs::write(
+            root.join("library").join(format!("Lib.{extension}")),
+            library,
+        )
+        .unwrap();
+        Self { root }
+    }
+
+    fn dir(&self) -> PathBuf {
+        self.root.join("library")
+    }
+
+    fn recording(&self) -> PathBuf {
+        self.root.join("cache").join("stdlib.libcache")
+    }
+}
+
+impl Drop for LibraryDir {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.root);
+    }
+}
+
+/// The library as the directory loader reads it: the file, then the
+/// ambient units.
+fn library_model(dir: &Path) -> Model {
+    let mut model = Model::new();
+    model.load_library_dir(dir).unwrap();
+    crate::ambient::add_to(&mut model);
+    model
+}
+
+/// What a build says about the model and the library.
+#[derive(Debug)]
+struct Outputs {
+    user: Value,
+    library: Value,
+    /// Per probe, the derived `type` targets by interchange id (or the
+    /// spelling a reference kept when it did not resolve).
+    types: Vec<(String, Vec<String>)>,
+}
+
+fn outputs(model: &Model, probes: &[&str]) -> Outputs {
+    let mut resolved = ResolvedModel::build(model);
+    let types = probes
+        .iter()
+        .map(|&probe| {
+            let e = resolved
+                .resolve_qualified(probe)
+                .unwrap_or_else(|| panic!("`{probe}` names an element"));
+            let targets = match resolved.derived(e, "type") {
+                Derived::Value(DerivedValue::References(targets)) => targets
+                    .iter()
+                    .map(|target| match target {
+                        Reference::Element(t) => resolved.element_id(*t).to_string(),
+                        other => format!("{other:?}"),
+                    })
+                    .collect(),
+                other => vec![format!("{other:?}")],
+            };
+            (probe.to_string(), targets)
+        })
+        .collect();
+    Outputs {
+        user: model_to_compact_json(model),
+        library: library_to_compact_json(model),
+        types,
+    }
+}
+
+/// Where `actual` departs from `cold`: the probed types, else the first
+/// differing element of the user or library graph.
+fn divergence(actual: &Outputs, cold: &Outputs) -> Option<String> {
+    if actual.types != cold.types {
+        return Some(format!("types {:?}, cold {:?}", actual.types, cold.types));
+    }
+    for (graph, a, c) in [
+        ("user", &actual.user, &cold.user),
+        ("library", &actual.library, &cold.library),
+    ] {
+        let (a, c) = (a.as_array().unwrap(), c.as_array().unwrap());
+        if let Some(i) = (0..a.len().max(c.len())).find(|&i| a.get(i) != c.get(i)) {
+            return Some(format!(
+                "{graph} element {i}: {}\ncold: {}",
+                a.get(i).map_or("none".into(), Value::to_string),
+                c.get(i).map_or("none".into(), Value::to_string)
+            ));
+        }
+    }
+    None
+}
+
+/// Build `user` over `library` cold, replaying a recording of the library
+/// alone (the in-memory sources-with-snapshot path), and on a prepared
+/// directory library whose root misses force a joint build that replays
+/// the recording it saved; all three must agree. Returns the cold outputs.
+fn replaying_builds_agree(library: &str, user: &str, probes: &[&str]) -> Outputs {
+    replaying_builds_agree_in("sysml", library, user, probes)
+}
+
+/// [`replaying_builds_agree`] for sources of the dialect `extension` names.
+fn replaying_builds_agree_in(
+    extension: &str,
+    library: &str,
+    user: &str,
+    probes: &[&str],
+) -> Outputs {
+    builds_agree_in(extension, library, user, probes, DirectoryBuild::Joint)
+}
+
+/// How a model builds on a directory library that was prepared.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum DirectoryBuild {
+    /// The model completes a root miss of the prepared library, so it
+    /// resolves jointly with it, replaying the recording saved beside it.
+    Joint,
+    /// The model completes none: it resolves on the prepared library.
+    Prepared,
+}
+
+/// Build `user` over `library` cold, replaying a recording of the library
+/// alone, and on a prepared directory library, which the model must build
+/// on as `directory_build` says; all three must agree. Returns the cold
+/// outputs.
+fn builds_agree_in(
+    extension: &str,
+    library: &str,
+    user: &str,
+    probes: &[&str],
+    directory_build: DirectoryBuild,
+) -> Outputs {
+    let files = LibraryDir::new(library, extension);
+    let user_unit = format!("user.{extension}");
+
+    let mut cold = library_model(&files.dir());
+    cold.add_source(&user_unit, user);
+    let cold = outputs(&cold, probes);
+
+    let mut recorder = library_model(&files.dir());
+    recorder.record_library_cache();
+    ResolvedModel::build(&recorder);
+    let recording = recorder.take_recorded_library_cache().unwrap();
+    let recording = LibraryCache::from_bytes(&recording.to_bytes()).unwrap();
+    let mut snapshot = library_model(&files.dir());
+    snapshot.set_library_cache(recording);
+    snapshot.add_source(&user_unit, user);
+    if let Some(divergence) = divergence(&outputs(&snapshot, probes), &cold) {
+        panic!(
+            "replaying a recording diverged from a cold build\nlibrary: {library}\nuser: {user}\n{divergence}"
+        );
+    }
+    assert_eq!(snapshot.lib_cache_kind(), "use");
+
+    // A fresh content key per call: prepared libraries are shared per key.
+    let key = uuid::Uuid::new_v4().as_u64_pair().0;
+    let cache = || Some((key, files.recording()));
+    let mut preparing = Model::new();
+    crate::prepared::load_library_with_cache_at(&mut preparing, &files.dir(), cache()).unwrap();
+    drop(preparing);
+    assert!(files.recording().exists(), "preparing records the library");
+    let mut directory = Model::new();
+    crate::prepared::load_library_with_cache_at(&mut directory, &files.dir(), cache()).unwrap();
+    directory.add_source(&user_unit, user);
+    let prepared = ResolvedModel::build(&directory).b.library_facts.is_some();
+    match directory_build {
+        DirectoryBuild::Joint => {
+            assert!(
+                !prepared,
+                "the model completes a root miss of the prepared library"
+            );
+            assert_eq!(
+                directory.lib_cache_kind(),
+                "use",
+                "the joint build replays the recording"
+            );
+        }
+        DirectoryBuild::Prepared => {
+            assert!(prepared, "the model builds on the prepared library");
+        }
+    }
+    if let Some(divergence) = divergence(&outputs(&directory, probes), &cold) {
+        panic!(
+            "a directory library's {directory_build:?} build diverged from a cold build\nlibrary: {library}\nuser: {user}\n{divergence}"
+        );
+    }
+
+    // A library prepared in memory while recording keeps that recording,
+    // and a build that cannot reuse its prepared graph replays it.
+    let mut recording_alone = library_model(&files.dir());
+    recording_alone.record_library_cache();
+    let mut memory = Model::new();
+    recording_alone
+        .prepare_library()
+        .unwrap()
+        .install(&mut memory)
+        .unwrap();
+    memory.add_source(&user_unit, user);
+    let prepared = ResolvedModel::build(&memory).b.library_facts.is_some();
+    match directory_build {
+        DirectoryBuild::Joint => {
+            assert!(
+                !prepared,
+                "the model completes a root miss of the library prepared in memory"
+            );
+            assert_eq!(
+                memory.lib_cache_kind(),
+                "use",
+                "the joint build replays the recording the library was prepared with"
+            );
+        }
+        DirectoryBuild::Prepared => {
+            assert!(
+                prepared,
+                "the model builds on the library prepared in memory"
+            );
+        }
+    }
+    if let Some(divergence) = divergence(&outputs(&memory, probes), &cold) {
+        panic!(
+            "an in-memory prepared library's {directory_build:?} build diverged from a cold build\nlibrary: {library}\nuser: {user}\n{divergence}"
+        );
+    }
+    cold
+}
+
+fn resolved_types(outputs: &Outputs) -> bool {
+    outputs
+        .types
+        .iter()
+        .all(|(_, targets)| targets.len() == 1 && !targets[0].contains("Unresolved"))
+}
+
+/// `j` reaches `X` only through `A`'s specialization base, which the
+/// scope's base cache resolved while `i` was resolving.
+const BASE_CACHE_LIBRARY: &str = "package Other { part def X { part def Inner; part def Inner2; } }
+package L { part def A :> X { part i : Inner; part j : Inner2; } }";
+
+#[test]
+fn outcomes_read_through_the_base_cache_replay_only_while_its_misses_stay_missing() {
+    for user in [
+        "private import Other::*; package P { part a : L::A; }",
+        "part def X { part def Inner; part def Inner2; } package P { part a : L::A; }",
+    ] {
+        let cold = replaying_builds_agree(
+            BASE_CACHE_LIBRARY,
+            user,
+            &["L::A::i", "L::A::j", "P::a::i", "P::a::j"],
+        );
+        assert!(resolved_types(&cold), "{user}: {:?}", cold.types);
+    }
+}
+
+#[test]
+fn outcomes_read_through_the_import_cache_replay_only_while_its_misses_stay_missing() {
+    let cold = replaying_builds_agree(
+        "package L { import X::*; part a : Inner; part b : Inner2; }",
+        "package X { part def Inner; part def Inner2; }",
+        &["L::a", "L::b"],
+    );
+    assert!(resolved_types(&cold), "{:?}", cold.types);
+    assert!(
+        !cold.library.to_string().contains(r#"{"@ref":"X"}"#),
+        "the library import resolves once the model supplies its target"
+    );
+}
+
+#[test]
+fn outcomes_read_through_a_cache_replay_soundly_across_resolution_passes() {
+    // A redefinition makes the build resolve in several passes; each pass
+    // starts from empty caches and must attribute its misses again.
+    let cold = replaying_builds_agree(
+        "package Other { part def X { part def Inner; part def Inner2; part y; } }
+package L { part def A :> X { part i : Inner; part j : Inner2; part :>> y; } }",
+        "private import Other::*; package U { part a : L::A; }",
+        &["L::A::i", "L::A::j", "U::a::j"],
+    );
+    assert!(resolved_types(&cold), "{:?}", cold.types);
+}
+
+#[test]
+fn outcomes_read_through_another_references_outcome_depend_on_its_misses() {
+    // `w :> y` meets `A`'s `:>> y` and `K::y`; whether the first shadows the
+    // second is `A`'s recorded redefinition outcome, which resolves only
+    // once the model supplies `X`. `w`'s own lookup never reaches `X`.
+    let cold = replaying_builds_agree(
+        "package Other { part def X :> L::K; }
+package L {
+    part def K { part y; }
+    part def A :> X { part :>> y; }
+    part def C :> A, K { part w :> y; }
+}",
+        "private import Other::*; package P { part c : L::C; }",
+        &[],
+    );
+    assert!(
+        !cold
+            .library
+            .to_string()
+            .contains(r#""subsettedFeature":{"@ref":"y"}"#),
+        "the model's import settles `w :> y`"
+    );
+}
+
+#[test]
+fn outcomes_read_through_the_recorded_lookup_graph_depend_on_its_inputs() {
+    // A later resolution pass settles the anonymous feature's `:>> y` in its
+    // header base `A`, reading `A`'s projection from the recorded lookup
+    // graph — which rests on `A :> X`. The model supplies `X`, so a joint
+    // build must resolve that redefinition again rather than replay it.
+    replaying_builds_agree_in(
+        "kerml",
+        "package Other {
+    feature :> L::A { feature y; feature y; feature :>> y; alias for K; }
+}
+package L {
+    feature A :> X { feature :>> y; class Inner; }
+    feature :> A, X { feature : Inner; }
+}",
+        "feature X { class Inner; }",
+        &[],
+    );
+}
+
+#[test]
+fn a_cache_entry_does_not_take_the_mode_of_the_lookup_that_fills_it() {
+    // `K :> X` finds `X` through the membership import, whose own target
+    // `Other::X` looks up `Other` through the namespace imports of `L` —
+    // computing them while that membership import resolves itself. The
+    // entry must still see it: `import X::*` resolves, and `Inner` with it.
+    // (`Extra` only makes the model resolve jointly with the library.)
+    let cold = replaying_builds_agree(
+        "package Other { part def X { part def Inner; } }
+package L {
+    import X::*;
+    private import Other::X;
+    part def K :> X;
+    part i : Inner;
+    part def J :> Extra;
+}",
+        "part def Extra; package P { part k : L::K; }",
+        &["L::i"],
+    );
+    assert!(resolved_types(&cold), "{:?}", cold.types);
+    assert!(
+        !cold.library.to_string().contains(r#"{"@ref":"X"}"#),
+        "the namespace import resolves"
+    );
+}
+
+#[test]
+fn a_redefinition_header_alone_makes_the_library_resolve_in_passes() {
+    // `k`'s `:>> z` resolves in its header base `K` once the recorded lookup
+    // graph is ready, where the lexical bootstrap takes the sibling `k::z`.
+    // Nothing else in the library asks for later passes (the redefining
+    // feature's typing does not resolve, so it is no complete graph node),
+    // while the model's `p : L::K` does. A recording that stopped after
+    // the bootstrap kept the sibling, which the joint build does not.
+    builds_agree_in(
+        "kerml",
+        "package L { class K { feature z; } feature k : K { feature z; feature :>> z : Missing; } }",
+        "package P { feature p : L::K; }",
+        &[],
+        DirectoryBuild::Prepared,
+    );
+}
+
+#[test]
+fn a_root_import_completes_the_absence_the_recorded_lookup_graph_took() {
+    // Alone, the library resolves in passes: its classes are graph nodes,
+    // which take their implied roots as absent because the root imports
+    // nothing. Any root import withdraws those nodes, so the joint build
+    // stops after the lexical bootstrap: `f0 : Inner2` takes `X`'s own
+    // `Inner2`, where the graph selects both that `K` inherits. The import
+    // brings in nothing the library missed, yet `f0`'s typing must resolve
+    // again rather than replay.
+    builds_agree_in(
+        "kerml",
+        "package L {
+    class X :> Y { class Inner2; }
+    class Y { class Inner2; }
+    class K :> X { feature f0 : Inner2; }
+}",
+        "package Q { } private import Q::*;",
+        &["L::K::f0"],
+        DirectoryBuild::Joint,
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/result_redefinition.rs b/crates/sysmlv2-model/src/json/result_redefinition.rs
new file mode 100644
index 0000000..4b39bb5
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/result_redefinition.rs
@@ -0,0 +1,1213 @@
+//! Checked canonical return witnesses for a later atomic generated-result tail.
+//! Candidate discovery never by itself certifies an effective result.
+use super::{
+    Builder, dynamic_invocations::Refusal, semantic_ownership, structural_index::StoredStructure,
+    type_relations,
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+fn charge(steps: &mut usize, n: usize) -> Result<(), Refusal> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(Refusal::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+fn incomplete(steps: &usize) -> Refusal {
+    if *steps > crate::eval::MAX_STEPS {
+        Refusal::WorkLimit
+    } else {
+        Refusal::Incomplete
+    }
+}
+
+/// Exact loaded role identities; ambiguity is retained before inversion.
+fn roles(
+    b: &Builder,
+    raw: &StoredStructure,
+    steps: &mut usize,
+) -> Result<(usize, usize, Option<usize>), Refusal> {
+    let mut found = [None; 3];
+    let mut ambiguous = [false; 3];
+    charge(steps, b.lib_qnames.len())?;
+    for (id, path) in &b.lib_qnames {
+        // Charge segment traversal before computing the aggregate byte cost.
+        // Empty segments still consume work; every size addition saturates.
+        charge(steps, path.len())?;
+        charge(
+            steps,
+            path.iter()
+                .fold(0usize, |n, part| n.saturating_add(part.len())),
+        )?;
+        let slot = match path.as_slice() {
+            [p, n] if p == "Performances" && n == "Evaluation" => 0,
+            [p, n, r] if p == "Performances" && n == "Evaluation" && r == "result" => 1,
+            [p, n] if p == "Performances" && n == "evaluations" => 2,
+            _ => continue,
+        };
+        if found[slot].is_some_and(|previous| previous != *id) {
+            ambiguous[slot] = true;
+        }
+        found[slot] = Some(*id);
+    }
+    let mut result = [None; 3];
+    for i in 0..3 {
+        if !ambiguous[i] {
+            result[i] = found[i]
+                .and_then(|id| raw.element_for_uuid(b, id))
+                .filter(|&e| e < b.lib_boundary);
+        }
+    }
+    let evaluation = result[0]
+        .filter(|&e| b.elements[e].ty == "Function")
+        .ok_or(Refusal::Incomplete)?;
+    let returned = result[1]
+        .filter(|&e| b.elements[e].ty == "Feature")
+        .ok_or(Refusal::Incomplete)?;
+    let evaluations = result[2].filter(|&e| b.elements[e].ty == "Expression");
+    Ok((evaluation, returned, evaluations))
+}
+fn relationships(b: &Builder, owner: usize, steps: &mut usize) -> Result<Vec<usize>, Refusal> {
+    let rows = semantic_ownership::owned_relationships(b, owner).ok_or(Refusal::Incomplete)?;
+    charge(steps, rows.len())?;
+    let rows: Vec<_> = rows.iter().collect();
+    let mut seen = HashSet::new();
+    if rows.iter().any(|&r| !seen.insert(r)) {
+        return Err(Refusal::Incomplete);
+    }
+    Ok(rows)
+}
+fn membership(
+    b: &Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    rel: usize,
+    steps: &mut usize,
+) -> Result<usize, Refusal> {
+    let row = b.elements.get(rel).ok_or(Refusal::Incomplete)?;
+    if !conforms(row.ty, "OwningMembership") || row.owning_relationship.is_some() {
+        return Err(Refusal::Incomplete);
+    }
+    let child = super::membership_evidence::member(b, raw, owner, rel, steps)
+        .ok_or_else(|| incomplete(steps))?;
+    if child >= b.explicit_len()
+        || row
+            .props
+            .get("visibility")
+            .is_some_and(|v| !matches!(v.as_str(), Some("public" | "protected" | "private")))
+        || conforms(row.ty, "FeatureMembership") && !conforms(b.elements[child].ty, "Feature")
+    {
+        return Err(Refusal::Incomplete);
+    }
+
+    Ok(child)
+}
+fn specialization(
+    b: &mut Builder,
+    raw: &StoredStructure,
+    owner: usize,
+    rel: usize,
+    steps: &mut usize,
+) -> Result<usize, Refusal> {
+    let kind = b.elements.get(rel).ok_or(Refusal::Incomplete)?.ty;
+    let (source_kind, target_kind) = if conforms(kind, "Subsetting") {
+        ("Feature", "Feature")
+    } else if conforms(kind, "FeatureTyping") {
+        ("Feature", "Type")
+    } else if conforms(kind, "Subclassification") {
+        ("Classifier", "Classifier")
+    } else {
+        ("Type", "Type")
+    };
+    if !conforms(b.elements[owner].ty, source_kind) {
+        return Err(Refusal::Incomplete);
+    }
+    let carrier = semantic_ownership::checked_relationship_carrier(b, raw, rel, steps)
+        .ok_or_else(|| incomplete(steps))?;
+    if carrier != Some(owner) {
+        return Err(Refusal::Incomplete);
+    }
+    type_relations::endpoint_with_carrier(
+        b,
+        owner,
+        carrier,
+        rel,
+        &[
+            "specific",
+            "subclassifier",
+            "typedFeature",
+            "subsettingFeature",
+            "redefiningFeature",
+            "referencingFeature",
+            "crossingFeature",
+        ],
+        &[
+            "general",
+            "superclassifier",
+            "type",
+            "subsettedFeature",
+            "redefinedFeature",
+            "referencedFeature",
+            "crossedFeature",
+        ],
+        target_kind,
+        steps,
+    )
+    .ok_or_else(|| incomplete(steps))
+}
+
+/// Conservative checked slice: no imported membership, conjugation, chaining or
+/// semantic metadata participates in this first canonical return certificate.
+fn dependency_slice(
+    b: &mut Builder,
+    raw: &StoredStructure,
+    roots: &[usize],
+    steps: &mut usize,
+) -> Result<HashMap<usize, Vec<usize>>, Refusal> {
+    let domains = raw
+        .membership_domains(b, steps)
+        .ok_or_else(|| incomplete(steps))?;
+    let inverse = raw.typing(b, steps).ok_or_else(|| incomplete(steps))?;
+    if inverse.sources_incomplete {
+        return Err(Refusal::Incomplete);
+    }
+    let mut bases = HashMap::new();
+    let mut todo = roots.to_vec();
+    let mut features = Vec::new();
+    while let Some(owner) = todo.pop() {
+        charge(steps, 1)?;
+        if bases.contains_key(&owner) {
+            continue;
+        }
+        if !domains.owner_complete(owner)
+            || owner >= b.explicit_len()
+            || !matches!(
+                b.elements[owner].ty,
+                "Classifier"
+                    | "Class"
+                    | "Structure"
+                    | "DataType"
+                    | "Behavior"
+                    | "Function"
+                    | "Feature"
+                    | "Step"
+                    | "Expression"
+            )
+            // This bounded fragment excludes conjugation rows; a retained flag
+            // must agree rather than claiming ordinary inheritance by itself.
+            || b.elements[owner].props.get("isConjugated")
+                .is_some_and(|v| v.as_bool() != Some(false))
+            || raw.bad_bases.contains(&owner)
+            || raw.bad_chains.contains(&owner)
+            || raw.metadata_annotation_targets.contains(&owner)
+            || b.metadata_of.get(&owner).is_some_and(|m| !m.is_empty())
+        {
+            return Err(Refusal::Incomplete);
+        }
+        if let Some(&scope) = b.elem_scope.get(&owner) {
+            let scope = &b.scopes[scope];
+            charge(
+                steps,
+                scope.imports.len()
+                    + scope.member_imports.len()
+                    + scope.aliases.len()
+                    + scope.filters.len()
+                    + scope.chain_bases.len(),
+            )?;
+            if scope.imports.iter().any(|i| {
+                b.elements[i.relationship]
+                    .props
+                    .get("visibility")
+                    .and_then(|v| v.as_str())
+                    != Some("private")
+            }) || scope.member_imports.iter().any(|i| {
+                b.elements[i.relationship]
+                    .props
+                    .get("visibility")
+                    .and_then(|v| v.as_str())
+                    != Some("private")
+            }) || !scope.aliases.is_empty()
+                || !scope.filters.is_empty()
+                || !scope.chain_bases.is_empty()
+            {
+                return Err(Refusal::Incomplete);
+            }
+        }
+        let mut direct = Vec::new();
+        for rel in relationships(b, owner, steps)? {
+            let row = b.elements.get(rel).ok_or(Refusal::Incomplete)?;
+            if conforms(row.ty, "Conjugation")
+                || conforms(row.ty, "FeatureChaining")
+                || (conforms(row.ty, "Import")
+                    && row.props.get("visibility").and_then(|v| v.as_str()) != Some("private"))
+            {
+                return Err(Refusal::Incomplete);
+            }
+            if conforms(row.ty, "Membership") {
+                let child = membership(b, raw, owner, rel, steps)?;
+                if conforms(b.elements[child].ty, "Feature") {
+                    features.push(child);
+                }
+            } else if conforms(row.ty, "Specialization") {
+                let target = specialization(b, raw, owner, rel, steps)?;
+                charge(steps, direct.len() + 1)?;
+                if !direct.contains(&target) {
+                    direct.push(target);
+                    todo.push(target);
+                }
+            }
+        }
+        bases.insert(owner, direct);
+    }
+    // Validate every stored redefinition closure that the common positional
+    // shadowing algorithm may consume, including targets outside the base slice.
+    let mut seen = HashSet::new();
+    let mut redefinitions = HashMap::new();
+    while let Some(feature) = features.pop() {
+        charge(steps, 1)?;
+        if !seen.insert(feature) {
+            continue;
+        }
+        if !conforms(
+            b.elements.get(feature).ok_or(Refusal::Incomplete)?.ty,
+            "Feature",
+        ) || raw.bad_bases.contains(&feature)
+            || raw.metadata_annotation_targets.contains(&feature)
+            || b.metadata_of.get(&feature).is_some_and(|m| !m.is_empty())
+        {
+            return Err(Refusal::Incomplete);
+        }
+        let mut actual = HashSet::new();
+        for rel in relationships(b, feature, steps)? {
+            if conforms(b.elements[rel].ty, "Redefinition") && rel < b.explicit_len() {
+                let target = specialization(b, raw, feature, rel, steps)?;
+                actual.insert(target);
+                features.push(target);
+            }
+        }
+        for &rel in inverse.relationships.get(&feature).into_iter().flatten() {
+            charge(steps, 1)?;
+            if rel < b.explicit_len() && conforms(b.elements[rel].ty, "Redefinition") {
+                let target = specialization(b, raw, feature, rel, steps)?;
+                if !actual.contains(&target) {
+                    return Err(Refusal::Incomplete);
+                }
+            }
+        }
+        redefinitions.insert(feature, actual.into_iter().collect::<Vec<_>>());
+    }
+    if b.positional_redefinition_sources_match(&redefinitions, steps) != Some(true) {
+        return Err(incomplete(steps));
+    }
+    acyclic(&redefinitions, steps)?;
+    Ok(bases)
+}
+
+fn acyclic(graph: &HashMap<usize, Vec<usize>>, steps: &mut usize) -> Result<(), Refusal> {
+    let mut state = HashMap::new();
+    for &root in graph.keys() {
+        let mut todo = vec![(root, false)];
+        while let Some((owner, exit)) = todo.pop() {
+            charge(steps, 1)?;
+            if exit {
+                state.insert(owner, 2);
+                continue;
+            }
+            match state.get(&owner) {
+                Some(1) => return Err(Refusal::Incomplete),
+                Some(2) => continue,
+                _ => {}
+            }
+            state.insert(owner, 1);
+            todo.push((owner, true));
+            let next = graph.get(&owner).map(Vec::as_slice).unwrap_or(&[]);
+            charge(steps, next.len())?;
+            todo.extend(next.iter().rev().map(|&n| (n, false)));
+        }
+    }
+    Ok(())
+}
+
+/// This returns positive canonical base/result identities only. It neither
+/// resolves a source expression's bases nor publishes any generated edge.
+pub(super) fn canonical_witness(
+    b: &mut Builder,
+    steps: &mut usize,
+) -> Result<(Vec<usize>, usize), Refusal> {
+    let raw = StoredStructure::for_query(b, steps).ok_or_else(|| incomplete(steps))?;
+    if !raw.ids_unique || raw.annotations_incomplete || b.metadata_associations_incomplete {
+        return Err(Refusal::Incomplete);
+    }
+    let (evaluation, result, evaluations) = roles(b, &raw, steps)?;
+    let member = b.elements[result]
+        .owning_relationship
+        .ok_or(Refusal::Incomplete)?;
+    if b.elements[member].ty != "ReturnParameterMembership"
+        || membership(b, &raw, evaluation, member, steps)? != result
+    {
+        return Err(Refusal::Incomplete);
+    }
+    let mut admitted = Vec::new();
+    for root in std::iter::once(evaluation).chain(evaluations) {
+        let bases = match dependency_slice(b, &raw, &[root], steps) {
+            Ok(bases) => bases,
+            Err(Refusal::WorkLimit) => return Err(Refusal::WorkLimit),
+            Err(_) => continue,
+        };
+        let candidates = b
+            .plan_unique_result_candidates(&bases, &HashSet::new(), &[root], steps)
+            .ok_or_else(|| incomplete(steps))?;
+        if candidates.get(&root) == Some(&result) {
+            admitted.push(root);
+        }
+    }
+    Ok((admitted, result))
+}
+
+#[derive(Default)]
+pub(super) struct Evidence {
+    pub sources: HashSet<usize>,
+    pub relationships: HashSet<usize>,
+}
+pub(super) struct Plan {
+    from: usize,
+    before: usize,
+    rows: Vec<super::Elem>,
+    roles: Vec<super::local_featuring::Role>,
+    replacements: Vec<(usize, Vec<usize>)>,
+    evidence: Evidence,
+    edges: Vec<(uuid::Uuid, uuid::Uuid)>,
+}
+/// Stage only independently proven canonical direct-base obligations. Other
+/// direct bases remain qualified and cannot erase these known obligations.
+pub(super) fn prepare(
+    b: &mut Builder,
+    rows: &[super::Elem],
+    roles: &[super::local_featuring::Role],
+    steps: &mut usize,
+) -> Result<Plan, Refusal> {
+    charge(
+        steps,
+        1 + rows.len().saturating_mul(2) + roles.len().saturating_mul(16),
+    )?;
+    if b.implied.is_none() {
+        return Err(Refusal::Incomplete);
+    }
+    let raw = StoredStructure::for_query(b, steps).ok_or_else(|| incomplete(steps))?;
+    let metadata = b.metadata_association_generation.clone();
+    let (bases, target) = canonical_witness(b, steps)?;
+    let mut ids = HashSet::new();
+    for row in rows {
+        if raw.element_for_uuid(b, row.id).is_some() || !ids.insert(row.id) {
+            return Err(Refusal::Collision);
+        }
+    }
+    let mut plan = Plan {
+        from: b.elements.len(),
+        before: rows.len(),
+        rows: Vec::new(),
+        roles: Vec::new(),
+        replacements: Vec::new(),
+        evidence: Evidence::default(),
+        edges: Vec::new(),
+    };
+    for &role in roles {
+        if role.target != role.anchor || !super::local_featuring::valid(b, rows, role) {
+            return Err(Refusal::Stale);
+        }
+        let mut proven = false;
+        for relation in relationships(b, role.anchor, steps)? {
+            if !conforms(b.elements[relation].ty, "Specialization") {
+                continue;
+            }
+            match specialization(b, &raw, role.anchor, relation, steps) {
+                Ok(target) if bases.contains(&target) => proven = true,
+                Err(Refusal::WorkLimit) => return Err(Refusal::WorkLimit),
+                _ => {}
+            }
+        }
+        if !proven {
+            continue;
+        }
+        if !plan.evidence.sources.insert(role.source) {
+            return Err(Refusal::Stale);
+        }
+        let source = &rows[role.source - b.elements.len()];
+        let target_id = b.elements[target].id;
+        let id = uuid::Uuid::new_v5(
+            &uuid::Uuid::NAMESPACE_OID,
+            format!("{}/implied/Redefinition/{target_id}", source.id).as_bytes(),
+        );
+        if raw.element_for_uuid(b, id).is_some() || !ids.insert(id) {
+            return Err(Refusal::Collision);
+        }
+        charge(steps, source.owned_relationships.len())?;
+        let index = b.elements.len() + rows.len() + plan.rows.len();
+        let mut owned = source.owned_relationships.to_vec();
+        owned.push(index);
+        plan.replacements
+            .push((role.source - b.elements.len(), owned));
+        plan.roles.push(role);
+        plan.evidence.relationships.insert(index);
+        plan.edges.push((source.id, target_id));
+        let mut props = crate::properties::Properties::new();
+        props.insert("isImplied", serde_json::json!(true));
+        for (key, id) in [
+            ("owningRelatedElement", source.id),
+            ("redefiningFeature", source.id),
+            ("redefinedFeature", target_id),
+        ] {
+            props.insert(key, serde_json::json!({"@id":id.to_string()}));
+        }
+        plan.rows.push(super::Elem {
+            ty: "Redefinition",
+            id,
+            path: String::new(),
+            path_parent: None,
+            props,
+            owned_relationships: Default::default(),
+            children: Default::default(),
+            owning_relationship: None,
+        });
+    }
+    let metadata_current = match (&metadata, &b.metadata_association_generation) {
+        (None, None) => true,
+        (Some(a), Some(z)) => std::sync::Arc::ptr_eq(a, z),
+        _ => false,
+    };
+    if !raw.is_current(b) || !metadata_current {
+        return Err(Refusal::Stale);
+    }
+    Ok(plan)
+}
+impl Plan {
+    pub(super) fn append(
+        self,
+        rows: &mut Vec<super::Elem>,
+        ownership: &mut semantic_ownership::SemanticOwnership,
+        graph: &mut HashMap<uuid::Uuid, Vec<uuid::Uuid>>,
+    ) -> Evidence {
+        assert_eq!(rows.len(), self.before);
+        for (owner, relationships) in self.replacements {
+            rows[owner].owned_relationships = relationships.into();
+        }
+        for ((row, role), (source, target)) in self.rows.into_iter().zip(self.roles).zip(self.edges)
+        {
+            ownership
+                .register(
+                    self.from + rows.len(),
+                    Some(role.source),
+                    role.anchor,
+                    false,
+                )
+                .expect("prevalidated result inheritance carrier");
+            rows.push(row);
+            graph.entry(source).or_default().push(target);
+        }
+        self.evidence
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    const LIB: &str = "standard library package Base {classifier Anything;feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence;function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences;expr evaluations:Evaluation subsets performances;}";
+    fn unpublished(lib: &str, user: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        m.add_library_source("return-library.kerml", lib);
+        m.add_source("return-user.kerml", user);
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+    fn fixture(lib: &str) -> ResolvedModel {
+        let mut r = unpublished(lib, "feature n;feature x=n;");
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(e);
+        r
+    }
+    #[test]
+    fn canonical_result_does_not_ignore_orphan_membership_claiming_same_owner() {
+        let library =
+            format!("{LIB} standard library package Extra {{function F {{return omitted;}}}}");
+        let mut r = unpublished(&library, "feature n; feature x=n;");
+        let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+        let extra_owner = r.resolve_qualified("Extra::F").unwrap().0;
+        let extra = r.resolve_qualified("Extra::F::omitted").unwrap().0;
+        let membership = r.b.elements[extra].owning_relationship.unwrap();
+        let id = r.b.elements[evaluation].id;
+        r.b.elements[extra_owner]
+            .owned_relationships
+            .make_mut()
+            .retain(|&rel| rel != membership);
+        for key in [
+            "owningRelatedElement",
+            "membershipOwningNamespace",
+            "owningType",
+        ] {
+            r.b.set(membership, key, serde_json::json!({"@id":id.to_string()}));
+        }
+        r.b.set(
+            extra,
+            "owningType",
+            serde_json::json!({"@id":id.to_string()}),
+        );
+        let witness = canonical_witness(&mut r.b, &mut 0);
+        assert!(
+            !witness
+                .as_ref()
+                .is_ok_and(|(bases, _)| bases.contains(&evaluation)),
+            "orphan claimed result must prevent canonical uniqueness: {witness:?}"
+        );
+    }
+    #[test]
+    fn independent_orphan_child_backlink_must_refuse_return_uniqueness() {
+        let mut r = unpublished(LIB, "feature n;feature x=n;");
+        let returned = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        let member = r.b.elements[returned].owning_relationship.unwrap();
+        assert!(canonical_witness(&mut r.b, &mut 0).is_ok());
+        let mut extra = r.b.elements[returned].clone();
+        extra.id = uuid::Uuid::new_v5(
+            &uuid::Uuid::NAMESPACE_OID,
+            b"independent orphan return child",
+        );
+        extra.path.clear();
+        extra.path_parent = None;
+        extra.owned_relationships = Vec::new().into();
+        extra.owning_relationship = Some(member);
+        r.b.elements.push(extra);
+        let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+        assert!(
+            !canonical_witness(&mut r.b, &mut 0)
+                .is_ok_and(|(bases, _)| bases.contains(&evaluation)),
+            "orphan inverse child must not certify unique return"
+        );
+    }
+    #[test]
+    fn orphan_membership_and_child_refusals_replay_all_library_representations() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut library = Model::new();
+        library.add_library_source("return-library.kerml", LIB);
+        library.record_library_cache();
+        ResolvedModel::build(&library);
+        let cache =
+            LibraryCache::from_bytes(&library.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = library.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(147).unwrap(), 147).unwrap());
+        for mode in 0..4 {
+            for orphan_child in [false, true] {
+                let mut model = Model::new();
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.add_library_source("return-library.kerml", LIB);
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                model.add_source(
+                    "return-user.kerml",
+                    "function Other {return extra;} feature n; feature x=n;",
+                );
+                let mut r = ResolvedModel::build(&model);
+                let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+                let returned = r
+                    .resolve_qualified("Performances::Evaluation::result")
+                    .unwrap()
+                    .0;
+                let extra = r.resolve_qualified("Other::extra").unwrap().0;
+                let other = r.resolve_qualified("Other").unwrap().0;
+                assert!(
+                    canonical_witness(&mut r.b, &mut 0)
+                        .unwrap()
+                        .0
+                        .contains(&evaluation)
+                );
+                if orphan_child {
+                    r.b.elements[extra].owning_relationship =
+                        r.b.elements[returned].owning_relationship;
+                } else {
+                    let membership = r.b.elements[extra].owning_relationship.unwrap();
+                    r.b.elements[other]
+                        .owned_relationships
+                        .make_mut()
+                        .retain(|&rel| rel != membership);
+                    let id = r.b.elements[evaluation].id;
+                    r.b.set(
+                        membership,
+                        "owningRelatedElement",
+                        serde_json::json!({"@id":id.to_string()}),
+                    );
+                }
+                assert!(
+                    !canonical_witness(&mut r.b, &mut 0)
+                        .is_ok_and(|(bases, _)| bases.contains(&evaluation)),
+                    "mode={mode}, child={orphan_child}"
+                );
+            }
+        }
+    }
+    #[test]
+    fn inverse_redefinition_sources_cannot_hide_a_shadowing_dependency() {
+        for contradictory_alias in [false, true] {
+            let mut r = unpublished(LIB, "feature other; feature alt redefines other;");
+            let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+            let result = r
+                .resolve_qualified("Performances::Evaluation::result")
+                .unwrap()
+                .0;
+            let alt = r.resolve_qualified("alt").unwrap().0;
+            assert!(
+                canonical_witness(&mut r.b, &mut 0)
+                    .unwrap()
+                    .0
+                    .contains(&evaluation)
+            );
+            let relation = *r.b.elements[alt]
+                .owned_relationships
+                .iter()
+                .find(|&&rel| r.b.elements[rel].ty == "Redefinition")
+                .unwrap();
+            let id = r.b.elements[result].id;
+            if contradictory_alias {
+                r.b.set(
+                    relation,
+                    "specific",
+                    serde_json::json!({"@id":id.to_string()}),
+                );
+            } else {
+                r.b.elements[alt]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&rel| rel != relation);
+                r.b.set(
+                    relation,
+                    "redefiningFeature",
+                    serde_json::json!({"@id":id.to_string()}),
+                );
+            }
+            assert!(
+                !canonical_witness(&mut r.b, &mut 0)
+                    .is_ok_and(|(bases, _)| bases.contains(&evaluation))
+            );
+        }
+    }
+    #[test]
+    fn checked_canonical_witness_matches_actual_direct_base_results() {
+        let mut r = fixture(LIB);
+        let expected = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        assert_eq!(canonical_witness(&mut r.b, &mut 0).unwrap().1, expected);
+    }
+    #[test]
+    fn canonical_role_and_membership_ambiguities_are_refused() {
+        let mut r = fixture(LIB);
+        let result = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        let n = r.resolve_qualified("n").unwrap().0;
+        let member = r.b.elements[result].owning_relationship.unwrap();
+        let wrong = r.b.elements[n].id;
+        r.b.elements[member].props.insert(
+            "memberFeature",
+            serde_json::json!({"@id":wrong.to_string()}),
+        );
+        assert!(canonical_witness(&mut r.b, &mut 0).is_err());
+        let mut r = fixture(LIB);
+        let n = r.resolve_qualified("n").unwrap();
+        let id = r.element_id(n);
+        r.b.lib_qnames.push((
+            id,
+            vec!["Performances".into(), "Evaluation".into(), "result".into()],
+        ));
+        assert!(canonical_witness(&mut r.b, &mut 0).is_err());
+    }
+
+    #[test]
+    fn return_parameter_aliases_are_checked_before_positive_publication() {
+        for key in [
+            "ownedMemberParameter",
+            "owningMembership",
+            "owningFeatureMembership",
+            "owningParameterMembership",
+        ] {
+            for bad in [false, true] {
+                let mut r = unpublished(LIB, "feature n;feature x=n;");
+                let result = r
+                    .resolve_qualified("Performances::Evaluation::result")
+                    .unwrap()
+                    .0;
+                let member = r.b.elements[result].owning_relationship.unwrap();
+                let expected = if key == "ownedMemberParameter" {
+                    result
+                } else {
+                    member
+                };
+                let target = if key == "ownedMemberParameter" {
+                    member
+                } else {
+                    result
+                };
+                let id = if bad {
+                    {
+                        let n = r.resolve_qualified("n").unwrap();
+                        r.element_id(n)
+                    }
+                } else {
+                    r.b.elements[expected].id
+                };
+                r.b.elements[target]
+                    .props
+                    .insert(key, serde_json::json!({"@id":id.to_string()}));
+                let expression = r
+                    .user_elements()
+                    .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+                    .unwrap();
+                r.implied_relationships(expression);
+                let result =
+                    r.b.semantic_ownership
+                        .as_ref()
+                        .unwrap()
+                        .result(expression.0)
+                        .unwrap()
+                        .feature;
+                assert_eq!(
+                    r.b.elements[result]
+                        .owned_relationships
+                        .iter()
+                        .any(|&rel| r.b.elements[rel].ty == "Redefinition"),
+                    !bad,
+                    "{key}, bad={bad}"
+                );
+                // Refusing this new certificate never removes the independently
+                // admitted result/Binding and local TypeFeaturing families.
+                assert!(
+                    r.b.elements[result]
+                        .owned_relationships
+                        .iter()
+                        .any(|&rel| r.b.elements[rel].ty == "Subsetting")
+                );
+                assert!(
+                    r.b.elements[result]
+                        .owned_relationships
+                        .iter()
+                        .any(|&rel| r.b.elements[rel].ty == "TypeFeaturing")
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn nonconjugated_dependency_flags_require_exact_false_or_absence() {
+        for value in [
+            serde_json::json!(false),
+            serde_json::json!(true),
+            serde_json::json!(null),
+            serde_json::json!("false"),
+            serde_json::json!({}),
+        ] {
+            let mut r = fixture(LIB);
+            let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+            r.b.elements[evaluation]
+                .props
+                .insert("isConjugated", value.clone());
+            let witness = canonical_witness(&mut r.b, &mut 0).unwrap();
+            assert_eq!(
+                !witness.0.is_empty(),
+                value == serde_json::json!(false),
+                "{value}"
+            );
+        }
+    }
+    #[test]
+    fn role_path_segment_work_is_charged_before_traversal() {
+        let mut r = fixture(LIB);
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        let id = r.b.elements[0].id;
+        r.b.lib_qnames = vec![(id, vec![String::new(); 6])].into();
+        let mut steps = crate::eval::MAX_STEPS - 5;
+        assert!(matches!(
+            roles(&r.b, &raw, &mut steps),
+            Err(Refusal::WorkLimit)
+        ));
+    }
+    #[test]
+    fn overridden_or_cyclic_canonical_base_does_not_reuse_named_return() {
+        let override_lib = LIB.replace(
+            "expr evaluations:Evaluation subsets performances;",
+            "expr evaluations:Evaluation subsets performances {return other;}",
+        );
+        let mut r = fixture(&override_lib);
+        let base = r.resolve_qualified("Performances::Evaluation").unwrap().0;
+        assert_eq!(canonical_witness(&mut r.b, &mut 0).unwrap().0, vec![base]);
+        let cyclic = LIB.replace(
+            "behavior Performance specializes Occurrences::Occurrence;",
+            "behavior Performance specializes Evaluation;",
+        );
+        let mut r = fixture(&cyclic);
+        assert!(canonical_witness(&mut r.b, &mut 0).unwrap().0.is_empty());
+    }
+    fn generated(r: &ResolvedModel) -> (usize, usize, usize) {
+        let expression = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap()
+            .0;
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expression)
+                .unwrap()
+                .feature;
+        let relation = *r.b.elements[result]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| r.b.elements[rel].ty == "Redefinition")
+            .unwrap();
+        (expression, result, relation)
+    }
+    #[test]
+    fn direct_result_edge_appends_after_old_fourteen_and_preserves_independent_witness() {
+        use crate::json::{
+            dynamic_graph::Outcome,
+            type_relations::{RelationFact, TypeRelations},
+        };
+        let mut r = fixture(LIB);
+        let (expression, result, relation) = generated(&r);
+        let expected = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        let n = r.resolve_qualified("n").unwrap().0;
+        let from = r.b.implied.as_ref().unwrap().owned_results_from;
+        assert_eq!(r.b.elements.len() - from, 15);
+        assert_eq!(relation, from + 14);
+        assert_eq!(result, from + 1);
+        assert_eq!(
+            r.b.elements[result].owned_relationships.to_vec(),
+            vec![from + 2, from + 11, from + 14]
+        );
+        assert_eq!(
+            r.b.dynamic_graph
+                .as_ref()
+                .unwrap()
+                .result_redefinition_outcome,
+            Outcome::Accepted
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, result, expected, &mut 0),
+            RelationFact::Yes
+        );
+        let ids: Vec<_> = r.b.elements.iter().map(|e| e.id).collect();
+        r.implied_relationships(crate::json::ElementRef(expression));
+        assert_eq!(ids, r.b.elements.iter().map(|e| e.id).collect::<Vec<_>>());
+        r.b.metadata_association_generation = Some(std::sync::Arc::new(()));
+        assert_ne!(
+            TypeRelations::default().specializes(&mut r.b, result, expected, &mut 0),
+            RelationFact::Yes
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, result, n, &mut 0),
+            RelationFact::Yes
+        );
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, result, &mut 0),
+            Some(vec![expression])
+        );
+    }
+    #[test]
+    fn explicit_supertypes_ignore_only_valid_excluded_stale_result_rows() {
+        use crate::json::type_relations::{RelationFact, TypeRelations};
+        let mut r = fixture(LIB);
+        let (_, result, relation) = generated(&r);
+        let expected = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        let n = r.resolve_qualified("n").unwrap().0;
+        let mut before = TypeRelations::default();
+        assert_eq!(
+            before.checked_supertypes(&mut r.b, result, true, &mut 0),
+            Ok(vec![])
+        );
+        r.b.metadata_association_generation = Some(std::sync::Arc::new(()));
+        assert!(
+            before
+                .checked_supertypes(&mut r.b, result, true, &mut 0)
+                .is_err()
+        );
+        let mut fresh = TypeRelations::default();
+        for _ in 0..2 {
+            assert_eq!(
+                fresh.checked_supertypes(&mut r.b, result, true, &mut 0),
+                Ok(vec![])
+            );
+        }
+        assert_ne!(
+            TypeRelations::default().specializes(&mut r.b, result, expected, &mut 0),
+            RelationFact::Yes
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, result, n, &mut 0),
+            RelationFact::Yes
+        );
+        for flag in [serde_json::json!(false), serde_json::Value::Null] {
+            r.b.elements[relation].props.insert("isImplied", flag);
+            assert!(
+                TypeRelations::default()
+                    .checked_supertypes(&mut r.b, result, true, &mut 0)
+                    .is_err()
+            );
+        }
+    }
+
+    #[test]
+    fn generated_explicit_edge_id_survives_remap_without_stale_recertification() {
+        use crate::json::{
+            ElementRef,
+            type_relations::{RelationFact, TypeRelations},
+        };
+        let mut r = fixture(LIB);
+        let (expression, result, relation) = generated(&r);
+        let target = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        let explicit =
+            uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"explicit result redefinition");
+        let old = r.element_id(ElementRef(relation));
+        let len = r.b.elements.len();
+        r.override_ids(&HashMap::from([(old, explicit)]));
+        assert_eq!(r.b.elements.len(), len);
+        assert_eq!(r.element_id(ElementRef(relation)), explicit);
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, result, target, &mut 0),
+            RelationFact::Yes
+        );
+        r.b.metadata_association_generation = Some(std::sync::Arc::new(()));
+        let old = r.element_id(ElementRef(expression));
+        let next = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"stale result expression");
+        r.override_ids(&HashMap::from([(old, next)]));
+        assert_eq!(r.element_id(ElementRef(relation)), explicit);
+        assert_ne!(
+            TypeRelations::default().specializes(&mut r.b, result, target, &mut 0),
+            RelationFact::Yes
+        );
+    }
+    #[test]
+    fn a_required_direct_redefinition_is_not_removed_by_existing_subsetting_reachability() {
+        let mut r = unpublished(LIB, "feature x=Performances::Evaluation::result;");
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(e);
+        let (_, result, _) = generated(&r);
+        let target = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap();
+        let target_id = r.element_id(target);
+        for (kind, key) in [
+            ("Subsetting", "subsettedFeature"),
+            ("Redefinition", "redefinedFeature"),
+        ] {
+            assert!(r.b.elements[result].owned_relationships.iter().any(|&rel| {
+                r.b.elements[rel].ty == kind
+                    && r.b.elements[rel]
+                        .props
+                        .get(key)
+                        .and_then(|v| v.as_reference())
+                        == Some(target_id)
+            }));
+        }
+    }
+    #[test]
+    fn collision_preserves_dynamic_local_and_old_result_families() {
+        use crate::json::dynamic_graph::Outcome;
+        let mut r = unpublished(
+            LIB,
+            "feature spare;feature n;feature x=n;function F {return result;}feature call=F();",
+        );
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        let target = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap();
+        let spare = r.resolve_qualified("spare").unwrap();
+        let result_id = uuid::Uuid::new_v5(
+            &uuid::Uuid::NAMESPACE_OID,
+            format!("{}/implied/ownedResult", r.element_id(e)).as_bytes(),
+        );
+        let collision = uuid::Uuid::new_v5(
+            &uuid::Uuid::NAMESPACE_OID,
+            format!("{result_id}/implied/Redefinition/{}", r.element_id(target)).as_bytes(),
+        );
+        r.override_ids(&HashMap::from([(r.element_id(spare), collision)]));
+        r.implied_relationships(e);
+        let snapshot = r.b.dynamic_graph.as_ref().unwrap();
+        assert_eq!(snapshot.outcome, Outcome::Accepted);
+        assert_eq!(snapshot.local_featuring_outcome, Outcome::Accepted);
+        assert_eq!(
+            snapshot.result_redefinition_outcome,
+            Outcome::Declined(Refusal::Collision)
+        );
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(e.0)
+                .unwrap()
+                .feature;
+        assert!(
+            r.b.elements[result]
+                .owned_relationships
+                .iter()
+                .all(|&rel| r.b.elements[rel].ty != "Redefinition")
+        );
+    }
+    #[test]
+    fn exhaustion_is_nonmutating_and_a_fresh_publication_can_retry() {
+        let mut r = unpublished(LIB, "feature n;feature x=n;");
+        let before: Vec<_> = r.b.elements.iter().map(|e| e.id).collect();
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(matches!(
+            prepare(&mut r.b, &[], &[], &mut steps),
+            Err(Refusal::WorkLimit)
+        ));
+        assert_eq!(
+            before,
+            r.b.elements.iter().map(|e| e.id).collect::<Vec<_>>()
+        );
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(e);
+        generated(&r);
+    }
+    #[test]
+    fn result_inheritance_replays_from_fresh_cached_prepared_and_decoded_libraries() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut base = Model::new();
+        base.add_library_source("return-library.kerml", LIB);
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(93).unwrap(), 93).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("return-library.kerml", LIB);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            m.add_source("return-user.kerml", "feature n;feature x=n;");
+            let mut r = ResolvedModel::build(&m);
+            let expr = r
+                .user_elements()
+                .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+                .unwrap();
+            r.implied_relationships(expr);
+            let (_, result, relation) = generated(&r);
+            let ids = (r.b.elements[result].id, r.b.elements[relation].id);
+            if let Some(expected) = expected {
+                assert_eq!(ids, expected);
+            }
+            expected = Some(ids);
+        }
+    }
+    #[test]
+    fn identity_binding_discards_and_rebuilds_the_whole_common_tail() {
+        let target = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"bound result referent");
+        let mut r = unpublished(
+            LIB,
+            &format!("feature n;feature ready=n;feature later='{target}';"),
+        );
+        let expressions: Vec<_> = r
+            .user_elements()
+            .filter(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .collect();
+        assert_eq!(expressions.len(), 2);
+        r.implied_relationships(expressions[0]);
+        let from = r.b.implied.as_ref().unwrap().owned_results_from;
+        let ready = r.b.elements[generated(&r).2].id;
+        let n = r.resolve_qualified("n").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), target)]));
+        assert!(r.bind_id_spelled_references().contains(&target));
+        assert_eq!(r.b.elements.len(), from);
+        assert!(r.b.dynamic_graph.is_none());
+        r.implied_relationships(expressions[0]);
+        let evidence =
+            r.b.dynamic_graph
+                .as_ref()
+                .unwrap()
+                .result_redefinition
+                .as_ref()
+                .unwrap();
+        assert_eq!(evidence.sources.len(), 2);
+        assert!(
+            evidence
+                .relationships
+                .iter()
+                .any(|&rel| r.b.elements[rel].id == ready)
+        );
+    }
+    #[test]
+    fn actual_library_witness() {
+        let library = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        let mut m = Model::new();
+        m.load_library_dir(&library).unwrap();
+        m.add_source("return-actual.kerml", "feature n;feature x=n;");
+        let mut r = ResolvedModel::build(&m);
+        let e = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+            .unwrap();
+        r.implied_relationships(e);
+        let expected = r
+            .resolve_qualified("Performances::Evaluation::result")
+            .unwrap()
+            .0;
+        assert_eq!(canonical_witness(&mut r.b, &mut 0).unwrap().1, expected);
+        let (_, result, relation) = generated(&r);
+        assert_eq!(
+            r.b.elements[relation]
+                .props
+                .get("redefinedFeature")
+                .and_then(|v| v.as_reference()),
+            Some(r.b.elements[expected].id)
+        );
+        assert!(r.b.elements[result].owned_relationships.contains(&relation));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/runtime_frames.rs b/crates/sysmlv2-model/src/json/runtime_frames.rs
new file mode 100644
index 0000000..edf881b
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/runtime_frames.rs
@@ -0,0 +1,259 @@
+//! Query-local admission proofs for monotonic runtime argument visibility.
+//!
+//! This provider proves eligibility at one declaration boundary. Callers must
+//! intersect the result with the prior visible set and restore their masks on
+//! return; a successful proof never re-enables an already hidden activation.
+
+use super::parameter_context::{descendant, explicit_ancestor};
+use super::{
+    Builder, ElementRef, ResolvedModel, ScopeRef, provider_completeness::ProviderCompleteness,
+};
+use std::collections::HashMap;
+
+/// One active calculation or lambda application. External query name bindings
+/// are not runtime frames and retain their separate compatibility contract.
+#[derive(Clone, Copy, Debug)]
+pub struct RuntimeFrame {
+    /// Actual calculation declaration, or `None` for a lambda application.
+    pub callee: Option<ElementRef>,
+    /// Declaration scope of this activation. A source-less query lambda has no
+    /// model scope; using the global scope would incorrectly admit all callees.
+    pub lexical_scope: Option<ScopeRef>,
+    /// Actual featuring context used to evaluate this activation's defaults.
+    /// It can differ from an inherited default's lexical declaration scope.
+    pub receiver_scope: ScopeRef,
+    /// Eligibility inherited from every surrounding declaration boundary.
+    pub visible: bool,
+}
+
+impl RuntimeFrame {
+    /// Start a calculation activation in its own body/receiver scope.
+    pub fn calculation(callee: ElementRef, scope: ScopeRef) -> Self {
+        Self {
+            callee: Some(callee),
+            lexical_scope: Some(scope),
+            receiver_scope: scope,
+            visible: true,
+        }
+    }
+
+    /// Start a distinct lambda activation, including inside calculations.
+    pub fn lambda(lexical_scope: Option<ScopeRef>, receiver_scope: ScopeRef) -> Self {
+        Self {
+            callee: None,
+            lexical_scope,
+            receiver_scope,
+            visible: true,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+struct AdmissionKey {
+    callee: Option<ElementRef>,
+    declaration: ScopeRef,
+    frame_receiver: ScopeRef,
+    lexical: ScopeRef,
+    receiver: ScopeRef,
+}
+
+/// Memoized proofs for one immutable-model evaluation. Discard before mutating
+/// identities, relationship endpoints, imports, or other model configuration.
+#[derive(Default)]
+pub struct RuntimeFrameProof {
+    providers: ProviderCompleteness,
+    known: HashMap<AdmissionKey, bool>,
+}
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+impl RuntimeFrameProof {
+    /// Whether an existing visible activation remains eligible when entering
+    /// a model declaration. `None` means incomplete evidence or exhausted
+    /// budget and must be propagated as unsupported. Hidden frames stay hidden.
+    ///
+    /// Syntactic lambda bodies are lexical continuations: callers preserve
+    /// the current visible set and push a new frame there, rather than applying
+    /// this declaration boundary (or inventing a root scope for query lambdas).
+    pub fn permits(
+        &mut self,
+        model: &mut ResolvedModel,
+        frame: RuntimeFrame,
+        lexical: ScopeRef,
+        receiver: ScopeRef,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        self.permits_builder(&mut model.b, frame, lexical, receiver, steps)
+    }
+
+    pub(crate) fn permits_builder(
+        &mut self,
+        b: &mut Builder,
+        frame: RuntimeFrame,
+        lexical: ScopeRef,
+        receiver: ScopeRef,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        if !frame.visible {
+            return Some(false);
+        }
+        if !b.semantic_ready {
+            return None;
+        }
+        b.scopes.get(lexical.0)?;
+        b.scopes.get(receiver.0)?;
+        let Some(declaration) = frame.lexical_scope else {
+            return frame.callee.is_none().then_some(false);
+        };
+        let key = AdmissionKey {
+            callee: frame.callee,
+            declaration,
+            frame_receiver: frame.receiver_scope,
+            lexical,
+            receiver,
+        };
+        if let Some(&known) = self.known.get(&key) {
+            return Some(known);
+        }
+        let result = self.prove(b, frame, declaration, lexical, receiver, steps)?;
+        self.known.insert(key, result);
+        Some(result)
+    }
+
+    fn prove(
+        &mut self,
+        b: &mut Builder,
+        frame: RuntimeFrame,
+        declaration: ScopeRef,
+        lexical: ScopeRef,
+        receiver: ScopeRef,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        // Ordinary nested lexical capture needs no inheritance approximation.
+        if descendant(b, lexical.0, declaration.0, steps)? {
+            return Some(true);
+        }
+        let Some(callee) = frame.callee else {
+            return Some(false);
+        };
+        let callee_scope = *b.elem_scope.get(&callee.0)?;
+        // A value from an ancestor declaration may use the active specializing
+        // calculation's arguments only in that calculation's actual context.
+        if !descendant(b, receiver.0, callee_scope, steps)? {
+            return Some(false);
+        }
+        if !self.providers.scope(b, callee_scope, steps) {
+            return None;
+        }
+        let Some(owner) = b.nearest_scope_owner(lexical.0) else {
+            return Some(false);
+        };
+        explicit_ancestor(b, callee.0, owner, steps)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+
+    fn model() -> ResolvedModel {
+        let mut m = Model::new();
+        m.add_source(
+            "frames.sysml",
+            "calc def Base { in p; attribute v=p; calc def Nested {Base::p}
+            attribute values=(1,2)->collect {in lambdaInput; lambdaInput}; }
+            calc def Child :> Base {in q :>> Base::p;}
+            calc def Other {Base::p}
+            package Constants {attribute value=Base::p;}",
+        );
+        assert!(!m.has_errors());
+        ResolvedModel::build(&m)
+    }
+
+    fn scope(r: &mut ResolvedModel, name: &str) -> (ElementRef, ScopeRef) {
+        let element = r.resolve_qualified(name).unwrap();
+        (element, r.element_scope(element).unwrap())
+    }
+
+    #[test]
+    fn frames_distinguish_lexical_and_receiver_admission() {
+        let mut r = model();
+        let (base, base_scope) = scope(&mut r, "Base");
+        let (child, child_scope) = scope(&mut r, "Child");
+        let (_, nested) = scope(&mut r, "Base::Nested");
+        let (_, other) = scope(&mut r, "Other");
+        let (_, constants) = scope(&mut r, "Constants");
+        let mut proof = RuntimeFrameProof::default();
+        let base_frame = RuntimeFrame::calculation(base, base_scope);
+        assert_eq!(
+            proof.permits(&mut r, base_frame, nested, nested, &mut 0),
+            Some(true)
+        );
+        assert_eq!(
+            proof.permits(&mut r, base_frame, other, other, &mut 0),
+            Some(false)
+        );
+        assert_eq!(
+            proof.permits(&mut r, base_frame, constants, base_scope, &mut 0),
+            Some(false)
+        );
+        let child_frame = RuntimeFrame::calculation(child, child_scope);
+        assert_eq!(
+            proof.permits(&mut r, child_frame, base_scope, child_scope, &mut 0),
+            Some(true)
+        );
+        assert_eq!(
+            proof.permits(&mut r, child_frame, base_scope, base_scope, &mut 0),
+            Some(false)
+        );
+    }
+
+    #[test]
+    fn cached_admission_never_reactivates_a_hidden_frame() {
+        let mut r = model();
+        let (base, s) = scope(&mut r, "Base");
+        let mut frame = RuntimeFrame::calculation(base, s);
+        let mut proof = RuntimeFrameProof::default();
+        assert_eq!(proof.permits(&mut r, frame, s, s, &mut 0), Some(true));
+        frame.visible = false;
+        assert_eq!(proof.permits(&mut r, frame, s, s, &mut 0), Some(false));
+        frame.visible = true;
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(proof.permits(&mut r, frame, s, s, &mut exhausted), None);
+        assert_eq!(proof.permits(&mut r, frame, s, s, &mut 0), Some(true));
+    }
+
+    #[test]
+    fn lambdas_have_their_own_declared_scope_or_no_declaration_scope() {
+        let mut r = model();
+        let (_, base_scope) = scope(&mut r, "Base");
+        let p =
+            r.b.elements
+                .iter()
+                .position(|e| {
+                    e.props.get("declaredName").and_then(|v| v.as_str()) == Some("lambdaInput")
+                })
+                .unwrap();
+        let lambda_scope = ScopeRef(r.b.owner_scope_of(p).unwrap());
+        let mut proof = RuntimeFrameProof::default();
+        let frame = RuntimeFrame::lambda(Some(lambda_scope), base_scope);
+        assert_eq!(
+            proof.permits(&mut r, frame, lambda_scope, base_scope, &mut 0),
+            Some(true)
+        );
+        assert_eq!(
+            proof.permits(&mut r, frame, base_scope, base_scope, &mut 0),
+            Some(false)
+        );
+        let query_frame = RuntimeFrame::lambda(None, base_scope);
+        assert_eq!(
+            proof.permits(&mut r, query_frame, lambda_scope, base_scope, &mut 0),
+            Some(false)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/scope_table.rs b/crates/sysmlv2-model/src/json/scope_table.rs
index 281094a..7f1e0be 100644
--- a/crates/sysmlv2-model/src/json/scope_table.rs
+++ b/crates/sysmlv2-model/src/json/scope_table.rs
@@ -7,11 +7,11 @@ use crate::{
     layered::LayeredVec,
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
 #[derive(Clone)]
 pub(super) enum Names {
-    Owned(HashMap<String, Vec<Binding>>),
+    Owned(crate::layered::IdMap<String, Vec<Binding>>),
     Table {
         rows: Row<Name>,
         bindings: Arc<Vec<Binding>>,
@@ -19,7 +19,7 @@ pub(super) enum Names {
 }
 impl Default for Names {
     fn default() -> Self {
-        Self::Owned(HashMap::new())
+        Self::Owned(crate::layered::IdMap::default())
     }
 }
 #[derive(Clone, Serialize, Deserialize)]
diff --git a/crates/sysmlv2-model/src/json/semantic.rs b/crates/sysmlv2-model/src/json/semantic.rs
new file mode 100644
index 0000000..590b417
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic.rs
@@ -0,0 +1,520 @@
+//! Checked semantic reads. Compatibility accessors remain available for
+//! callers that explicitly accept incomplete derivations.
+
+use super::{Derived, DerivedValue, Derives, ElementRef, Reference, ResolvedModel, derives_under};
+use crate::semantic_catalog::{self, PropertySpec};
+use serde_json::{Value, json};
+pub(super) mod certified_types;
+mod export;
+use certified_types::CheckedRow;
+pub use certified_types::{ConditionalPropertyCapability, conditional_property_capability};
+
+/// Why a specification property cannot be returned as an exact value.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum PropertyError {
+    NotDeclared,
+    NotComputed,
+    Approximate,
+    /// The declaration has a conditional implementation, but this receiver's
+    /// complete type projection could not be established.
+    IncompleteTypeProjection(super::FeatureTypeIssue),
+    /// Complete Usage variability could not be established for this receiver.
+    IncompleteUsageVariability(super::UsageVariabilityIssue),
+    /// Complete ordered Type.input could not be established.
+    IncompleteTypeInput(super::TypeInputIssue),
+    /// Complete ordered Type feature or membership projections could not be established.
+    IncompleteTypeFeatures(super::TypeInputIssue),
+    /// A complete supplied Invocation argument mapping could not be established.
+    IncompleteInvocationBindings(super::InvocationBindingIssue),
+    /// Complete canonical Constructor supplied-argument mapping could not be established.
+    IncompleteConstructorBindings(super::ConstructorBindingIssue),
+    /// Complete ordinary Function result selection could not be established.
+    IncompleteFunctionResult(super::TypeInputIssue),
+    MissingRequiredValue,
+    UnresolvedReference(String),
+    InvalidValue(String),
+}
+
+impl std::fmt::Display for PropertyError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NotDeclared => f.write_str("property is not declared"),
+            Self::NotComputed => f.write_str("property is not computed"),
+            Self::Approximate => f.write_str("property has an incomplete derivation"),
+            Self::IncompleteTypeProjection(reason) => {
+                write!(f, "type projection is incomplete: {reason:?}")
+            }
+            Self::IncompleteUsageVariability(reason) => {
+                write!(f, "Usage variability is incomplete: {reason:?}")
+            }
+            Self::IncompleteTypeInput(reason) => write!(f, "Type.input is incomplete: {reason:?}"),
+            Self::IncompleteTypeFeatures(reason) => {
+                write!(f, "Type features are incomplete: {reason:?}")
+            }
+            Self::IncompleteInvocationBindings(reason) => {
+                write!(f, "Invocation arguments are incomplete: {reason:?}")
+            }
+            Self::IncompleteConstructorBindings(reason) => {
+                write!(f, "Constructor arguments are incomplete: {reason:?}")
+            }
+            Self::IncompleteFunctionResult(reason) => {
+                write!(f, "Function.result is incomplete: {reason:?}")
+            }
+            Self::MissingRequiredValue => f.write_str("required property has no value"),
+            Self::UnresolvedReference(s) => write!(f, "unresolved reference: {s}"),
+            Self::InvalidValue(s) => write!(f, "invalid property value: {s}"),
+        }
+    }
+}
+
+impl std::error::Error for PropertyError {}
+
+/// A field that prevented strict full-form export.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PropertyIssue {
+    pub element_id: uuid::Uuid,
+    pub property: String,
+    pub reason: PropertyError,
+}
+
+/// Strict export never substitutes placeholders. Unavailable fields are
+/// collected for an established snapshot. Snapshot or identity failures may
+/// stop the export before property inspection.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SemanticExportError {
+    pub issues: Vec<PropertyIssue>,
+}
+
+impl std::fmt::Display for SemanticExportError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "strict export refused: {} unavailable properties",
+            self.issues.len()
+        )?;
+        if let Some(first) = self.issues.first() {
+            write!(
+                f,
+                " ({}.{}: {})",
+                first.element_id, first.property, first.reason
+            )?;
+        }
+        Ok(())
+    }
+}
+impl std::error::Error for SemanticExportError {}
+
+impl ResolvedModel {
+    /// Export specification properties through the checked semantic reader.
+    /// No recovery annotations or invented references are inserted. Incomplete
+    /// semantic support causes refusal, even for a syntactically valid model.
+    /// The current closure policy is preserved and never implicitly promoted.
+    pub fn to_full_json_strict(&mut self) -> Result<Value, SemanticExportError> {
+        export::full(self)
+    }
+
+    /// Read an owned or derived property by its specification name. Inherited
+    /// names follow metamodel redefinitions, including changes of name, shape
+    /// and derived status. Required values, known target metaclasses and
+    /// multiplicities are checked. Unknown computations are errors, not defaults.
+    /// Core type/behavior/function reads require complete bounded evidence and
+    /// full semantic closure. Unsupported type-dependent derivations refuse;
+    /// compatibility values remain available through [`Self::derived`].
+    /// Other external UUIDs are preserved; their target type cannot be verified locally.
+    pub fn property(&mut self, e: ElementRef, name: &str) -> Result<Value, PropertyError> {
+        self.property_with_row(e, name, &mut CheckedRow::default())
+    }
+
+    fn property_with_row(
+        &mut self,
+        e: ElementRef,
+        name: &str,
+        row: &mut CheckedRow,
+    ) -> Result<Value, PropertyError> {
+        let (requested, effective) = semantic_catalog::property(self.element_type(e), name)
+            .ok_or(PropertyError::NotDeclared)?;
+        let spec = effective.ok_or(PropertyError::NotComputed)?;
+        if let Some(result) = row.read_declared(self, e, requested, spec) {
+            return result.map(|value| self.semantic_json(value));
+        }
+        let mut value = match row.read_owned_source(self, e, spec) {
+            Some(result) => result?,
+            None => self.effective_property(e, spec, row)?,
+        };
+        self.validate_property_value(spec, &value)?;
+        value = reshape(value, requested)?;
+        self.validate_property_value(requested, &value)?;
+        Ok(value)
+    }
+
+    fn effective_property(
+        &mut self,
+        e: ElementRef,
+        spec: &PropertySpec,
+        row: &mut CheckedRow,
+    ) -> Result<Value, PropertyError> {
+        let ty = self.element_type(e);
+        if ty == "FeatureReferenceExpression"
+            && matches!(spec.name, "ownedRelationship" | "isImpliedIncluded")
+            && !self.owned_result_projection_ready(e)
+        {
+            return Err(PropertyError::Approximate);
+        }
+        // Fixed constraints override the concrete syntax's default bits.
+        if spec.name == "isSufficient" && super::metaclass_conforms(ty, "ConnectionDefinition") {
+            return Ok(json!(true));
+        }
+        if spec.name == "isConstant"
+            && self.b.graph_format == crate::model::GraphFormat::LegacyV2
+            && super::metaclass_conforms(ty, "Usage")
+            && self.b.elements[e.0]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true)
+        {
+            // The end constraint is conditional on mayTimeVary; do not guess.
+            return Err(PropertyError::NotComputed);
+        }
+        if spec.derived {
+            if matches!(
+                spec.id,
+                "Root-Namespaces-Namespace-importedMembership"
+                    | "Root-Namespaces-Namespace-membership"
+                    | "Root-Namespaces-Namespace-member"
+            ) {
+                let value = row.read_namespace(self, e, spec.id)?;
+                return Ok(self.semantic_json(value));
+            }
+            let value = self.derived_exact_with_row(e, spec.name, row)?;
+            return Ok(self.semantic_json(value));
+        }
+        let id = |r: usize| json!({"@id": self.element_id(ElementRef(r)).to_string()});
+        match spec.name {
+            "elementId" => return Ok(json!(self.element_id(e).to_string())),
+            "owningRelationship" => {
+                return Ok(self.b.elements[e.0]
+                    .owning_relationship
+                    .map(id)
+                    .unwrap_or(Value::Null));
+            }
+            "ownedRelatedElement" => {
+                return Ok(Value::Array(
+                    self.b.elements[e.0]
+                        .children
+                        .iter()
+                        .map(|&r| id(r))
+                        .collect(),
+                ));
+            }
+            "ownedRelationship" => {
+                if !self.implied_relationships(e).is_empty() {
+                    return Err(PropertyError::Approximate);
+                }
+                return Ok(Value::Array(
+                    self.owned_relationships(e)
+                        .into_iter()
+                        .map(|r| json!({"@id": self.element_id(r).to_string()}))
+                        .collect(),
+                ));
+            }
+            "isImpliedIncluded" => {
+                return if self.implied_relationships(e).is_empty() {
+                    Ok(json!(false))
+                } else {
+                    Err(PropertyError::Approximate)
+                };
+            }
+            "owningRelatedElement" => {
+                self.ensure_rel_owner();
+                return Ok(self.rel_owner[e.0]
+                    .map(|r| json!({"@id": self.element_id(ElementRef(r)).to_string()}))
+                    .unwrap_or(Value::Null));
+            }
+            _ => {}
+        }
+        for name in spec.storage_names {
+            if let Some(value) = self.b.elements[e.0].props.get(name) {
+                // Compact storage may retain a general property's spelling/shape.
+                return reshape(value.to_json(), spec);
+            }
+        }
+        if let Some(default) = spec.default_json {
+            return serde_json::from_str(default)
+                .map_err(|e| PropertyError::InvalidValue(e.to_string()));
+        }
+        if spec.lower == 0 {
+            return Ok(if spec.upper == Some(1) {
+                Value::Null
+            } else {
+                json!([])
+            });
+        }
+        Err(PropertyError::MissingRequiredValue)
+    }
+
+    fn semantic_json(&self, value: DerivedValue) -> Value {
+        let id = |e: ElementRef| json!({"@id": self.element_id(e).to_string()});
+        let reference = |r: Reference| match r {
+            Reference::Element(e) => id(e),
+            Reference::External(u) => json!({"@id": u.to_string()}),
+            Reference::Unresolved(s) => json!({"@ref": s}),
+        };
+        match value {
+            DerivedValue::Null => Value::Null,
+            DerivedValue::Bool(v) => json!(v),
+            DerivedValue::Str(v) => json!(v),
+            DerivedValue::Strings(v) => json!(v),
+            DerivedValue::Element(e) => id(e),
+            DerivedValue::Elements(es) => Value::Array(es.into_iter().map(id).collect()),
+            DerivedValue::Reference(r) => reference(r),
+            DerivedValue::References(rs) => Value::Array(rs.into_iter().map(reference).collect()),
+        }
+    }
+
+    fn validate_property_value(
+        &mut self,
+        spec: &PropertySpec,
+        value: &Value,
+    ) -> Result<(), PropertyError> {
+        let values: &[Value] = if spec.upper == Some(1) {
+            if value.is_null() {
+                &[]
+            } else {
+                std::slice::from_ref(value)
+            }
+        } else {
+            value
+                .as_array()
+                .ok_or_else(|| PropertyError::InvalidValue("expected an array".into()))?
+        };
+        if values.len() < spec.lower {
+            return Err(PropertyError::MissingRequiredValue);
+        }
+        if spec.upper.is_some_and(|upper| values.len() > upper) {
+            return Err(PropertyError::InvalidValue(
+                "multiplicity upper bound exceeded".into(),
+            ));
+        }
+        if spec.unique && values.len() > 1 {
+            let mut seen = std::collections::HashSet::with_capacity(values.len());
+            for value in values {
+                if !seen.insert(value.to_string()) {
+                    return Err(PropertyError::InvalidValue(
+                        "duplicate value in a unique property".into(),
+                    ));
+                }
+            }
+        }
+        for v in values {
+            if let Some(s) = v.get("@ref").and_then(Value::as_str) {
+                return Err(PropertyError::UnresolvedReference(s.into()));
+            }
+            let valid = match spec.target {
+                "Boolean" => v.is_boolean(),
+                "String" => v.is_string(),
+                "Integer" => v.is_i64() || v.is_u64(),
+                "Real" => v.is_number(),
+                "UnlimitedNatural" => v.is_u64() || v.as_i64() == Some(-1),
+                target if crate::metaclass_name(target).is_some() => {
+                    if let Some(id) = v.get("@id").and_then(Value::as_str) {
+                        if uuid::Uuid::parse_str(id).is_err() {
+                            false
+                        } else if let Some(e) = self.element_by_id(id) {
+                            super::metaclass_conforms(self.element_type(e), target)
+                        } else {
+                            true
+                        }
+                    } else {
+                        false
+                    }
+                }
+                _ if !spec.enum_values.is_empty() => {
+                    v.as_str().is_some_and(|s| spec.enum_values.contains(&s))
+                }
+                _ => return Err(PropertyError::NotComputed),
+            };
+            if !valid {
+                return Err(PropertyError::InvalidValue(format!(
+                    "expected {}",
+                    spec.target
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    /// Read a derived property whose implementation is classified `Exact`.
+    /// Unlike [`Self::derived`], this refuses passthrough values and unresolved
+    /// spellings. A required reference is never substituted with a self-reference.
+    /// External UUID references remain explicit external references.
+    /// This is not whole-model validation or certification of reference target
+    /// types and multiplicities beyond the required-reference check.
+    pub fn derived_exact(
+        &mut self,
+        e: ElementRef,
+        name: &str,
+    ) -> Result<DerivedValue, PropertyError> {
+        self.derived_exact_with_row(e, name, &mut CheckedRow::default())
+    }
+
+    fn derived_exact_with_row(
+        &mut self,
+        e: ElementRef,
+        name: &str,
+        row: &mut CheckedRow,
+    ) -> Result<DerivedValue, PropertyError> {
+        if let Some(result) = row.read(self, e, name) {
+            return result;
+        }
+        if self.element_type(e) == "FeatureReferenceExpression" {
+            // Local result/binding additions do not certify every required
+            // family or existing-result expression, so entire collections
+            // remain qualified.
+            if matches!(
+                name,
+                "ownedElement"
+                    | "ownedMember"
+                    | "ownedFeature"
+                    | "ownedFeatureMembership"
+                    | "ownedMembership"
+                    | "member"
+                    | "membership"
+                    | "feature"
+                    | "featureMembership"
+            ) || (matches!(name, "result" | "ownedParameter")
+                && !self.owned_result_projection_ready(e))
+            {
+                return Err(PropertyError::Approximate);
+            }
+        }
+        match derives_under(self.element_type(e), name, self.closure_policy()) {
+            Derives::NotDeclared => return Err(PropertyError::NotDeclared),
+            Derives::NotComputed => return Err(PropertyError::NotComputed),
+            Derives::Passthrough => return Err(PropertyError::Approximate),
+            Derives::Exact => {}
+        }
+        let value = match self.derived(e, name) {
+            Derived::NotDeclared => return Err(PropertyError::NotDeclared),
+            Derived::NotComputed => return Err(PropertyError::NotComputed),
+            Derived::Value(value) => value,
+        };
+        let unresolved = match &value {
+            DerivedValue::Reference(Reference::Unresolved(s)) => Some(s),
+            DerivedValue::References(rs) => rs.iter().find_map(|r| match r {
+                Reference::Unresolved(s) => Some(s),
+                _ => None,
+            }),
+            _ => None,
+        };
+        if let Some(s) = unresolved {
+            return Err(PropertyError::UnresolvedReference(s.clone()));
+        }
+        if value == DerivedValue::Null {
+            let props = crate::schema_props::METACLASS_PROPS;
+            if let Ok(i) = props.binary_search_by_key(&self.element_type(e), |(m, _)| *m) {
+                if let Ok(p) = props[i].1.binary_search_by_key(&name, |(n, _)| *n) {
+                    if props[i].1[p].1 == b'R' {
+                        return Err(PropertyError::MissingRequiredValue);
+                    }
+                }
+            }
+        }
+        Ok(value)
+    }
+}
+
+pub(super) fn reshape(value: Value, spec: &PropertySpec) -> Result<Value, PropertyError> {
+    if spec.upper != Some(1) {
+        return Ok(match value {
+            Value::Array(_) => value,
+            Value::Null => json!([]),
+            other => Value::Array(vec![other]),
+        });
+    }
+    match value {
+        Value::Array(mut values) if values.len() <= 1 => Ok(values.pop().unwrap_or(Value::Null)),
+        Value::Array(_) => Err(PropertyError::InvalidValue(
+            "multiple values for a single-valued redefinition".into(),
+        )),
+        other => Ok(other),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+
+    #[test]
+    fn strict_export_refuses_duplicate_row_identities() {
+        let mut m = Model::new();
+        m.add_source("identity.sysml", "package A; package B;");
+        let mut r = ResolvedModel::build(&m);
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        r.b.elements[b.0].id = r.element_id(a);
+        let report = r.to_full_json_strict().unwrap_err();
+        assert!(report.issues.iter().any(|issue| issue.property == "@id"
+            && matches!(issue.reason, PropertyError::InvalidValue(_))));
+    }
+
+    #[test]
+    fn semantic_validation_rejects_bad_enums_targets_and_duplicate_ids() {
+        let mut model = Model::new();
+        model.add_source("m.sysml", "package P { part def D; part p : D; }");
+        let mut r = ResolvedModel::build(&model);
+        let p = r.resolve_qualified("P::p").unwrap();
+        let pkg = r.resolve_qualified("P").unwrap();
+        let membership = r.b.elements[p.0].owning_relationship.unwrap();
+        r.b.elements[membership]
+            .props
+            .insert("visibility", json!("sideways"));
+        assert!(matches!(
+            r.property(ElementRef(membership), "visibility"),
+            Err(PropertyError::InvalidValue(_))
+        ));
+        let typing = r
+            .owned_relationships(p)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "FeatureTyping")
+            .unwrap();
+        let pkg_id = r.element_id(pkg).to_string();
+        r.b.elements[typing.0]
+            .props
+            .insert("type", json!({"@id": pkg_id}));
+        assert!(matches!(
+            r.property(typing, "general"),
+            Err(PropertyError::InvalidValue(_))
+        ));
+        let spec = semantic_catalog::property("Namespace", "ownedRelationship")
+            .unwrap()
+            .0;
+        assert!(matches!(
+            r.validate_property_value(spec, &json!([{"@id": pkg_id}, {"@id": pkg_id}])),
+            Err(PropertyError::InvalidValue(_))
+        ));
+    }
+
+    #[test]
+    fn multiple_inheritance_ambiguity_is_explicit() {
+        let (_, effective) = semantic_catalog::property("BindingConnectorAsUsage", "type").unwrap();
+        assert!(effective.is_none());
+        assert!(
+            semantic_catalog::property("BindingConnectorAsUsage", "definition")
+                .unwrap()
+                .1
+                .is_some()
+        );
+        assert!(
+            semantic_catalog::property("BindingConnectorAsUsage", "association")
+                .unwrap()
+                .1
+                .is_some()
+        );
+    }
+}
+
+#[cfg(test)]
+mod type_fidelity_tests;
diff --git a/crates/sysmlv2-model/src/json/semantic/certified_types.rs b/crates/sysmlv2-model/src/json/semantic/certified_types.rs
new file mode 100644
index 0000000..7f51910
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic/certified_types.rs
@@ -0,0 +1,1507 @@
+//! Conditional implementation capabilities, separate from the normative catalog.
+use super::PropertyError;
+use crate::{
+    json::{
+        ClosurePolicy, DerivedValue, ElementRef, FeatureTypeIssue, FeatureTypeReport, Reference,
+        ResolvedModel, implied::SupportedImpliedSpecializations,
+        semantic_ownership::SemanticOwnership,
+    },
+    layered::Revision,
+    semantic_catalog,
+};
+use std::sync::Arc;
+
+/// A declaration can be attempted by the checked reader under the indicated
+/// policy. This is implementation capability metadata, never a promise that all
+/// receivers succeed or a replacement for the normative declaration catalog.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConditionalPropertyCapability {
+    pub declaration: &'static str,
+    pub requires_full_closure: bool,
+}
+
+/// Conditional proof capability for an exact effective declaration identity.
+/// This accessor does not change static `derives` fidelity. SDKs should attempt `property`
+/// and handle its explicit errors, not treat this metadata as certification.
+pub fn conditional_property_capability(declaration: &str) -> Option<ConditionalPropertyCapability> {
+    let declaration = match declaration {
+        "Systems-DefinitionAndUsage-Usage-mayTimeVary" => {
+            "Systems-DefinitionAndUsage-Usage-mayTimeVary"
+        }
+        "Systems-DefinitionAndUsage-Definition-usage" => {
+            "Systems-DefinitionAndUsage-Definition-usage"
+        }
+        "Systems-DefinitionAndUsage-Definition-directedUsage" => {
+            "Systems-DefinitionAndUsage-Definition-directedUsage"
+        }
+        "Core-Types-Type-input" => "Core-Types-Type-input",
+        "Core-Types-Type-feature" => "Core-Types-Type-feature",
+        "Core-Types-Type-featureMembership" => "Core-Types-Type-featureMembership",
+        "Core-Types-Type-inheritedMembership" => "Core-Types-Type-inheritedMembership",
+        "Core-Types-Type-inheritedFeature" => "Core-Types-Type-inheritedFeature",
+        "Core-Types-Type-output" => "Core-Types-Type-output",
+        "Core-Types-Type-directedFeature" => "Core-Types-Type-directedFeature",
+        "Core-Types-Type-endFeature" => "Core-Types-Type-endFeature",
+        "Kernel-Functions-Function-result" => "Kernel-Functions-Function-result",
+        "Kernel-Functions-Expression-result" => "Kernel-Functions-Expression-result",
+        "Kernel-Expressions-InstantiationExpression-instantiatedType" => {
+            "Kernel-Expressions-InstantiationExpression-instantiatedType"
+        }
+        "Kernel-Expressions-InstantiationExpression-argument" => {
+            "Kernel-Expressions-InstantiationExpression-argument"
+        }
+        "Systems-DefinitionAndUsage-Usage-definition" => {
+            "Systems-DefinitionAndUsage-Usage-definition"
+        }
+        "Systems-Attributes-AttributeUsage-attributeDefinition" => {
+            "Systems-Attributes-AttributeUsage-attributeDefinition"
+        }
+        "Systems-Occurrences-OccurrenceUsage-occurrenceDefinition" => {
+            "Systems-Occurrences-OccurrenceUsage-occurrenceDefinition"
+        }
+        "Systems-Items-ItemUsage-itemDefinition" => "Systems-Items-ItemUsage-itemDefinition",
+        "Systems-Parts-PartUsage-partDefinition" => "Systems-Parts-PartUsage-partDefinition",
+        "Core-Features-Feature-type" => "Core-Features-Feature-type",
+        "Kernel-Behaviors-Step-behavior" => "Kernel-Behaviors-Step-behavior",
+        "Kernel-Functions-Expression-function" => "Kernel-Functions-Expression-function",
+        _ => return None,
+    };
+    Some(ConditionalPropertyCapability {
+        declaration,
+        requires_full_closure: true,
+    })
+}
+fn same_arc<T>(a: &Option<Arc<T>>, b: &Option<Arc<T>>) -> bool {
+    match (a, b) {
+        (None, None) => true,
+        (Some(a), Some(b)) => Arc::ptr_eq(a, b),
+        _ => false,
+    }
+}
+
+/// Private query snapshot. Every semantic input that can change proof results
+/// without changing rows must participate in the freshness check.
+pub(in crate::json) struct Stamp {
+    publication: crate::json::publication::Revision,
+    rows: Revision,
+    len: usize,
+    explicit: usize,
+    library: usize,
+    ownership: Option<Arc<SemanticOwnership>>,
+    metadata: Option<Arc<()>>,
+    retained: Option<Arc<SupportedImpliedSpecializations>>,
+    metadata_incomplete: bool,
+    lookup_incomplete: bool,
+    ready: bool,
+    positional_ready: bool,
+    policy: Option<ClosurePolicy>,
+}
+impl Stamp {
+    pub(in crate::json) fn capture(r: &mut ResolvedModel) -> Self {
+        let mut stamp = Self::capture_builder(&mut r.b);
+        stamp.policy = Some(r.closure_policy());
+        stamp
+    }
+    pub(in crate::json) fn capture_builder(b: &mut crate::json::Builder) -> Self {
+        Self {
+            publication: b.publication.revision(),
+            rows: b.elements.observe_revision(),
+            len: b.elements.len(),
+            explicit: b.explicit_len(),
+            library: b.lib_boundary,
+            ownership: b.semantic_ownership.clone(),
+            metadata: b.metadata_association_generation.clone(),
+            retained: b.supported_implied.clone(),
+            metadata_incomplete: b.metadata_associations_incomplete,
+            lookup_incomplete: b.recorded_lookup_incomplete,
+            ready: b.semantic_ready,
+            positional_ready: b.positional_redefinitions.is_some(),
+            policy: None,
+        }
+    }
+    pub(in crate::json) fn current(&self, r: &ResolvedModel) -> bool {
+        self.current_builder(&r.b)
+            && self
+                .policy
+                .is_none_or(|policy| policy == r.closure_policy())
+    }
+    pub(in crate::json) fn current_builder(&self, b: &crate::json::Builder) -> bool {
+        !b.positional_planning
+            && self.publication.same_as(&b.publication.revision())
+            && b.elements.revision().is_some_and(|v| self.rows.same_as(v))
+            && self.len == b.elements.len()
+            && self.explicit == b.explicit_len()
+            && self.library == b.lib_boundary
+            && same_arc(&self.ownership, &b.semantic_ownership)
+            && same_arc(&self.metadata, &b.metadata_association_generation)
+            && same_arc(&self.retained, &b.supported_implied)
+            && self.metadata_incomplete == b.metadata_associations_incomplete
+            && self.lookup_incomplete == b.recorded_lookup_incomplete
+            && self.ready == b.semantic_ready
+            && self.positional_ready == b.positional_redefinitions.is_some()
+    }
+}
+struct Cached {
+    receiver: ElementRef,
+    stamp: Stamp,
+    report: FeatureTypeReport,
+}
+struct CachedFeatures {
+    receiver: ElementRef,
+    stamp: Stamp,
+    projections: crate::json::TypeFeatures,
+}
+#[derive(Default)]
+pub(super) struct CheckedRow {
+    namespaces: crate::json::operations::namespaces::NamespaceRow,
+    cached: Option<Cached>,
+    features: Option<CachedFeatures>,
+    steps: usize,
+}
+impl CheckedRow {
+    pub(in crate::json) fn read_namespace(
+        &mut self,
+        r: &mut ResolvedModel,
+        receiver: ElementRef,
+        declaration: &'static str,
+    ) -> Result<DerivedValue, PropertyError> {
+        if crate::json::type_features::supported_root(r.element_type(receiver))
+            && matches!(
+                declaration,
+                "Root-Namespaces-Namespace-membership" | "Root-Namespaces-Namespace-member"
+            )
+        {
+            if r.closure_policy()
+                != (ClosurePolicy::Closure {
+                    include_implied: true,
+                })
+            {
+                return Err(PropertyError::Approximate);
+            }
+            return self.read_features(r, receiver, declaration);
+        }
+        self.namespaces
+            .property(r, receiver, declaration, &mut self.steps)
+    }
+    fn ensure_features(
+        &mut self,
+        r: &mut ResolvedModel,
+        receiver: ElementRef,
+    ) -> Result<(), crate::json::TypeInputIssue> {
+        self.steps = self.steps.saturating_add(1);
+        if self.steps > crate::eval::MAX_STEPS {
+            return Err(crate::json::TypeInputIssue::WorkLimit);
+        }
+        if !self
+            .features
+            .as_ref()
+            .is_some_and(|c| c.receiver == receiver && c.stamp.current(r))
+        {
+            self.features = None;
+            let report = r.type_feature_report_with_budget(receiver, self.steps);
+            self.steps = report.steps;
+            let projections = report.projections?;
+            self.features = Some(CachedFeatures {
+                receiver,
+                stamp: Stamp::capture(r),
+                projections,
+            });
+        }
+        Ok(())
+    }
+    fn read_features(
+        &mut self,
+        r: &mut ResolvedModel,
+        receiver: ElementRef,
+        declaration: &str,
+    ) -> Result<DerivedValue, PropertyError> {
+        let error = |issue| {
+            if declaration == "Core-Types-Type-input" {
+                PropertyError::IncompleteTypeInput(issue)
+            } else {
+                PropertyError::IncompleteTypeFeatures(issue)
+            }
+        };
+        self.ensure_features(r, receiver).map_err(error)?;
+        let p = &self
+            .features
+            .as_ref()
+            .expect("complete current certificate")
+            .projections;
+        let refs = match declaration {
+            "Core-Types-Type-input" => &p.inputs,
+            "Core-Types-Type-output" => &p.outputs,
+            "Core-Types-Type-directedFeature" => &p.directed_features,
+            "Core-Types-Type-endFeature" => &p.end_features,
+            "Core-Types-Type-feature" => &p.features,
+            "Core-Types-Type-featureMembership" => &p.feature_memberships,
+            "Core-Types-Type-inheritedFeature" => &p.inherited_features,
+            "Core-Types-Type-inheritedMembership" => &p.inherited_memberships,
+            "Root-Namespaces-Namespace-membership" => {
+                p.memberships.as_ref().map_err(|e| error(*e))?
+            }
+            "Root-Namespaces-Namespace-member" => p.members.as_ref().map_err(|e| error(*e))?,
+            _ => unreachable!("audited Type sequence declaration"),
+        };
+        self.steps = self.steps.saturating_add(refs.len().saturating_mul(12));
+        if self.steps > crate::eval::MAX_STEPS {
+            return Err(error(crate::json::TypeInputIssue::WorkLimit));
+        }
+        Ok(DerivedValue::References(
+            refs.iter().copied().map(Reference::Element).collect(),
+        ))
+    }
+    fn charge(&mut self, amount: usize) -> Result<(), PropertyError> {
+        self.steps = self.steps.saturating_add(amount);
+        if self.steps > crate::eval::MAX_STEPS {
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::WorkLimit,
+            ))
+        } else {
+            Ok(())
+        }
+    }
+    /// An owned source endpoint uses local carrier evidence, not inheritance
+    /// closure. Its work participates in the same strict-export row budget.
+    pub(super) fn read_owned_source(
+        &mut self,
+        r: &mut ResolvedModel,
+        e: ElementRef,
+        effective: &semantic_catalog::PropertySpec,
+    ) -> Option<Result<serde_json::Value, PropertyError>> {
+        if effective.id == "Root-Elements-Element-ownedRelationship" {
+            return Some(self.owned_relationships(r, e));
+        }
+        if effective.id == "Core-Features-Feature-isConstant" {
+            if let Some(report) = r.canonical_end_constant_with_budget(e, self.steps) {
+                self.steps = report.steps;
+                return Some(
+                    report
+                        .value
+                        .map(serde_json::Value::Bool)
+                        .map_err(PropertyError::IncompleteUsageVariability),
+                );
+            }
+        }
+        if effective.id != "Core-Features-TypeFeaturing-featureOfType" {
+            return None;
+        }
+        let source =
+            crate::json::type_relations::type_featuring_source(&mut r.b, e.0, &mut self.steps);
+        Some(if self.steps > crate::eval::MAX_STEPS {
+            Err(PropertyError::NotComputed)
+        } else {
+            source
+                .map(|id| serde_json::json!({"@id":id.to_string()}))
+                .ok_or_else(|| {
+                    PropertyError::InvalidValue("unproved TypeFeaturing source endpoint".into())
+                })
+        })
+    }
+
+    /// The relationships present in the published model are structural data.
+    /// Reading them does not assert that every required implied family exists.
+    fn owned_relationships(
+        &mut self,
+        r: &mut ResolvedModel,
+        owner: ElementRef,
+    ) -> Result<serde_json::Value, PropertyError> {
+        use crate::json::{publication, semantic_ownership, structural_index::StoredStructure};
+        if r.b.ensure_semantic_graph() != publication::Status::Ready {
+            return Err(PropertyError::Approximate);
+        }
+        r.sync_semantic_publication();
+        let raw = StoredStructure::for_query(&mut r.b, &mut self.steps)
+            .ok_or(PropertyError::Approximate)?;
+        if !raw.ids_unique {
+            return Err(PropertyError::InvalidValue(
+                "duplicate element identity".into(),
+            ));
+        }
+        let rows = semantic_ownership::owned_relationships(&r.b, owner.0)
+            .ok_or(PropertyError::Approximate)?;
+        self.steps = self.steps.saturating_add(rows.len().saturating_mul(12));
+        if self.steps > crate::eval::MAX_STEPS {
+            return Err(PropertyError::Approximate);
+        }
+        let mut seen = std::collections::HashSet::new();
+        let mut values = Vec::with_capacity(rows.len());
+        for relationship in rows.iter() {
+            if !seen.insert(relationship)
+                || semantic_ownership::checked_relationship_carrier(
+                    &r.b,
+                    &raw,
+                    relationship,
+                    &mut self.steps,
+                ) != Some(Some(owner.0))
+            {
+                return Err(PropertyError::InvalidValue(
+                    "inconsistent owned relationship carrier".into(),
+                ));
+            }
+            values.push(
+                serde_json::json!({"@id": r.element_id(ElementRef(relationship)).to_string()}),
+            );
+        }
+        Ok(serde_json::Value::Array(values))
+    }
+
+    pub(super) fn read(
+        &mut self,
+        r: &mut ResolvedModel,
+        e: ElementRef,
+        name: &str,
+    ) -> Option<Result<DerivedValue, PropertyError>> {
+        let (requested, effective) = semantic_catalog::property(r.element_type(e), name)?;
+        let effective = effective?;
+        self.read_declared(r, e, requested, effective)
+    }
+    pub(super) fn read_declared(
+        &mut self,
+        r: &mut ResolvedModel,
+        e: ElementRef,
+        requested: &semantic_catalog::PropertySpec,
+        effective: &semantic_catalog::PropertySpec,
+    ) -> Option<Result<DerivedValue, PropertyError>> {
+        if matches!(
+            effective.id,
+            "Root-Namespaces-Namespace-importedMembership"
+                | "Root-Namespaces-Namespace-membership"
+                | "Root-Namespaces-Namespace-member"
+        ) && (matches!(
+            r.element_type(e),
+            "Namespace" | "Package" | "LibraryPackage"
+        ) || crate::json::type_features::supported_root(r.element_type(e)))
+        {
+            return Some(self.read_namespace(r, e, effective.id));
+        }
+        conditional_property_capability(effective.id)?;
+        // New plain-Type capabilities do not change the established error
+        // contract for unsupported subclasses. Type.input predates this domain
+        // expansion and retains its existing typed qualification.
+        if (effective.id.starts_with("Core-Types-Type-")
+            || matches!(
+                effective.id,
+                "Systems-DefinitionAndUsage-Definition-usage"
+                    | "Systems-DefinitionAndUsage-Definition-directedUsage"
+            ))
+            && effective.id != "Core-Types-Type-input"
+            && !crate::json::type_features::supported_root(r.element_type(e))
+        {
+            return None;
+        }
+        if matches!(
+            effective.id,
+            "Kernel-Functions-Expression-result"
+                | "Kernel-Expressions-InstantiationExpression-instantiatedType"
+        ) && (r.element_type(e) != "ConstructorExpression"
+            || r.b.graph_format != crate::model::GraphFormat::CanonicalV3)
+        {
+            return None;
+        }
+        Some(self.read_known(r, e, requested, effective))
+    }
+    fn read_known(
+        &mut self,
+        r: &mut ResolvedModel,
+        e: ElementRef,
+        requested: &semantic_catalog::PropertySpec,
+        effective: &semantic_catalog::PropertySpec,
+    ) -> Result<DerivedValue, PropertyError> {
+        if r.closure_policy()
+            != (ClosurePolicy::Closure {
+                include_implied: true,
+            })
+        {
+            return Err(PropertyError::Approximate);
+        }
+        if effective.id == "Systems-DefinitionAndUsage-Usage-mayTimeVary" {
+            let report = r.usage_variability_report_with_budget(e, self.steps);
+            self.steps = report.steps;
+            return report
+                .value
+                .map(DerivedValue::Bool)
+                .map_err(PropertyError::IncompleteUsageVariability);
+        }
+        if matches!(
+            effective.id,
+            "Kernel-Functions-Expression-result"
+                | "Kernel-Expressions-InstantiationExpression-instantiatedType"
+        ) {
+            let report = r.constructor_selection_report_with_budget(e, self.steps);
+            self.steps = report.steps.saturating_add(12);
+            if self.steps > crate::eval::MAX_STEPS {
+                return Err(PropertyError::IncompleteConstructorBindings(
+                    crate::json::ConstructorBindingIssue::WorkLimit,
+                ));
+            }
+            let selection = report
+                .selection
+                .map_err(PropertyError::IncompleteConstructorBindings)?;
+            let selected = if effective.id == "Kernel-Functions-Expression-result" {
+                selection.result
+            } else {
+                selection.instantiated_type
+            };
+            validate_references(r, effective, &[selected])?;
+            validate_references(r, requested, &[selected])?;
+            return Ok(DerivedValue::Reference(Reference::Element(selected)));
+        }
+        if effective.id == "Kernel-Functions-Function-result" {
+            if r.element_type(e) != "Function" {
+                return Err(PropertyError::IncompleteFunctionResult(
+                    crate::json::TypeInputIssue::UnsupportedConfiguration,
+                ));
+            }
+            self.ensure_features(r, e)
+                .map_err(PropertyError::IncompleteFunctionResult)?;
+            let features = &self
+                .features
+                .as_ref()
+                .expect("complete current certificate")
+                .projections
+                .features;
+            self.steps = self.steps.saturating_add(features.len()).saturating_add(12);
+            if self.steps > crate::eval::MAX_STEPS {
+                return Err(PropertyError::IncompleteFunctionResult(
+                    crate::json::TypeInputIssue::WorkLimit,
+                ));
+            }
+            let result = features
+                .iter()
+                .copied()
+                .find(|f| {
+                    r.b.elements[f.0].owning_relationship.is_some_and(|m| {
+                        crate::metaclass::conforms(r.b.elements[m].ty, "ReturnParameterMembership")
+                    })
+                })
+                .ok_or(PropertyError::MissingRequiredValue)?;
+            validate_references(r, effective, &[result])?;
+            validate_references(r, requested, &[result])?;
+            return Ok(DerivedValue::Reference(Reference::Element(result)));
+        }
+        if effective.id == "Kernel-Expressions-InstantiationExpression-argument" {
+            if r.element_type(e) == "ConstructorExpression"
+                && r.b.graph_format == crate::model::GraphFormat::CanonicalV3
+            {
+                let report = r.constructor_binding_report_with_budget(e, self.steps);
+                self.steps = report.steps;
+                let args = report
+                    .arguments
+                    .map_err(PropertyError::IncompleteConstructorBindings)?;
+                self.steps = self
+                    .steps
+                    .saturating_add(args.bindings.len().saturating_mul(12));
+                if self.steps > crate::eval::MAX_STEPS {
+                    return Err(PropertyError::IncompleteConstructorBindings(
+                        crate::json::ConstructorBindingIssue::WorkLimit,
+                    ));
+                }
+                let refs: Vec<_> = args.bindings.into_iter().map(|b| b.value).collect();
+                validate_references(r, effective, &refs)?;
+                validate_references(r, requested, &refs)?;
+                return Ok(DerivedValue::References(
+                    refs.into_iter().map(Reference::Element).collect(),
+                ));
+            }
+            let report = r.invocation_binding_report_with_budget(e, self.steps);
+            self.steps = report.steps;
+            let args = report
+                .arguments
+                .map_err(PropertyError::IncompleteInvocationBindings)?;
+            self.steps = self
+                .steps
+                .saturating_add(args.bindings.len().saturating_mul(12));
+            if self.steps > crate::eval::MAX_STEPS {
+                return Err(PropertyError::IncompleteInvocationBindings(
+                    crate::json::InvocationBindingIssue::WorkLimit,
+                ));
+            }
+            let refs: Vec<_> = args.bindings.into_iter().map(|b| b.value).collect();
+            validate_references(r, effective, &refs)?;
+            validate_references(r, requested, &refs)?;
+            return Ok(DerivedValue::References(
+                refs.into_iter().map(Reference::Element).collect(),
+            ));
+        }
+        if matches!(
+            effective.id,
+            "Systems-DefinitionAndUsage-Definition-usage"
+                | "Systems-DefinitionAndUsage-Definition-directedUsage"
+        ) {
+            let base = if effective.name == "usage" {
+                "Core-Types-Type-feature"
+            } else {
+                "Core-Types-Type-directedFeature"
+            };
+            // These normative subsets filter the complete inherited sequence,
+            // never an owned-only inventory or a member's separate type proof.
+            let DerivedValue::References(refs) = self.read_features(r, e, base)? else {
+                unreachable!("certified Type sequences contain local handles")
+            };
+            let handles: Vec<_> = refs
+                .into_iter()
+                .filter_map(|reference| match reference {
+                    Reference::Element(member) if r.is_kind(member, "Usage") => Some(member),
+                    Reference::Element(_) => None,
+                    _ => unreachable!("certified local handles"),
+                })
+                .collect();
+            validate_references(r, effective, &handles)?;
+            validate_references(r, requested, &handles)?;
+            return Ok(DerivedValue::References(
+                handles.into_iter().map(Reference::Element).collect(),
+            ));
+        }
+        if effective.id.starts_with("Core-Types-Type-") {
+            let value = self.read_features(r, e, effective.id)?;
+            if let DerivedValue::References(refs) = &value {
+                let handles: Vec<_> = refs
+                    .iter()
+                    .map(|reference| match reference {
+                        Reference::Element(e) => *e,
+                        _ => unreachable!("certified local handles"),
+                    })
+                    .collect();
+                validate_references(r, effective, &handles)?;
+                validate_references(r, requested, &handles)?;
+            }
+            return Ok(value);
+        }
+        self.charge(1)?;
+        if r.b.positional_planning {
+            return Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::UnsupportedProjection,
+            ));
+        }
+        if !self
+            .cached
+            .as_ref()
+            .is_some_and(|v| v.receiver == e && v.stamp.current(r))
+        {
+            self.cached = None;
+            let report = r.feature_type_report_with_budget(e, self.steps);
+            self.steps = report.steps;
+            self.charge(0)?;
+            let stamp = Stamp::capture(r);
+            self.cached = Some(Cached {
+                receiver: e,
+                stamp,
+                report,
+            });
+        }
+        let report = &self
+            .cached
+            .as_ref()
+            .expect("established current report")
+            .report;
+        let refs: Result<&[ElementRef], FeatureTypeIssue> = match effective.id {
+            "Core-Features-Feature-type"
+            | "Systems-DefinitionAndUsage-Usage-definition"
+            | "Systems-Attributes-AttributeUsage-attributeDefinition"
+            | "Systems-Occurrences-OccurrenceUsage-occurrenceDefinition"
+            | "Systems-Items-ItemUsage-itemDefinition"
+            | "Systems-Parts-PartUsage-partDefinition" => {
+                report.types.as_ref().map(Vec::as_slice).map_err(|e| *e)
+            }
+            "Kernel-Behaviors-Step-behavior" => {
+                report.behavior.as_ref().map(Vec::as_slice).map_err(|e| *e)
+            }
+            "Kernel-Functions-Expression-function" => report
+                .function
+                .as_ref()
+                .map(|v| v.as_slice())
+                .map_err(|e| *e),
+            _ => unreachable!("audited capability identity"),
+        };
+        let refs = refs.map_err(PropertyError::IncompleteTypeProjection)?;
+        if (effective.upper == Some(1) || requested.upper == Some(1)) && refs.len() > 1 {
+            return Err(PropertyError::InvalidValue(
+                "multiple values for a single-valued redefinition".into(),
+            ));
+        }
+
+        // Report output, effective/requested validation and JSON reference
+        // conversion all have bounded passes over fixed-length UUID identities.
+        // Charge before cloning or serializing even when the report is cached.
+        let amount = refs.len().saturating_mul(12).saturating_add(1);
+        let used = self.steps.saturating_add(amount);
+        if used > crate::eval::MAX_STEPS {
+            self.steps = used;
+            return Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::WorkLimit,
+            ));
+        }
+        self.steps = used;
+        // Item and Part definitions subset the complete type collection;
+        // the other Usage declarations redefine it and must validate every type.
+        let subset_kind = match effective.id {
+            "Systems-Items-ItemUsage-itemDefinition" => Some("Structure"),
+            "Systems-Parts-PartUsage-partDefinition" => Some("PartDefinition"),
+            _ => None,
+        };
+        let refs: Vec<_> = refs
+            .iter()
+            .copied()
+            .filter(|e| {
+                subset_kind.is_none_or(|kind| crate::metaclass::conforms(r.element_type(*e), kind))
+            })
+            .collect();
+        validate_references(r, effective, &refs)?;
+        validate_references(r, requested, &refs)?;
+        if requested.upper == Some(1) {
+            Ok(refs
+                .first()
+                .map(|&e| DerivedValue::Reference(Reference::Element(e)))
+                .unwrap_or(DerivedValue::Null))
+        } else {
+            Ok(DerivedValue::References(
+                refs.into_iter().map(Reference::Element).collect(),
+            ))
+        }
+    }
+}
+
+/// Certified local handles avoid the independent ResolvedModel by_id map.
+/// This enforces the same reference cardinality, uniqueness and target-kind
+/// constraints as JSON property validation without a cold whole-model rebuild.
+fn validate_references(
+    r: &ResolvedModel,
+    spec: &semantic_catalog::PropertySpec,
+    refs: &[ElementRef],
+) -> Result<(), PropertyError> {
+    if refs.len() < spec.lower {
+        return Err(PropertyError::MissingRequiredValue);
+    }
+    if spec.upper.is_some_and(|upper| refs.len() > upper) {
+        return Err(PropertyError::InvalidValue(
+            "multiple values for a single-valued redefinition".into(),
+        ));
+    }
+    let mut seen = std::collections::HashSet::new();
+    for target in refs {
+        let element =
+            r.b.elements
+                .get(target.0)
+                .ok_or_else(|| PropertyError::InvalidValue("missing certified reference".into()))?;
+        if spec.unique && !seen.insert(element.id) {
+            return Err(PropertyError::InvalidValue(
+                "duplicate value in a unique property".into(),
+            ));
+        }
+        if !crate::metaclass::conforms(element.ty, spec.target) {
+            return Err(PropertyError::InvalidValue(format!(
+                "expected {}",
+                spec.target
+            )));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{Derived, Derives, derives},
+        model::Model,
+    };
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        assert!(
+            m.add_library_source("certified-lib.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            m.add_source("certified-user.kerml", source)
+                .diagnostics
+                .is_empty()
+        );
+        ResolvedModel::build(&m)
+    }
+    fn full(r: &mut ResolvedModel) {
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+    }
+    #[test]
+    fn result_and_argument_output_budget_errors_keep_their_report_family() {
+        let mut r = fixture("function F {in a; return r;} feature call=F(a=1);");
+        full(&mut r);
+        let f = r.resolve_qualified("F").unwrap();
+        let call = ElementRef(
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "InvocationExpression")
+                .unwrap(),
+        );
+        assert!(r.function_result_report(f).result.is_ok());
+        let used = r.function_result_report(f).steps;
+        assert!(
+            r.function_result_report_with_budget(f, crate::eval::MAX_STEPS - used - 6)
+                .result
+                .is_ok()
+        );
+        let mut row = CheckedRow {
+            steps: crate::eval::MAX_STEPS - used - 6,
+            ..Default::default()
+        };
+        assert_eq!(
+            row.read(&mut r, f, "result"),
+            Some(Err(PropertyError::IncompleteFunctionResult(
+                crate::json::TypeInputIssue::WorkLimit
+            )))
+        );
+        assert!(r.invocation_binding_report(call).arguments.is_ok());
+        let used = r.invocation_binding_report(call).steps;
+        assert!(
+            r.invocation_binding_report_with_budget(call, crate::eval::MAX_STEPS - used - 6)
+                .arguments
+                .is_ok()
+        );
+        let mut row = CheckedRow {
+            steps: crate::eval::MAX_STEPS - used - 6,
+            ..Default::default()
+        };
+        assert_eq!(
+            row.read(&mut r, call, "argument"),
+            Some(Err(PropertyError::IncompleteInvocationBindings(
+                crate::json::InvocationBindingIssue::WorkLimit
+            )))
+        );
+        assert!(r.property(f, "result").is_ok());
+        assert!(r.property(call, "argument").is_ok());
+    }
+    #[test]
+    fn input_checked_row_budget_is_cumulative_and_retryable() {
+        let mut r = fixture("function F { in a; }");
+        full(&mut r);
+        let f = r.resolve_qualified("F").unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read(&mut r, f, "input").unwrap().is_ok());
+        let used = row.steps;
+        assert!(row.read(&mut r, f, "input").unwrap().is_ok());
+        assert!(row.steps > used);
+        row.steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            row.read(&mut r, f, "input"),
+            Some(Err(PropertyError::IncompleteTypeInput(
+                crate::json::TypeInputIssue::WorkLimit
+            )))
+        );
+        assert!(r.property(f, "input").is_ok());
+    }
+    #[test]
+    fn usage_aliases_share_checked_row_work_without_legacy_type_errors() {
+        let mut model = Model::new();
+        model.add_source("usage.sysml", "ref x;");
+        let mut r = ResolvedModel::build(&model);
+        full(&mut r);
+        let x = r.resolve_qualified("x").unwrap();
+        let mut row = CheckedRow::default();
+        assert_eq!(
+            row.read(&mut r, x, "mayTimeVary"),
+            Some(Ok(DerivedValue::Bool(false)))
+        );
+        let used = row.steps;
+        assert_eq!(
+            row.read(&mut r, x, "isVariable"),
+            Some(Ok(DerivedValue::Bool(false)))
+        );
+        assert!(row.steps > used);
+        row.steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            row.read(&mut r, x, "isVariable"),
+            Some(Err(PropertyError::IncompleteUsageVariability(
+                crate::json::UsageVariabilityIssue::WorkLimit
+            )))
+        );
+        assert_eq!(r.property(x, "mayTimeVary"), Ok(serde_json::json!(false)));
+    }
+
+    #[test]
+    fn warm_checked_row_refuses_an_in_progress_positional_sentinel() {
+        let mut r = fixture(
+            "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+        );
+        full(&mut r);
+        let e = r.resolve_qualified("e").unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read(&mut r, e, "function").unwrap().is_ok());
+        let plan = r.b.positional_redefinitions.replace(Default::default());
+        r.b.positional_planning = true;
+        assert!(!row.cached.as_ref().unwrap().stamp.current(&r));
+        assert_eq!(
+            row.read(&mut r, e, "function").unwrap(),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::UnsupportedProjection
+            ))
+        );
+        r.b.positional_planning = false;
+        r.b.positional_redefinitions = plan;
+        assert!(row.read(&mut r, e, "function").unwrap().is_ok());
+    }
+
+    #[test]
+    fn checked_reads_certify_full_policy_and_preserve_compatibility_with_qualified_fidelity() {
+        let mut r = fixture(
+            "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+        );
+        let e = r.resolve_qualified("e").unwrap();
+        let f = r.resolve_qualified("F").unwrap();
+        let baseline = r.derived(e, "type");
+        let rows = r.elements().count();
+        let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        assert_eq!(derives("Expression", "type"), Derives::Passthrough);
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            assert_eq!(r.property(e, "type"), Err(PropertyError::Approximate));
+            assert_eq!(
+                r.derived_exact(e, "function"),
+                Err(PropertyError::Approximate)
+            );
+            assert_eq!(r.closure_policy(), policy);
+        }
+        full(&mut r);
+        let reference = serde_json::json!({"@id":r.element_id(f).to_string()});
+        assert_eq!(
+            r.property(e, "type"),
+            Ok(serde_json::json!([reference.clone()]))
+        );
+        assert_eq!(r.property(e, "function"), Ok(reference.clone()));
+        assert_eq!(
+            r.property(e, "behavior"),
+            Ok(serde_json::json!([reference]))
+        );
+        assert_eq!(
+            r.derived_exact(e, "function"),
+            Ok(DerivedValue::Reference(Reference::Element(f)))
+        );
+        assert_eq!(
+            r.derived_exact(e, "behavior"),
+            Ok(DerivedValue::References(vec![Reference::Element(f)]))
+        );
+        assert_eq!(r.derived(e, "type"), baseline);
+        assert_eq!(r.elements().count(), rows);
+        assert_eq!(
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>(),
+            ids
+        );
+        assert!(
+            conditional_property_capability("Kernel-Functions-Expression-function")
+                .unwrap()
+                .requires_full_closure
+        );
+        assert!(conditional_property_capability("function").is_none());
+        assert!(matches!(r.derived(e, "function"), Derived::Value(_)));
+    }
+    #[test]
+    fn effective_function_multiplicity_governs_behavior_alias_but_not_complete_feature_type() {
+        let mut r = fixture(
+            "function F specializes Performances::Evaluation; function G specializes Performances::Evaluation; expr e:F,G subsets Performances::evaluations;",
+        );
+        full(&mut r);
+        let e = r.resolve_qualified("e").unwrap();
+        assert!(r.property(e, "type").is_ok());
+        assert_eq!(
+            r.property(e, "function"),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::InvalidFunctionMultiplicity
+            ))
+        );
+        assert_eq!(
+            r.derived_exact(e, "function"),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::InvalidFunctionMultiplicity
+            ))
+        );
+        for name in ["function", "behavior"] {
+            assert_eq!(
+                r.property(e, name),
+                Err(PropertyError::IncompleteTypeProjection(
+                    FeatureTypeIssue::InvalidFunctionMultiplicity
+                ))
+            );
+            assert_eq!(
+                r.derived_exact(e, name),
+                Err(PropertyError::IncompleteTypeProjection(
+                    FeatureTypeIssue::InvalidFunctionMultiplicity
+                ))
+            );
+        }
+    }
+    #[test]
+    fn checked_export_reports_missing_evidence_without_changing_compatibility() {
+        // Generic Expression/Step ancestry supplies both Feature roles even
+        // when the source and the canonical evaluations omit their subsetting.
+        let mut intact = Model::new();
+        let library = LIB.replace(
+            "expr evaluations:Evaluation subsets performances;",
+            "expr evaluations:Evaluation;",
+        );
+        assert_ne!(library, LIB);
+        assert!(
+            intact
+                .add_library_source("intact.kerml", &library)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            intact
+                .add_source(
+                    "complete.kerml",
+                    "function F specializes Performances::Evaluation; expr complete:F;"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut positive = ResolvedModel::build(&intact);
+        full(&mut positive);
+        let evaluations = positive
+            .resolve_qualified("Performances::evaluations")
+            .unwrap()
+            .0;
+        let performances = positive
+            .resolve_qualified("Performances::performances")
+            .unwrap()
+            .0;
+        assert_eq!(
+            crate::json::type_relations::TypeRelations::default().specializes(
+                &mut positive.b,
+                evaluations,
+                performances,
+                &mut 0
+            ),
+            crate::json::type_relations::RelationFact::Yes
+        );
+        let complete = positive.resolve_qualified("complete").unwrap();
+        let complete_id = positive.element_id(complete);
+        let positive_issues = positive.to_full_json_strict().unwrap_err().issues;
+        assert!(!positive_issues.iter().any(|i| i.element_id == complete_id
+            && matches!(i.property.as_str(), "type" | "function" | "behavior")));
+
+        // Remove the canonical Step Feature entirely, including its authored
+        // reference from evaluations. Only the required implied family is
+        // missing; no invalid authored endpoint obscures that qualification.
+        let library = LIB
+            .replace(
+                "step performances:Performance subsets Occurrences::occurrences;",
+                "",
+            )
+            .replace(
+                "expr evaluations:Evaluation subsets performances;",
+                "expr evaluations:Evaluation;",
+            );
+        assert_ne!(library, LIB);
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_library_source("broken-evaluation-base.kerml", &library)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(model.add_source("missing-export.kerml",
+            "function F specializes Performances::Evaluation; expr missing:F; feature call=F();"
+        ).diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&model);
+        full(&mut r);
+        assert!(r.resolve_qualified("Performances::evaluations").is_some());
+        assert!(r.resolve_qualified("Performances::performances").is_none());
+        assert!(r.resolve_qualified("Performances::Performance").is_some());
+        let missing = r.resolve_qualified("missing").unwrap();
+        let before_type = r.property(missing, "type");
+        let before_function = r.property(missing, "function");
+        let before_export = r.to_full_json_strict();
+        let compatibility_type = r.derived(missing, "type");
+        assert_eq!(
+            r.property(missing, "type"),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::MissingRequiredFamilies
+            ))
+        );
+        let call = r.resolve_qualified("call").unwrap();
+        let invocation = r.members_via(call, "FeatureValue")[0];
+        assert!(matches!(
+            r.property(invocation, "function"),
+            Err(PropertyError::IncompleteTypeProjection(_))
+        ));
+        let missing_id = r.element_id(missing);
+        let issues = r.to_full_json_strict().unwrap_err().issues;
+        assert!(issues.iter().any(|i| i.element_id == missing_id
+            && i.property == "type"
+            && matches!(i.reason, PropertyError::IncompleteTypeProjection(_))));
+        assert!(
+            !issues.is_empty(),
+            "other unsupported properties still refuse whole export"
+        );
+        assert_eq!(r.property(missing, "type"), before_type);
+        assert_eq!(r.property(missing, "function"), before_function);
+        assert_eq!(r.to_full_json_strict(), before_export);
+        assert_eq!(r.derived(missing, "type"), compatibility_type);
+    }
+    #[test]
+    fn ordered_type_row_shares_one_current_certificate_across_components() {
+        let mut r = fixture("function F {in a; out b; return answer;}");
+        full(&mut r);
+        let f = r.resolve_qualified("F").unwrap();
+        let a = r.resolve_qualified("F::a").unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read(&mut r, f, "feature").unwrap().is_ok());
+        let first = row.steps;
+        for name in [
+            "featureMembership",
+            "input",
+            "output",
+            "endFeature",
+            "inheritedMembership",
+            "inheritedFeature",
+            "result",
+        ] {
+            assert!(row.read(&mut r, f, name).unwrap().is_ok(), "{name}");
+        }
+        assert!(
+            row.read(&mut r, f, "directedFeature").is_none(),
+            "Behavior parameter override remains qualified"
+        );
+        assert!(
+            row.read_namespace(&mut r, f, "Root-Namespaces-Namespace-membership")
+                .is_ok()
+        );
+        assert!(
+            row.steps - first < 500,
+            "one row must reuse its complete certificate"
+        );
+        r.b.set(a.0, "direction", serde_json::json!("out"));
+        assert_eq!(
+            row.read(&mut r, f, "input").unwrap(),
+            Ok(DerivedValue::References(vec![]))
+        );
+        r.b.set(a.0, "direction", serde_json::json!(false));
+        assert!(matches!(
+            row.read(&mut r, f, "feature").unwrap(),
+            Err(PropertyError::IncompleteTypeFeatures(_))
+        ));
+        r.b.set(a.0, "direction", serde_json::json!("in"));
+        assert!(row.read(&mut r, f, "feature").unwrap().is_ok());
+        row.steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            row.read(&mut r, f, "input").unwrap(),
+            Err(PropertyError::IncompleteTypeInput(
+                crate::json::TypeInputIssue::WorkLimit
+            ))
+        );
+        assert!(
+            CheckedRow::default()
+                .read(&mut r, f, "feature")
+                .unwrap()
+                .is_ok()
+        );
+    }
+    #[test]
+    fn row_cache_reuses_one_proof_and_refuses_same_length_or_metadata_changes() {
+        let mut r = fixture(
+            "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+        );
+        full(&mut r);
+        let e = r.resolve_qualified("e").unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read(&mut r, e, "type").unwrap().is_ok());
+        let first_steps = row.steps;
+        assert!(row.read(&mut r, e, "function").unwrap().is_ok());
+        assert!(row.steps - first_steps < 100, "same row reuses report");
+        let relation = r.b.elements[e.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| r.b.elements[i].ty == "FeatureTyping")
+            .unwrap();
+        let original = r.b.elements[relation].props.clone();
+        r.b.elements[relation].props.insert(
+            "target",
+            serde_json::json!([{"@id":uuid::Uuid::new_v4().to_string()}]),
+        );
+        assert!(matches!(
+            row.read(&mut r, e, "type").unwrap(),
+            Err(PropertyError::IncompleteTypeProjection(_))
+        ));
+        r.b.elements[relation].props = original;
+        assert!(row.read(&mut r, e, "type").unwrap().is_ok());
+        r.b.metadata_associations_incomplete = true;
+        r.b.metadata_association_generation = Some(Arc::new(()));
+        assert!(matches!(
+            row.read(&mut r, e, "type").unwrap(),
+            Err(PropertyError::IncompleteTypeProjection(_))
+        ));
+        r.b.metadata_associations_incomplete = false;
+        r.b.metadata_association_generation = Some(Arc::new(()));
+        assert!(row.read(&mut r, e, "type").unwrap().is_ok());
+        row.steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            row.read(&mut r, e, "function").unwrap(),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::WorkLimit
+            ))
+        );
+        assert!(
+            CheckedRow::default()
+                .read(&mut r, e, "function")
+                .unwrap()
+                .is_ok()
+        );
+    }
+    #[test]
+    fn cold_large_read_obeys_remaining_budget_without_initializing_legacy_uuid_map() {
+        let mut source = String::from(
+            "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+        );
+        for i in 0..10_000 {
+            source.push_str(&format!(" feature unrelated{i};"));
+        }
+        let mut r = fixture(&source);
+        full(&mut r);
+        let e = r.resolve_qualified("e").unwrap();
+        r.by_id.clear();
+        r.by_id_built_for = usize::MAX;
+        let mut row = CheckedRow {
+            steps: crate::eval::MAX_STEPS - 10,
+            ..CheckedRow::default()
+        };
+        assert_eq!(
+            row.read(&mut r, e, "function").unwrap(),
+            Err(PropertyError::IncompleteTypeProjection(
+                FeatureTypeIssue::WorkLimit
+            ))
+        );
+        assert!(r.by_id.is_empty());
+        assert_eq!(r.by_id_built_for, usize::MAX);
+        assert!(r.property(e, "function").is_ok());
+        assert!(r.by_id.is_empty());
+        assert_eq!(r.by_id_built_for, usize::MAX);
+    }
+    #[test]
+    fn same_length_uuid_remap_uses_certified_handles_even_with_stale_legacy_index() {
+        let mut r = fixture(
+            "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations; package Spare;",
+        );
+        full(&mut r);
+        let e = r.resolve_qualified("e").unwrap();
+        let f = r.resolve_qualified("F").unwrap();
+        let spare = r.resolve_qualified("Spare").unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read(&mut r, e, "function").unwrap().is_ok());
+        r.ensure_by_id();
+        let old_index = r.by_id.clone();
+        let size = r.b.elements.len();
+        let target_id = r.element_id(spare);
+        r.override_ids(&std::collections::HashMap::from([
+            (r.element_id(f), target_id),
+            (target_id, uuid::Uuid::new_v4()),
+        ]));
+        assert_eq!(r.b.elements.len(), size);
+        r.by_id = old_index;
+        r.by_id_built_for = size;
+        assert_eq!(r.by_id.get(&target_id), Some(&spare.0));
+        assert_eq!(
+            row.read(&mut r, e, "function").unwrap(),
+            Ok(DerivedValue::Reference(Reference::Element(f)))
+        );
+        assert_eq!(
+            r.property(e, "function"),
+            Ok(serde_json::json!({"@id":target_id.to_string()}))
+        );
+        assert_eq!(
+            r.by_id.get(&target_id),
+            Some(&spare.0),
+            "new path must not query or rebuild this separate stale map"
+        );
+    }
+}
+
+#[cfg(test)]
+mod owned_source_tests {
+    use super::*;
+    use crate::model::Model;
+    use serde_json::{Value, json};
+
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("source.kerml", source)
+                .diagnostics
+                .is_empty()
+        );
+        ResolvedModel::build(&model)
+    }
+    fn relation(r: &ResolvedModel) -> ElementRef {
+        r.user_elements()
+            .find(|&e| r.element_type(e) == "TypeFeaturing")
+            .unwrap()
+    }
+    fn aliases(r: &mut ResolvedModel, e: ElementRef, source: Value) {
+        assert_eq!(r.property(e, "featureOfType"), Ok(source.clone()));
+        assert_eq!(r.property(e, "source"), Ok(json!([source])));
+    }
+    #[test]
+    fn structural_relationship_reads_refuse_duplicate_owners_and_exhausted_work() {
+        let mut r = fixture("class A; feature x : A;");
+        let x = r.resolve_qualified("x").unwrap();
+        let baseline = r.property(x, "ownedRelationship").unwrap();
+        assert!(!baseline.as_array().unwrap().is_empty());
+        let relationship = r.b.elements[x.0].owned_relationships[0];
+        r.b.elements[x.0].owned_relationships.push(relationship);
+        assert!(r.property(x, "ownedRelationship").is_err());
+
+        let mut r = fixture("class A; feature x : A;");
+        let x = r.resolve_qualified("x").unwrap();
+        let mut row = CheckedRow {
+            steps: crate::eval::MAX_STEPS,
+            ..Default::default()
+        };
+        assert!(row.owned_relationships(&mut r, x).is_err());
+    }
+    #[test]
+    fn sparse_and_standalone_source_aliases_are_exact_under_every_policy() {
+        for source in [
+            "class A; feature x featured by A;",
+            "class A; feature x; featuring x by A;",
+        ] {
+            let mut r = fixture(source);
+            let e = relation(&r);
+            let x = r.resolve_qualified("x").unwrap();
+            let expected = json!({"@id":r.element_id(x).to_string()});
+            let old = r.element_properties(e);
+            let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            for policy in [
+                ClosurePolicy::Passthrough,
+                ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+                ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                aliases(&mut r, e, expected.clone());
+                assert_eq!(r.element_properties(e), old);
+                let id = r.element_id(e);
+                if let Err(report) = r.to_full_json_strict() {
+                    assert!(!report.issues.iter().any(|issue| issue.element_id == id
+                        && matches!(issue.property.as_str(), "source" | "featureOfType")));
+                }
+            }
+            assert_eq!(
+                ids,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+    #[test]
+    fn present_bad_aliases_and_invalid_carriers_never_fall_back() {
+        for (key, value) in [
+            ("featureOfType", Value::Null),
+            ("featureOfType", json!(false)),
+            ("source", json!([])),
+            ("source", json!([{"@ref":"x"}])),
+            (
+                "source",
+                json!({"@id":"00000000-0000-0000-0000-000000000001"}),
+            ),
+            ("relatedElement", json!([])),
+            ("owningRelatedElement", Value::Null),
+            ("owningFeatureOfType", Value::Null),
+        ] {
+            let mut r = fixture("class A; feature x featured by A;");
+            let e = relation(&r);
+            assert!(r.property(e, "source").is_ok());
+            r.b.set(e.0, key, value);
+            for name in ["source", "featureOfType"] {
+                assert!(r.property(e, name).is_err(), "{key}/{name}");
+            }
+        }
+        for kind in 0..5 {
+            let mut r = fixture("class A; class B; feature x featured by A; feature y;");
+            let e = relation(&r);
+            let x = r.resolve_qualified("x").unwrap();
+            let y = r.resolve_qualified("y").unwrap();
+            let a = r.resolve_qualified("A").unwrap();
+            match kind {
+                0 => {
+                    let id = r.element_id(y);
+                    r.b.set(e.0, "featureOfType", json!({"@id":id.to_string()}));
+                    r.b.set(e.0, "source", json!([{"@id":r.element_id(x).to_string()}]));
+                }
+                1 => {
+                    let id = r.element_id(a);
+                    r.b.set(e.0, "featureOfType", json!({"@id":id.to_string()}));
+                }
+                2 => {
+                    r.b.elements[y.0].owned_relationships = vec![e.0].into();
+                }
+                3 => {
+                    r.b.elements[y.0].id = r.element_id(x);
+                }
+                _ => {
+                    r.b.elements[x.0].ty = "Package";
+                }
+            }
+            assert!(r.property(e, "featureOfType").is_err(), "case {kind}");
+        }
+    }
+    #[test]
+    fn generic_aliases_external_ids_and_same_length_mutation_are_revalidated() {
+        let mut r = fixture("class A; class B; feature x; feature y; featuring x by A;");
+        let e = relation(&r);
+        let x = r.resolve_qualified("x").unwrap();
+        let y = r.resolve_qualified("y").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        let xid = json!({"@id":r.element_id(x).to_string()});
+        let yid = json!({"@id":r.element_id(y).to_string()});
+        aliases(&mut r, e, xid.clone());
+        // Shape-preserving source edit must not reuse the previous answer.
+        r.b.set(e.0, "featureOfType", yid.clone());
+        aliases(&mut r, e, yid.clone());
+        r.b.set(e.0, "source", json!([yid]));
+        r.b.set(e.0, "target", json!([{"@id":r.element_id(a).to_string()}]));
+        assert!(r.property(e, "source").is_ok());
+        r.b.set(e.0, "target", json!([{"@id":r.element_id(b).to_string()}]));
+        // Opposite target evidence does not define the source's identity.
+        assert!(r.property(e, "source").is_ok());
+        let mut props = r.b.elements[e.0].props.to_json();
+        props.remove("featureOfType");
+        props.remove("featuringType");
+        let mut replacement = crate::properties::Properties::new();
+        for (key, value) in props {
+            replacement.insert(&key, value);
+        }
+        r.b.elements[e.0].props = replacement;
+        // Both endpoints stored only under generic singleton-array aliases.
+        let expected = json!({"@id":r.element_id(y).to_string()});
+        aliases(&mut r, e, expected);
+        let external = json!({"@id":"fe1c5e00-959e-4b3b-9512-b0ae7ed3799d"});
+        r.b.set(e.0, "source", json!([external.clone()]));
+        aliases(&mut r, e, external);
+    }
+    #[test]
+    fn unrelated_target_absence_or_resolution_does_not_hide_known_source() {
+        for value in [
+            None,
+            Some(json!({"@ref":"Missing"})),
+            Some(Value::Null),
+            Some(json!(false)),
+        ] {
+            let mut r = fixture("class A; feature x featured by A;");
+            let e = relation(&r);
+            let x = r.resolve_qualified("x").unwrap();
+            let expected = json!({"@id":r.element_id(x).to_string()});
+            let mut props = r.b.elements[e.0].props.to_json();
+            props.remove("featuringType");
+            let mut replacement = crate::properties::Properties::new();
+            for (key, value) in props {
+                replacement.insert(&key, value);
+            }
+            r.b.elements[e.0].props = replacement;
+            if let Some(value) = value {
+                r.b.set(e.0, "featuringType", value);
+            }
+            aliases(&mut r, e, expected);
+        }
+    }
+    #[test]
+    fn related_element_target_tail_does_not_define_source_identity() {
+        for tail in [
+            vec![],
+            vec![json!({"@ref":"Missing"})],
+            vec![Value::Null, json!(false)],
+        ] {
+            let mut r = fixture("class A; feature x featured by A;");
+            let e = relation(&r);
+            let x = r.resolve_qualified("x").unwrap();
+            let source = json!({"@id":r.element_id(x).to_string()});
+            let mut related = vec![source.clone()];
+            related.extend(tail);
+            r.b.set(e.0, "relatedElement", json!(related));
+            aliases(&mut r, e, source);
+        }
+    }
+    #[test]
+    fn row_budget_accumulates_alias_reads_and_exhaustion_is_retryable() {
+        let mut r = fixture("class A; feature x featured by A;");
+        let e = relation(&r);
+        let (_, spec) = semantic_catalog::property("TypeFeaturing", "featureOfType").unwrap();
+        let spec = spec.unwrap();
+        let mut row = CheckedRow::default();
+        assert!(row.read_owned_source(&mut r, e, spec).unwrap().is_ok());
+        let first = row.steps;
+        assert!(row.read_owned_source(&mut r, e, spec).unwrap().is_ok());
+        assert!(row.steps > first);
+        row.steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            row.read_owned_source(&mut r, e, spec),
+            Some(Err(PropertyError::NotComputed))
+        );
+        assert!(r.property(e, "source").is_ok());
+        r.b.positional_planning = true;
+        assert!(r.property(e, "source").is_err());
+        r.b.positional_planning = false;
+        assert!(r.property(e, "source").is_ok());
+    }
+    #[test]
+    fn source_projection_replays_across_all_library_representations() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut library = Model::new();
+        library.add_library_source("lib.kerml", "standard library package L {class A;}");
+        library.record_library_cache();
+        ResolvedModel::build(&library);
+        let cache =
+            LibraryCache::from_bytes(&library.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = library.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(61).unwrap(), 61).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lib.kerml", "standard library package L {class A;}");
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("source.kerml", "feature x featured by L::A;");
+            let mut r = ResolvedModel::build(&model);
+            let e = relation(&r);
+            let x = r.resolve_qualified("x").unwrap();
+            let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            if let Some(expected) = &expected {
+                assert_eq!(&ids, expected);
+            } else {
+                expected = Some(ids);
+            }
+            let expected = json!({"@id":r.element_id(x).to_string()});
+            aliases(&mut r, e, expected);
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "definition_usage_tests.rs"]
+mod definition_usage_tests;
diff --git a/crates/sysmlv2-model/src/json/semantic/definition_usage_tests.rs b/crates/sysmlv2-model/src/json/semantic/definition_usage_tests.rs
new file mode 100644
index 0000000..aec349f
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic/definition_usage_tests.rs
@@ -0,0 +1,163 @@
+use super::{CheckedRow, PropertyError};
+use crate::{
+    json::{ClosurePolicy, ResolvedModel, TypeInputIssue},
+    model::{GraphFormat, Model},
+};
+use serde_json::json;
+use std::sync::Arc;
+
+fn library(format: GraphFormat) -> Model {
+    let mut model = Model::with_graph_format(format);
+    for (name, text) in [
+        (
+            "kernel.kerml",
+            "standard library package Base { classifier Anything { feature raw; } feature things : Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences : Occurrence subsets Base::things; } standard library package Objects { struct Object specializes Occurrences::Occurrence; feature objects : Object subsets Occurrences::occurrences; }",
+        ),
+        (
+            "items.sysml",
+            "standard library package Items { item def Item :> Objects::Object; ref item items : Item :> Objects::objects; }",
+        ),
+        (
+            "parts.sysml",
+            "standard library package Parts { part def Part :> Items::Item; ref part parts : Part :> Items::items; }",
+        ),
+    ] {
+        let parsed = model.add_library_source(name, text);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    }
+    model
+}
+fn source(model: &mut Model) -> ResolvedModel {
+    let parsed = model.add_source("user.sysml", "part def A { ref a; in ref input; out ref output; } part def B :> A { ref b; ref a2 :>> a; } part def Broken :> Missing { ref x; } port def Unsupported; part outer { ref child; }");
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let mut r = ResolvedModel::build(model);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    r
+}
+#[test]
+fn definition_usage_filters_complete_sequences_in_order_across_replay() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut lib = library(format);
+        let prepared = lib.prepare_library().unwrap();
+        let decoded = Arc::new(
+            crate::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(147).unwrap(), 147)
+                .unwrap(),
+        );
+        let mut expected = None;
+        for mode in 0..3 {
+            let mut model = if mode == 0 {
+                library(format)
+            } else {
+                let mut model = Model::with_graph_format(format);
+                Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                    .install(&mut model)
+                    .unwrap();
+                model
+            };
+            let mut r = source(&mut model);
+            let b = r.resolve_qualified("B").unwrap();
+            let mut names = Vec::new();
+            for name in ["A::input", "A::output", "B::b", "B::a2"] {
+                let e = r.resolve_qualified(name).unwrap();
+                names.push(json!({"@id": r.element_id(e).to_string()}));
+            }
+            let usages = r.property(b, "usage").unwrap();
+            assert_eq!(usages.as_array().unwrap().len(), names.len());
+            for name in &names {
+                assert!(usages.as_array().unwrap().contains(name));
+            }
+            let directed = r.property(b, "directedUsage").unwrap();
+            assert_eq!(directed, json!([names[0], names[1]]));
+            // The inherited Kernel Feature is not a Usage; the overwritten a is absent.
+            let raw = r.resolve_qualified("Base::Anything::raw").unwrap();
+            let features = r.property(b, "feature").unwrap();
+            assert!(
+                features
+                    .as_array()
+                    .unwrap()
+                    .contains(&json!({"@id":r.element_id(raw).to_string()}))
+            );
+            let filtered: Vec<_> = features
+                .as_array()
+                .unwrap()
+                .iter()
+                .filter(|v| usages.as_array().unwrap().contains(v))
+                .cloned()
+                .collect();
+            assert_eq!(usages, json!(filtered));
+            let result = (usages, directed);
+            assert_eq!(&result, expected.get_or_insert(result.clone()));
+            let mut row = CheckedRow::default();
+            assert!(row.read(&mut r, b, "usage").unwrap().is_ok());
+            assert!(row.read(&mut r, b, "directedUsage").unwrap().is_ok());
+            row.steps = crate::eval::MAX_STEPS;
+            assert_eq!(
+                row.read(&mut r, b, "usage"),
+                Some(Err(PropertyError::IncompleteTypeFeatures(
+                    TypeInputIssue::WorkLimit
+                )))
+            );
+            assert!(r.property(b, "usage").is_ok());
+            for path in ["Broken", "Unsupported", "outer"] {
+                let e = r.resolve_qualified(path).unwrap();
+                assert!(r.property(e, "usage").is_err(), "{path}");
+                assert!(r.property(e, "directedUsage").is_err(), "{path}");
+            }
+            for policy in [
+                ClosurePolicy::Passthrough,
+                ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                for property in ["usage", "directedUsage"] {
+                    assert_eq!(r.property(b, property), Err(PropertyError::Approximate));
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn definition_usage_projections_revalidate_cached_rows_and_leave_fidelity_qualified() {
+    use crate::json::{Derives, conditional_property_capability, derives};
+    let mut r = source(&mut library(GraphFormat::CanonicalV3));
+    let b = r.resolve_qualified("B").unwrap();
+    let member = r.resolve_qualified("B::b").unwrap();
+    for (name, declaration) in [
+        ("usage", "Systems-DefinitionAndUsage-Definition-usage"),
+        (
+            "directedUsage",
+            "Systems-DefinitionAndUsage-Definition-directedUsage",
+        ),
+    ] {
+        assert_eq!(derives("PartDefinition", name), Derives::Passthrough);
+        assert!(
+            conditional_property_capability(declaration)
+                .unwrap()
+                .requires_full_closure
+        );
+    }
+    let mut row = CheckedRow::default();
+    let before = row.read(&mut r, b, "directedUsage").unwrap().unwrap();
+    r.b.elements[member.0]
+        .props
+        .insert("direction", json!("in"));
+    let after = row.read(&mut r, b, "directedUsage").unwrap().unwrap();
+    assert_ne!(before, after);
+    assert_eq!(after, r.derived_exact(b, "directedUsage").unwrap());
+    // The ownership inverse must still hold after warming the certificate.
+    r.b.elements[member.0].owning_relationship = None;
+    assert!(row.read(&mut r, b, "usage").unwrap().is_err());
+    assert!(r.property(b, "usage").is_err());
+    let mut empty = Model::new();
+    empty.add_source("missing.sysml", "part def P { ref child; }");
+    let mut r = ResolvedModel::build(&empty);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let p = r.resolve_qualified("P").unwrap();
+    assert!(r.property(p, "usage").is_err());
+}
diff --git a/crates/sysmlv2-model/src/json/semantic/export.rs b/crates/sysmlv2-model/src/json/semantic/export.rs
new file mode 100644
index 0000000..2d401f1
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic/export.rs
@@ -0,0 +1,505 @@
+//! One checked export frame over the shared published graph. This module does
+//! not construct semantic relationships or certify missing property families.
+use super::certified_types::Stamp;
+use super::{
+    CheckedRow, ElementRef, PropertyError, PropertyIssue, ResolvedModel, SemanticExportError,
+};
+use crate::json::{publication, semantic_ownership, structural_index::StoredStructure};
+use serde_json::{Value, json};
+use std::collections::{HashMap, HashSet};
+use uuid::Uuid;
+
+fn issue(id: Uuid, property: &str, message: &str) -> PropertyIssue {
+    PropertyIssue {
+        element_id: id,
+        property: property.into(),
+        reason: PropertyError::InvalidValue(message.into()),
+    }
+}
+fn charge(steps: &mut usize, amount: usize, id: Uuid) -> Result<(), PropertyIssue> {
+    *steps = steps.saturating_add(amount);
+    if *steps > crate::eval::MAX_STEPS {
+        return Err(issue(id, "@snapshot", "strict export work limit"));
+    }
+    Ok(())
+}
+
+struct Snapshot {
+    stamp: Stamp,
+    elements: Vec<ElementRef>,
+    /// All known identities, with a separate local-user/library classification.
+    /// A missing entry is an external UUID, not an omitted local row.
+    identities: HashMap<Uuid, (usize, bool)>,
+    root: Uuid,
+    steps: usize,
+}
+
+impl Snapshot {
+    #[cfg(test)]
+    fn prepare(r: &mut ResolvedModel) -> Result<Self, PropertyIssue> {
+        Self::prepare_with_budget(r, 0)
+    }
+
+    fn prepare_with_budget(r: &mut ResolvedModel, mut steps: usize) -> Result<Self, PropertyIssue> {
+        let root = r
+            .user_elements()
+            .next()
+            .map(|e| r.element_id(e))
+            .unwrap_or(Uuid::nil());
+        if r.b.ensure_semantic_graph() != publication::Status::Ready {
+            return Err(issue(
+                root,
+                "@snapshot",
+                "semantic publication is unavailable",
+            ));
+        }
+        r.sync_semantic_publication();
+        charge(&mut steps, r.b.elements.len(), root)?;
+        let raw = StoredStructure::for_query(&mut r.b, &mut steps)
+            .ok_or_else(|| issue(root, "@snapshot", "stored graph evidence is unavailable"))?;
+        let ownership =
+            r.b.semantic_ownership
+                .as_ref()
+                .filter(|view| view.matches_suffix(&r.b))
+                .ok_or_else(|| issue(root, "@snapshot", "semantic ownership is unavailable"))?;
+        let explicit = r.b.explicit_len();
+        let library = r.b.lib_boundary;
+        let mut identities = HashMap::with_capacity(r.b.elements.len());
+        let mut elements = Vec::new();
+        for (i, row) in r.b.elements.iter().enumerate() {
+            let anchor = ownership.source_anchor(i);
+            if anchor >= explicit {
+                return Err(issue(
+                    row.id,
+                    "@snapshot",
+                    "generated row has no authored source anchor",
+                ));
+            }
+            let local = anchor >= library;
+            if identities.insert(row.id, (i, local)).is_some() {
+                return Err(issue(row.id, "@id", "duplicate element identity"));
+            }
+            if local {
+                elements.push(ElementRef(i));
+            }
+        }
+        // The suffix classification comes from central publication. Its current
+        // carriers and ordinary child backlinks must still agree with that view.
+        for &e in &elements {
+            if e.0 < explicit {
+                continue;
+            }
+            let row = &r.b.elements[e.0];
+            // Connector is both a Feature and a Relationship, but its node is
+            // owned through a Membership. The publisher's role, not metaclass
+            // conformance alone, determines which ownership proof applies.
+            if ownership.generated_relationship_owner(e.0).is_some() {
+                let owner =
+                    semantic_ownership::checked_relationship_carrier(&r.b, &raw, e.0, &mut steps)
+                        .flatten()
+                        .ok_or_else(|| {
+                            issue(
+                                row.id,
+                                "owningRelatedElement",
+                                "generated relationship carrier is unproved",
+                            )
+                        })?;
+                if !identities
+                    .get(&r.b.elements[owner].id)
+                    .is_some_and(|(_, local)| *local)
+                {
+                    return Err(issue(
+                        row.id,
+                        "owningRelatedElement",
+                        "generated user relationship has a non-user carrier",
+                    ));
+                }
+            } else {
+                let owner = row
+                    .owning_relationship
+                    .and_then(|owner| r.b.elements.get(owner).map(|row| (owner, row)))
+                    .ok_or_else(|| {
+                        issue(
+                            row.id,
+                            "owningRelationship",
+                            "generated element owner is unproved",
+                        )
+                    })?;
+                charge(&mut steps, owner.1.children.len(), row.id)?;
+                if !crate::metaclass::conforms(owner.1.ty, "Relationship")
+                    || owner
+                        .1
+                        .children
+                        .iter()
+                        .filter(|&&child| child == e.0)
+                        .count()
+                        != 1
+                    || !identities.get(&owner.1.id).is_some_and(|(_, local)| *local)
+                    || row
+                        .props
+                        .get("owningRelationship")
+                        .is_some_and(|value| value.as_reference() != Some(owner.1.id))
+                {
+                    return Err(issue(
+                        row.id,
+                        "owningRelationship",
+                        "generated element ownership is inconsistent",
+                    ));
+                }
+            }
+        }
+        charge(&mut steps, 0, root)?;
+        let stamp = Stamp::capture(r);
+        Ok(Self {
+            stamp,
+            elements,
+            identities,
+            root,
+            steps,
+        })
+    }
+
+    fn finish(&mut self, r: &ResolvedModel, output: &[Value]) -> Result<(), PropertyIssue> {
+        if !self.stamp.current(r) {
+            return Err(issue(
+                self.root,
+                "@snapshot",
+                "semantic export snapshot changed during property reads",
+            ));
+        }
+        charge(&mut self.steps, output.len(), self.root)?;
+        let mut emitted = HashSet::with_capacity(output.len());
+        for row in output {
+            let id = row["@id"]
+                .as_str()
+                .and_then(|id| Uuid::parse_str(id).ok())
+                .ok_or_else(|| issue(self.root, "@id", "invalid emitted identity"))?;
+            if !emitted.insert(id) {
+                return Err(issue(id, "@id", "duplicate emitted element identity"));
+            }
+        }
+        for &e in &self.elements {
+            let id = r.element_id(e);
+            if !emitted.contains(&id) {
+                return Err(issue(
+                    id,
+                    "@snapshot",
+                    "admitted user element is absent from the export",
+                ));
+            }
+        }
+        for row in output {
+            let id = Uuid::parse_str(row["@id"].as_str().unwrap()).unwrap();
+            for (property, value) in row.as_object().unwrap() {
+                charge(&mut self.steps, 1, id)?;
+                let values = value
+                    .as_array()
+                    .map(Vec::as_slice)
+                    .unwrap_or_else(|| std::slice::from_ref(value));
+                charge(&mut self.steps, values.len(), id)?;
+                for value in values {
+                    if value.get("@ref").is_some() {
+                        return Err(issue(id, property, "unresolved spelling in strict export"));
+                    }
+                    let Some(target) = value.get("@id").and_then(Value::as_str) else {
+                        continue;
+                    };
+                    let target = Uuid::parse_str(target)
+                        .map_err(|_| issue(id, property, "invalid reference identity"))?;
+                    if self
+                        .identities
+                        .get(&target)
+                        .is_some_and(|(_, local)| *local)
+                        && !emitted.contains(&target)
+                    {
+                        return Err(issue(
+                            id,
+                            property,
+                            "local reference target is absent from the export",
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+pub(super) fn full(r: &mut ResolvedModel) -> Result<Value, SemanticExportError> {
+    let mut steps = 0;
+    for attempt in 0..2 {
+        let mut snapshot =
+            Snapshot::prepare_with_budget(r, steps).map_err(|issue| SemanticExportError {
+                issues: vec![issue],
+            })?;
+        let mut output = Vec::with_capacity(snapshot.elements.len());
+        let mut issues = Vec::new();
+        for &e in &snapshot.elements {
+            let ty = r.element_type(e);
+            let id = r.element_id(e);
+            let mut row = serde_json::Map::new();
+            row.insert("@id".into(), json!(id.to_string()));
+            row.insert("@type".into(), json!(ty));
+            let catalog = crate::schema_props::METACLASS_PROPS;
+            let Ok(i) = catalog.binary_search_by_key(&ty, |(name, _)| *name) else {
+                issues.push(PropertyIssue {
+                    element_id: id,
+                    property: "@type".into(),
+                    reason: PropertyError::NotDeclared,
+                });
+                continue;
+            };
+            if let Err(issue) = charge(&mut snapshot.steps, catalog[i].1.len(), id) {
+                issues.push(issue);
+                break;
+            }
+            let mut checked_row = CheckedRow::default();
+            for &(name, _) in catalog[i].1 {
+                let result = if name == "aliasIds" {
+                    Ok(json!([]))
+                } else {
+                    r.property_with_row(e, name, &mut checked_row)
+                };
+                match result {
+                    Ok(value) => {
+                        row.insert(name.into(), value);
+                    }
+                    Err(reason) => issues.push(PropertyIssue {
+                        element_id: id,
+                        property: name.into(),
+                        reason,
+                    }),
+                }
+            }
+            output.push(Value::Object(row));
+        }
+        // A cold checked provider can complete lazy proof preparation. Never mix
+        // values from that transition: discard the entire candidate and recapture
+        // once, charging both scans to the same allowance. Continuing changes refuse.
+        if !snapshot.stamp.current(r) && attempt == 0 {
+            steps = snapshot.steps;
+            continue;
+        }
+        if let Err(issue) = snapshot.finish(r, &output) {
+            issues.push(issue);
+        }
+        if issues.is_empty() {
+            return Ok(Value::Array(output));
+        } else {
+            return Err(SemanticExportError { issues });
+        }
+    }
+    unreachable!("the final export attempt returns or refuses")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ClosurePolicy, model::Model};
+
+    fn model(text: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        assert!(m.add_source("export.kerml", text).diagnostics.is_empty());
+        ResolvedModel::build(&m)
+    }
+    fn candidate(r: &ResolvedModel, snapshot: &Snapshot) -> Vec<Value> {
+        snapshot.elements.iter().map(|&e| {
+            let row = &r.b.elements[e.0];
+            let relationships = semantic_ownership::owned_relationships(&r.b, e.0).unwrap();
+            json!({"@id":row.id,"@type":row.ty,
+                "ownedRelationship":relationships.iter().map(|i| json!({"@id":r.b.elements[i].id})).collect::<Vec<_>>(),
+                "ownedRelatedElement":row.children.iter().map(|&i| json!({"@id":r.b.elements[i].id})).collect::<Vec<_>>()})
+        }).collect()
+    }
+
+    #[test]
+    fn empty_namespace_export_matches_checked_properties_and_preserves_policy() {
+        let mut r = model("");
+        let before = r.closure_policy();
+        let output = r.to_full_json_strict().unwrap();
+        assert_eq!(r.closure_policy(), before);
+        assert_eq!(output.as_array().unwrap().len(), 1);
+        let e = r.user_elements().next().unwrap();
+        for (name, value) in output[0].as_object().unwrap() {
+            if matches!(name.as_str(), "@id" | "@type" | "aliasIds") {
+                continue;
+            }
+            assert_eq!(&r.property(e, name).unwrap(), value, "{name}");
+        }
+        assert_eq!(r.to_full_json_strict().unwrap(), output);
+    }
+
+    #[test]
+    fn snapshot_includes_the_existing_generated_user_domain_and_no_library_rows() {
+        let mut m = Model::new();
+        m.add_library_source(
+            "library.kerml",
+            "standard library package L { feature n=4; feature use=n; }",
+        );
+        m.add_source("export.kerml", "feature source=4; feature use=source;");
+        let mut r = ResolvedModel::build(&m);
+        let mut snapshot = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        assert!(snapshot.elements.iter().any(|e| e.0 >= r.b.explicit_len()));
+        let connector = snapshot
+            .elements
+            .iter()
+            .copied()
+            .find(|&e| e.0 >= r.b.explicit_len() && r.element_type(e) == "BindingConnector")
+            .expect("the generated result owns a binding connector");
+        assert!(r.b.elements[connector.0].owning_relationship.is_some());
+        assert_eq!(
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .generated_relationship_owner(connector.0),
+            None
+        );
+        let rows: Vec<_> = r.b.elements.iter().map(|e| (e.ty, e.id)).collect();
+        let output = candidate(&r, &snapshot);
+        snapshot.finish(&r, &output).unwrap();
+        let report = r.to_full_json_strict().unwrap_err();
+        let generated_ids: HashSet<_> = snapshot
+            .elements
+            .iter()
+            .filter(|e| e.0 >= r.b.explicit_len())
+            .map(|&e| r.element_id(e))
+            .collect();
+        assert!(
+            report
+                .issues
+                .iter()
+                .any(|issue| generated_ids.contains(&issue.element_id))
+        );
+        assert_eq!(
+            rows,
+            r.b.elements
+                .iter()
+                .map(|e| (e.ty, e.id))
+                .collect::<Vec<_>>()
+        );
+        let again = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        assert_eq!(snapshot.elements, again.elements);
+    }
+
+    #[test]
+    fn final_reference_check_distinguishes_missing_local_library_and_external_ids() {
+        let mut m = Model::new();
+        m.add_library_source("library.kerml", "standard library package L;");
+        m.add_source("export.kerml", "package P; package Q;");
+        let mut r = ResolvedModel::build(&m);
+        let mut snapshot = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        let mut output = candidate(&r, &snapshot);
+        let library = r.b.elements[0].id;
+        let external = Uuid::from_u128(79);
+        output[0]["references"] = json!([{"@id":library},{"@id":external}]);
+        snapshot.finish(&r, &output).unwrap();
+        let removed = snapshot.elements.pop().unwrap();
+        output.retain(|row| row["@id"] != r.element_id(removed).to_string());
+        output[0]["references"] = json!([{"@id":r.element_id(removed)}]);
+        let error = snapshot.finish(&r, &output).unwrap_err();
+        assert!(
+            matches!(error.reason, PropertyError::InvalidValue(ref s) if s.contains("local reference target"))
+        );
+    }
+
+    #[test]
+    fn strict_export_refuses_implied_authored_identity_collisions() {
+        let mut r = model("feature source=4; feature use=source;");
+        let snapshot = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        let generated = snapshot
+            .elements
+            .iter()
+            .find(|e| e.0 >= r.b.explicit_len())
+            .unwrap()
+            .0;
+        r.b.elements[generated].id = r.b.elements[0].id;
+        let report = r.to_full_json_strict().unwrap_err();
+        assert!(report.issues.iter().any(|issue| issue.property == "@id"));
+    }
+
+    #[test]
+    fn changed_rows_publication_or_policy_cannot_pass_the_final_snapshot_check() {
+        for change in 0..3 {
+            let mut r = model("package P;");
+            let mut snapshot = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+            let output = candidate(&r, &snapshot);
+            match change {
+                0 => {
+                    r.b.elements[0]
+                        .props
+                        .insert("declaredName", json!("changed"));
+                }
+                1 => r.b.publication.published(),
+                _ => r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                }),
+            }
+            assert!(matches!(snapshot.finish(&r, &output).unwrap_err().reason,
+                PropertyError::InvalidValue(ref s) if s.contains("snapshot changed")));
+        }
+    }
+
+    #[test]
+    fn publication_refusal_and_bounded_final_scan_are_explicit() {
+        let mut r = model("package P;");
+        let guard = r.b.publication.begin(true).unwrap();
+        assert!(
+            r.to_full_json_strict()
+                .unwrap_err()
+                .issues
+                .iter()
+                .any(|issue| issue.property == "@snapshot")
+        );
+        drop(guard);
+        let mut snapshot = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        let output = candidate(&r, &snapshot);
+        snapshot.steps = crate::eval::MAX_STEPS;
+        assert!(matches!(snapshot.finish(&r, &output).unwrap_err().reason,
+            PropertyError::InvalidValue(ref s) if s.contains("work limit")));
+        let mut retry = Snapshot::prepare(&mut r).unwrap_or_else(|e| panic!("{e:?}"));
+        retry.finish(&r, &output).unwrap();
+    }
+
+    /// Private, machine-readable census keyed by exact effective declaration,
+    /// receiver metaclass and refusal reason. It does not alter the public error.
+    fn census(r: &ResolvedModel, report: &SemanticExportError) -> Value {
+        let rows: HashMap<_, _> = r.b.elements.iter().map(|row| (row.id, row.ty)).collect();
+        let mut groups = std::collections::BTreeMap::<(_, _, _), (usize, Uuid)>::new();
+        for issue in &report.issues {
+            let ty = rows.get(&issue.element_id).copied().unwrap_or("<snapshot>");
+            let declaration = crate::semantic_catalog::property(ty, &issue.property)
+                .map(|(requested, effective)| effective.unwrap_or(requested).id)
+                .unwrap_or("<export>");
+            let count = groups
+                .entry((declaration, ty, issue.reason.to_string()))
+                .or_insert((0, issue.element_id));
+            count.0 += 1;
+        }
+        Value::Array(groups.into_iter().map(|((declaration,receiver,reason),(count,example))|
+            json!({"declaration":declaration,"receiver":receiver,"reason":reason,"count":count,"example":example})).collect())
+    }
+
+    #[test]
+    fn refusal_census_uses_catalog_identity_without_claiming_generated_family_completeness() {
+        let mut r =
+            model("function F {in x; return result;} feature source=4; feature use=source;");
+        let report = r.to_full_json_strict().unwrap_err();
+        let census = census(&r, &report);
+        assert_eq!(
+            census
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|row| row["count"].as_u64().unwrap() as usize)
+                .sum::<usize>(),
+            report.issues.len()
+        );
+        assert!(census.as_array().unwrap().iter().any(|row| {
+            row["declaration"]
+                .as_str()
+                .unwrap()
+                .starts_with("Core-Types-Type-")
+        }));
+        assert!(serde_json::to_string(&census).is_ok());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/semantic/type_fidelity_tests.rs b/crates/sysmlv2-model/src/json/semantic/type_fidelity_tests.rs
new file mode 100644
index 0000000..267f54c
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic/type_fidelity_tests.rs
@@ -0,0 +1,120 @@
+use super::*;
+use crate::{
+    json::{ClosurePolicy, derives},
+    model::Model,
+};
+fn model(source: &str) -> ResolvedModel {
+    let mut m = Model::new();
+    assert!(
+        m.add_source("typing-dependencies.kerml", source)
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    r
+}
+#[test]
+fn inverse_typing_invalidates_direct_filters_and_generated_compositions() {
+    // The first two cases are native source syntax. The remaining cases use
+    // the same explicit inverse FeatureTyping topology with exact receiver and
+    // target metaclasses to exercise each kind-filtered dependency branch.
+    for (receiver, target, property) in [
+        ("Feature", "Classifier", "type"),
+        ("Step", "Behavior", "behavior"),
+        ("Expression", "Function", "function"),
+        ("BooleanExpression", "Predicate", "predicate"),
+        ("MetadataFeature", "Metaclass", "metaclass"),
+        ("Connector", "Association", "association"),
+        ("Flow", "Interaction", "interaction"),
+        ("Usage", "Classifier", "definition"),
+    ] {
+        let mut r = model("classifier T; feature x; typing x typed by T;");
+        let x = r.resolve_qualified("x").unwrap();
+        let t = r.resolve_qualified("T").unwrap();
+        r.b.elements[x.0].ty = receiver;
+        r.b.elements[t.0].ty = target;
+        let compatibility = r.derived(x, property);
+        assert!(
+            matches!(compatibility,Derived::Value(DerivedValue::References(ref values)) if values.is_empty())
+                || matches!(compatibility, Derived::Value(DerivedValue::Null)),
+            "{receiver}.{property}: {compatibility:?}"
+        );
+        assert_eq!(
+            derives(receiver, property),
+            Derives::Passthrough,
+            "{receiver}.{property}"
+        );
+        assert!(r.property(x, property).is_err(), "{receiver}.{property}");
+        assert!(
+            r.derived_exact(x, property).is_err(),
+            "{receiver}.{property}"
+        );
+        assert_eq!(r.derived(x, property), compatibility);
+        for alias in ["type", "behavior", "function"] {
+            if crate::semantic_catalog::property(receiver, alias).is_some() {
+                assert!(
+                    r.property(x, alias).is_err(),
+                    "{receiver}.{alias} must not bypass its effective redefinition"
+                );
+                assert!(r.derived_exact(x, alias).is_err(), "{receiver}.{alias}");
+            }
+        }
+    }
+}
+#[test]
+fn individual_predicate_does_not_turn_missing_inverse_type_into_exact_null() {
+    let mut r = model("classifier T; feature x; typing x typed by T;");
+    let x = r.resolve_qualified("x").unwrap();
+    let t = r.resolve_qualified("T").unwrap();
+    r.b.elements[x.0].ty = "OccurrenceUsage";
+    r.b.elements[t.0].ty = "OccurrenceDefinition";
+    r.b.elements[t.0]
+        .props
+        .insert("isIndividual", serde_json::json!(true));
+    assert_eq!(
+        r.derived(x, "individualDefinition"),
+        Derived::Value(DerivedValue::Null)
+    );
+    assert_eq!(
+        derives("OccurrenceUsage", "individualDefinition"),
+        Derives::Passthrough
+    );
+    assert_eq!(
+        r.derived_exact(x, "individualDefinition"),
+        Err(PropertyError::Approximate)
+    );
+}
+#[test]
+fn payload_type_dereference_preserves_dependency_qualification() {
+    let mut r =
+        model("classifier T; feature holder {feature payload;} typing holder::payload typed by T;");
+    let holder = r.resolve_qualified("holder").unwrap();
+    let payload = r.resolve_qualified("holder::payload").unwrap();
+    r.b.elements[holder.0].ty = "Flow";
+    r.b.elements[payload.0].ty = "PayloadFeature";
+    assert_eq!(r.d_payload_feature(holder), Some(payload));
+    let compatibility = r.derived(holder, "payloadType");
+    assert_eq!(
+        compatibility,
+        Derived::Value(DerivedValue::References(vec![]))
+    );
+    assert_eq!(derives("Flow", "payloadType"), Derives::Passthrough);
+    assert_eq!(
+        r.derived_exact(holder, "payloadType"),
+        Err(PropertyError::Approximate)
+    );
+    assert_eq!(r.derived(holder, "payloadType"), compatibility);
+}
+#[test]
+fn owned_relationship_type_and_instantiated_type_keep_distinct_contracts() {
+    assert_eq!(derives("FeatureTyping", "type"), Derives::NotDeclared);
+    assert_eq!(
+        derives("InvocationExpression", "instantiatedType"),
+        Derives::Exact
+    );
+    assert_eq!(derives("Step", "behavior"), Derives::Passthrough);
+    assert_eq!(derives("Expression", "behavior"), Derives::Passthrough);
+}
diff --git a/crates/sysmlv2-model/src/json/semantic_batch.rs b/crates/sysmlv2-model/src/json/semantic_batch.rs
new file mode 100644
index 0000000..2e92a79
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic_batch.rs
@@ -0,0 +1,52 @@
+//! Detached static and dynamic specialization recipes.
+use super::positional::PositionalRedefinitions;
+use std::{collections::HashMap, sync::Arc};
+use uuid::Uuid;
+
+/// Exact materialization recipe, including the surviving legacy UUID. A recipe
+/// is not just a (source,target) pair: metaclass, typed aliases and ordering are
+/// observable. Static recipes come from the shared emitter, or are checked
+/// against its existing physical rows before this snapshot is admitted.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct Edge {
+    pub owner: usize,
+    pub owner_id: Uuid,
+    pub id: Uuid,
+    pub kind: &'static str,
+    pub source_key: &'static str,
+    pub target_key: &'static str,
+    pub target: Uuid,
+}
+
+/// One exact immutable prefix. Recreating this Arc after any provenance or
+/// configuration change intentionally makes pending admission stale, even if
+/// the new recipes happen to compare equal. Never reconstruct a prefix from
+/// current predictions alone when old physical rows already exist. The shared
+/// capture gate compares actual fields/order/carriers and preserves physical IDs.
+#[derive(Clone)]
+pub(super) struct StaticPrefix {
+    pub authored_end: usize,
+    pub rows: Vec<Edge>,
+    pub positional: Arc<PositionalRedefinitions>,
+    pub chain_bases: Arc<super::type_relations::FeatureChainBases>,
+    pub planner_bases: HashMap<usize, Vec<usize>>,
+    pub planner_incomplete: std::collections::HashSet<usize>,
+    pub specializations: HashMap<Uuid, Vec<Uuid>>,
+}
+
+/// The immutable accepted batch. All vectors/maps are fully constructed before
+/// publication. Direct bases and positional targets include static and dynamic
+/// contributions; tail contains only additions, in final materialization order.
+/// Result/Binding rows are reserved with these edges by the common tail builder
+/// before this value may publish; they are deliberately not constructed here.
+#[derive(Clone)]
+pub(super) struct Plan {
+    pub static_prefix: Arc<StaticPrefix>,
+    pub direct_bases: HashMap<usize, Vec<usize>>,
+    pub added_bases: HashMap<usize, Vec<usize>>,
+    pub affected_owners: std::collections::HashSet<usize>,
+    pub incomplete_bases: std::collections::HashSet<usize>,
+    pub specializations: HashMap<Uuid, Vec<Uuid>>,
+    pub positional: PositionalRedefinitions,
+    pub tail: Vec<Edge>,
+}
diff --git a/crates/sysmlv2-model/src/json/semantic_ownership.rs b/crates/sysmlv2-model/src/json/semantic_ownership.rs
new file mode 100644
index 0000000..52e7121
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/semantic_ownership.rs
@@ -0,0 +1,400 @@
+//! Shared ownership projection for the materialized semantic suffix.
+//!
+//! Source rows and their identity derivation remain unchanged. This module
+//! certifies only ownership of nodes produced by the materializer; it does not
+//! certify that every normative implied family has been implemented.
+use super::Builder;
+use std::collections::HashMap;
+
+#[derive(Clone, Copy)]
+struct GeneratedNode {
+    /// Relationships have a carrier; ordinary elements use their row backlink.
+    relationship_owner: Option<usize>,
+    /// Always an explicit declaration, not a synthetic scope or target owner.
+    source_anchor: usize,
+    added_to_source: bool,
+    /// Static generic rows have no children or nested ownership.
+    generic_relationship: bool,
+}
+
+/// Immutable after publication on Builder. There is one ownership view, shared
+/// by derived reads, interchange emission and structural proof adapters.
+#[derive(Clone)]
+pub(super) struct SemanticOwnership {
+    from: usize,
+    nodes: Vec<GeneratedNode>,
+    /// Relationships added to an unchanged source row. Relationships physically
+    /// owned by generated rows are NOT added here a second time.
+    additions: HashMap<usize, Vec<usize>>,
+    /// Positive owned-result projections only. Absence is unsupported/unknown,
+    /// never proof that a normative result is absent or a family is complete.
+    results: HashMap<usize, OwnedResult>,
+}
+
+#[derive(Clone, Copy)]
+pub(super) struct OwnedResult {
+    pub(super) membership: usize,
+    pub(super) feature: usize,
+}
+
+/// Borrowed lists let checked callers charge the complete iteration before
+/// allocating an output. Merely obtaining a row never clones its contents.
+pub(super) struct Relationships<'a> {
+    stored: &'a [usize],
+    additions: &'a [usize],
+}
+impl Relationships<'_> {
+    pub(super) fn len(&self) -> usize {
+        self.stored.len().saturating_add(self.additions.len())
+    }
+    pub(super) fn iter(&self) -> impl Iterator<Item = usize> + '_ {
+        self.stored.iter().chain(self.additions).copied()
+    }
+}
+
+/// One semantic owned-relationship projection shared by derived reads and
+/// checked adapters. The caller charges len before copying or traversing it.
+pub(super) fn owned_relationships(b: &Builder, owner: usize) -> Option<Relationships<'_>> {
+    match (&b.semantic_ownership, b.implied_from) {
+        (None, None) => Some(Relationships {
+            stored: &b.elements.get(owner)?.owned_relationships,
+            additions: &[],
+        }),
+        (Some(view), Some(_)) if view.matches_suffix(b) => view.relationships(b, owner),
+        _ => None,
+    }
+}
+
+/// Checked carrier identity without conflating a standalone relationship's
+/// carrier with its source. Typed endpoint readers validate source/target
+/// aliases and generic arrays separately. An authored isImplied flag grants
+/// no exemption; only the certified in-memory ownership view can add a carrier.
+pub(super) fn checked_relationship_carrier(
+    b: &Builder,
+    raw: &super::structural_index::StoredStructure,
+    relationship: usize,
+    steps: &mut usize,
+) -> Option<Option<usize>> {
+    if !raw.ids_unique
+        || !crate::metaclass::conforms(b.elements.get(relationship)?.ty, "Relationship")
+    {
+        return None;
+    }
+    match (&b.semantic_ownership, b.implied_from) {
+        (Some(view), Some(_)) if view.matches_suffix(b) => {
+            view.effective_carrier(b, raw, relationship, steps)
+        }
+        (None, None) => {
+            *steps = steps.saturating_add(1);
+            if *steps > crate::eval::MAX_STEPS {
+                return None;
+            }
+            raw.carrier(b, relationship)
+        }
+        _ => None,
+    }
+}
+
+/// Whether this overlay adds a known omission to an owned-feature projection.
+/// A true result only preserves a caller's previously audited evidence domain;
+/// it does NOT certify normative family completeness for Constructor, Invocation,
+/// FeatureChain, general Expression, or any other metaclass. Those family proofs
+/// remain the caller's responsibility. FeatureReference remains false: the
+/// local result/binding projection does not certify complete required connector
+/// ancestry, featuring, or every existing-result expression.
+pub(super) fn owned_feature_projection_complete(b: &Builder, owner: usize) -> bool {
+    b.elements
+        .get(owner)
+        .is_some_and(|e| !crate::metaclass::conforms(e.ty, "FeatureReferenceExpression"))
+}
+
+impl SemanticOwnership {
+    pub(super) fn clone_with_budget(&self, steps: &mut usize) -> Option<Self> {
+        let work = self
+            .nodes
+            .len()
+            .saturating_add(self.additions.capacity().saturating_mul(2))
+            .saturating_add(self.results.capacity());
+        *steps = steps.saturating_add(work);
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        for relationships in self.additions.values() {
+            *steps = steps.saturating_add(relationships.len());
+            if *steps > crate::eval::MAX_STEPS {
+                return None;
+            }
+        }
+        Some(self.clone())
+    }
+
+    pub(super) fn new(from: usize) -> Self {
+        Self {
+            from,
+            nodes: Vec::new(),
+            additions: HashMap::new(),
+            results: HashMap::new(),
+        }
+    }
+
+    /// Generated records cover exactly the materialized suffix. This is a
+    /// provenance shape check, not a substitute for raw carrier/alias validation.
+    pub(super) fn matches_suffix(&self, b: &Builder) -> bool {
+        b.implied_from == Some(self.from)
+            && self.from.checked_add(self.nodes.len()) == Some(b.elements.len())
+    }
+
+    /// Register one newly appended node. The materializer admits endpoints and
+    /// raw carriers BEFORE calling this; this is not an arbitrary payload owner
+    /// override. Registration order must exactly match the append-only suffix.
+    pub(super) fn register(
+        &mut self,
+        index: usize,
+        relationship_owner: Option<usize>,
+        source_anchor: usize,
+        added_to_source: bool,
+    ) -> Option<()> {
+        if index != self.from.checked_add(self.nodes.len())?
+            || source_anchor >= self.from
+            || relationship_owner.is_some_and(|owner| owner >= index)
+            || (added_to_source && relationship_owner.is_none_or(|owner| owner >= self.from))
+        {
+            return None;
+        }
+        self.nodes.push(GeneratedNode {
+            relationship_owner,
+            source_anchor,
+            added_to_source,
+            generic_relationship: false,
+        });
+        if added_to_source {
+            self.additions
+                .entry(relationship_owner?)
+                .or_default()
+                .push(index);
+        }
+        Some(())
+    }
+
+    /// Certify the existing static, childless generic relationship family.
+    /// The checked carrier preserves this shape after later row mutations.
+    pub(super) fn register_generic(&mut self, index: usize, owner: usize) -> Option<()> {
+        self.register(index, Some(owner), owner, true)?;
+        self.nodes.last_mut()?.generic_relationship = true;
+        Some(())
+    }
+
+    /// Publish only after the complete admitted result subtree is registered.
+    /// This certifies its ownership projection, not other expression obligations.
+    pub(super) fn record_result(
+        &mut self,
+        expression: usize,
+        membership: usize,
+        feature: usize,
+    ) -> Option<()> {
+        if self.generated_relationship_owner(membership) != Some(expression)
+            || !self.contains(feature)
+            || self.results.contains_key(&expression)
+        {
+            return None;
+        }
+        self.results.insert(
+            expression,
+            OwnedResult {
+                membership,
+                feature,
+            },
+        );
+        Some(())
+    }
+
+    /// Remove only a certified generated-result tail from a cloned view.
+    /// The caller invalidates tail-indexed caches before replacing Builder rows.
+    pub(super) fn without_result_tail(&self, boundary: usize) -> Option<Self> {
+        let keep = boundary.checked_sub(self.from)?;
+        if keep > self.nodes.len() {
+            return None;
+        }
+        let mut view = self.clone();
+        view.nodes.truncate(keep);
+        view.additions.retain(|_, relationships| {
+            relationships.retain(|&relationship| relationship < boundary);
+            !relationships.is_empty()
+        });
+        view.results.clear();
+        Some(view)
+    }
+
+    pub(super) fn result(&self, expression: usize) -> Option<OwnedResult> {
+        self.results.get(&expression).copied()
+    }
+
+    pub(super) fn relationships<'a>(
+        &'a self,
+        b: &'a Builder,
+        owner: usize,
+    ) -> Option<Relationships<'a>> {
+        Some(Relationships {
+            stored: &b.elements.get(owner)?.owned_relationships,
+            additions: self.additions(owner),
+        })
+    }
+
+    pub(super) fn additions(&self, owner: usize) -> &[usize] {
+        self.additions.get(&owner).map_or(&[], Vec::as_slice)
+    }
+
+    /// Does not confuse a generated Feature with a Relationship. Proof adapters
+    /// can distinguish a trusted generated carrier from malformed raw ownership.
+    pub(super) fn generated_relationship_owner(&self, element: usize) -> Option<usize> {
+        self.nodes
+            .get(element.checked_sub(self.from)?)?
+            .relationship_owner
+    }
+
+    /// Combine raw topology with a certified generated carrier. Never repair
+    /// an invalid raw carrier or reinterpret arbitrary source rows as generated.
+    pub(super) fn effective_carrier(
+        &self,
+        b: &Builder,
+        raw: &super::structural_index::StoredStructure,
+        relationship: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        use super::structural_index::Carrier;
+        *steps = steps.saturating_add(1);
+        if *steps > crate::eval::MAX_STEPS {
+            return None;
+        }
+        if !raw.ids_unique {
+            return None;
+        }
+        let Some(owner) = self.generated_relationship_owner(relationship) else {
+            return raw.carrier(b, relationship);
+        };
+        if !crate::metaclass::conforms(b.elements.get(relationship)?.ty, "Relationship")
+            || b.elements[relationship].owning_relationship.is_some()
+            || self.source_anchor(relationship) >= self.from
+        {
+            return None;
+        }
+        b.elements.get(owner)?;
+        b.elements.get(self.source_anchor(relationship))?;
+        let node = self.nodes.get(relationship.checked_sub(self.from)?)?;
+        if node.generic_relationship
+            && (owner >= self.from
+                || !node.added_to_source
+                || !b.elements[relationship].children.is_empty()
+                || !b.elements[relationship].owned_relationships.is_empty())
+        {
+            return None;
+        }
+        let added = node.added_to_source;
+        match raw.raw_carrier(b, relationship)? {
+            Carrier::Missing if added => {}
+            Carrier::Unique(actual) if actual == owner && !added => {}
+            _ => return None,
+        }
+        if b.elements
+            .get(relationship)?
+            .props
+            .get("owningRelatedElement")
+            .is_some_and(|value| value.as_reference() != Some(b.elements[owner].id))
+        {
+            return None;
+        }
+        Some(Some(owner))
+    }
+
+    pub(super) fn relationship_owners(&self) -> impl Iterator<Item = (usize, usize)> + '_ {
+        self.nodes.iter().enumerate().filter_map(|(offset, node)| {
+            node.relationship_owner
+                .map(|owner| (self.from + offset, owner))
+        })
+    }
+
+    pub(super) fn source_anchor(&self, element: usize) -> usize {
+        element
+            .checked_sub(self.from)
+            .and_then(|offset| self.nodes.get(offset))
+            .map_or(element, |node| node.source_anchor)
+    }
+
+    pub(super) fn contains(&self, element: usize) -> bool {
+        element
+            .checked_sub(self.from)
+            .is_some_and(|offset| offset < self.nodes.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generated_nodes_have_distinct_carrier_and_source_roles() {
+        let mut view = SemanticOwnership::new(10);
+        assert_eq!(view.register(10, Some(2), 2, true), Some(()));
+        assert_eq!(view.register(11, None, 2, false), Some(()));
+        assert_eq!(view.register(12, Some(11), 2, false), Some(()));
+        assert_eq!(view.additions(2), &[10]);
+        assert!(view.additions(11).is_empty());
+        assert_eq!(
+            view.relationship_owners().collect::<Vec<_>>(),
+            vec![(10, 2), (12, 11)]
+        );
+        assert_eq!(view.generated_relationship_owner(11), None);
+        assert_eq!(view.source_anchor(12), 2);
+        assert_eq!(view.source_anchor(8), 8);
+        assert!(view.contains(11));
+        assert!(!view.contains(13));
+    }
+
+    #[test]
+    fn malformed_registration_is_atomic() {
+        let mut view = SemanticOwnership::new(10);
+        assert_eq!(view.register(11, Some(2), 2, true), None);
+        assert_eq!(view.register(10, Some(10), 2, true), None);
+        assert_eq!(view.register(10, None, 2, true), None);
+        assert_eq!(view.register(10, Some(2), 10, true), None);
+        assert!(!view.contains(10));
+        assert!(view.additions(2).is_empty());
+        assert_eq!(view.register(10, Some(2), 2, true), Some(()));
+    }
+    #[test]
+    fn generic_carrier_keeps_its_childless_shape_for_every_adapter() {
+        for corruption in 0..3 {
+            let mut model = crate::model::Model::new();
+            model.add_library_source("generic.kerml", "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+            model.add_source(
+                "source.kerml",
+                "class A; feature target=1; feature read=target;",
+            );
+            let mut r = super::super::ResolvedModel::build(&model);
+            let a = r.resolve_qualified("A").unwrap();
+            let relation = r.implied_relationships(a)[0].0;
+            let view = r.b.semantic_ownership.clone().unwrap();
+            let mut steps = 0;
+            let raw =
+                super::super::structural_index::StoredStructure::for_query(&mut r.b, &mut steps)
+                    .unwrap();
+            assert_eq!(
+                checked_relationship_carrier(&r.b, &raw, relation, &mut steps),
+                Some(Some(a.0))
+            );
+            match corruption {
+                0 => r.b.elements[relation].children.push(a.0),
+                1 => r.b.elements[relation].owned_relationships.push(relation),
+                _ => r.b.elements[relation].owning_relationship = Some(relation),
+            }
+            let raw =
+                super::super::structural_index::StoredStructure::for_query(&mut r.b, &mut steps)
+                    .unwrap();
+            assert!(view.matches_suffix(&r.b));
+            assert_eq!(
+                checked_relationship_carrier(&r.b, &raw, relation, &mut steps),
+                None
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/settled.rs b/crates/sysmlv2-model/src/json/settled.rs
new file mode 100644
index 0000000..0f4e90e
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/settled.rs
@@ -0,0 +1,448 @@
+//! The outcomes a settled build resolved its references to, for the next
+//! build of the same units to start from.
+//!
+//! A language server builds a session again after every edit, and nearly
+//! every reference is as it was. Reference resolution repeats its pass
+//! against the lookup graph of the previous pass's outcomes until a pass
+//! changes none, starting from a pass over nothing; started instead from
+//! the outcomes the previous build settled on, the loop confirms them in
+//! one pass where the edit changed none, and otherwise carries the change
+//! through as many passes as it takes, which is what the loop does after
+//! its first pass anyway.
+//!
+//! The outcomes are kept per unit, under the unit's root path, and per
+//! reference in pending order, each with a fingerprint of the reference —
+//! its position within the unit, key, spelling, scope, exclusion, modes
+//! and chain — so that a reference lowered where and as it was takes its
+//! outcome, and any other — an edited reference, or every reference after
+//! an inserted or removed element — starts unresolved. An outcome names
+//! its target by the identity the element had before user identities were
+//! assigned — the ownership-path identity, which a unit lowered the same
+//! way assigns the same — or by its library identity; a target no row of
+//! the next build carries starts unresolved. The seed is a guess the first
+//! pass verifies: every pass resolves every reference, so a wrong or
+//! missing seed costs passes, never answers. Nor can a seed change what an
+//! acyclic model settles on, since each pass's outcomes follow from the
+//! graph of the previous pass's and the chain of what depends on what ends
+//! at references resolved lexically; a cyclic model, which the checks
+//! report, could settle on a fixed point the seed chose as it could on one
+//! the first pass chose, and a seeded loop that does not settle within its
+//! passes starts over cold.
+
+use super::{Builder, PendingRef, id_ref};
+use crate::libcache::Fnv;
+use serde_json::json;
+use std::collections::HashMap;
+use std::sync::Arc;
+use uuid::Uuid;
+
+/// The outcomes a settled build's references resolved to, per unit, for
+/// the next build of the same units to start from (see the module).
+#[derive(Clone, Default)]
+pub struct SettledOutcomes {
+    units: HashMap<String, SettledUnit>,
+}
+
+#[derive(Clone)]
+struct SettledUnit {
+    /// Each reference in pending order: its fingerprint — position within
+    /// the unit, key, spelling, scope, exclusion, modes and chain — and its
+    /// outcome, the identity of its target before user identities were
+    /// assigned, or `None` unresolved.
+    refs: Vec<(u64, Option<Uuid>)>,
+}
+
+impl SettledOutcomes {
+    /// How many units' outcomes are kept.
+    pub fn unit_count(&self) -> usize {
+        self.units.len()
+    }
+}
+
+/// The outcomes seeded into a build's pending references, in pending
+/// order: `None` for a reference without a kept outcome.
+#[derive(Clone)]
+pub(super) struct Seed {
+    outcomes: Vec<Option<Option<Uuid>>>,
+}
+
+#[cfg(test)]
+thread_local! {
+    static SEEDS_ABANDONED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+/// How many seeded loops did not settle and started over cold.
+#[cfg(test)]
+pub(crate) fn seeds_abandoned() -> usize {
+    SEEDS_ABANDONED.with(|c| c.get())
+}
+#[cfg(test)]
+pub(super) fn note_seed_abandoned() {
+    SEEDS_ABANDONED.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+pub(super) fn note_seed_abandoned() {}
+
+#[cfg(test)]
+thread_local! {
+    /// A test's budget of seeded passes, in place of the loop's own.
+    static SEEDED_PASSES: std::cell::Cell<Option<usize>> = const { std::cell::Cell::new(None) };
+}
+/// The passes a seeded loop may take before starting over cold.
+pub(super) fn seeded_passes() -> usize {
+    #[cfg(test)]
+    if let Some(passes) = SEEDED_PASSES.with(|c| c.get()) {
+        return passes;
+    }
+    super::REDO_PASSES + 1
+}
+#[cfg(test)]
+pub(crate) fn set_seeded_passes(passes: Option<usize>) {
+    SEEDED_PASSES.with(|c| c.set(passes));
+}
+
+impl Builder {
+    /// The pending references by unit, in pending order: each unit's root
+    /// path, and each of its references' index and fingerprint.
+    fn pending_by_unit(&self, pending: &[PendingRef]) -> Vec<(String, Vec<(usize, u64)>)> {
+        let mut units: Vec<(String, Vec<(usize, u64)>)> = Vec::new();
+        let mut current: Option<(usize, usize, usize)> = None;
+        let mut spelled = String::new();
+        for (i, p) in pending.iter().enumerate() {
+            // the unit the reference's element was lowered in
+            let unit = match self.unit_starts.binary_search_by_key(&p.elem, |&(e, _)| e) {
+                Ok(u) => u,
+                Err(0) => 0,
+                Err(u) => u - 1,
+            };
+            if current.is_none_or(|(u, ..)| u != unit) {
+                let start = self.unit_starts[unit].0;
+                let scope_start = self.scope_starts.get(unit).map_or(0, |&(s, _)| s);
+                current = Some((unit, start, scope_start));
+                units.push((self.elements[start].path.clone(), Vec::new()));
+            }
+            let (_, start, scope_start) = current.unwrap();
+            let mut hash = Fnv::new();
+            hash.update(&(p.elem.wrapping_sub(start) as u64).to_le_bytes());
+            hash.update(p.key.as_bytes());
+            hash.update(&[0]);
+            spelled.clear();
+            p.qn.write_ref_string(&mut spelled);
+            hash.update(spelled.as_bytes());
+            hash.update(&[0]);
+            hash.update(&(p.scope.wrapping_sub(scope_start) as u64).to_le_bytes());
+            hash.update(
+                &(p.exclude.map_or(u64::MAX, |e| e.wrapping_sub(start) as u64)).to_le_bytes(),
+            );
+            hash.update(&[u8::from(p.declared_only), u8::from(p.spec_idx.is_some())]);
+            for link in p.chain.iter().flatten() {
+                spelled.clear();
+                link.write_ref_string(&mut spelled);
+                hash.update(spelled.as_bytes());
+                hash.update(&[0]);
+            }
+            units.last_mut().unwrap().1.push((i, hash.finish()));
+        }
+        units
+    }
+
+    /// Keep the outcomes this build settled on, for the next build of the
+    /// same units to start from, when asked to.
+    pub(super) fn record_settled(&mut self, pending: &[PendingRef]) {
+        if !self.keep_settled {
+            return;
+        }
+        // An array key's references append in pending order: the n-th
+        // reference of an element's key reads the array's n-th entry.
+        let mut appended: HashMap<(usize, &str), usize> = HashMap::new();
+        let mut units = HashMap::new();
+        for (path, refs) in self.pending_by_unit(pending) {
+            let refs = refs
+                .iter()
+                .map(|&(i, fingerprint)| {
+                    let p = &pending[i];
+                    let props = &self.elements[p.elem].props;
+                    let outcome = match p.key.split_once('#') {
+                        Some((base, _)) => {
+                            let n = appended.entry((p.elem, base)).or_insert(0);
+                            let entry = props
+                                .get(base)
+                                .and_then(|v| v.as_array()?.get(*n)?.as_reference());
+                            *n += 1;
+                            entry
+                        }
+                        None => props.get(&p.key).and_then(|v| v.as_reference()),
+                    };
+                    (fingerprint, outcome)
+                })
+                .collect();
+            units.insert(path, SettledUnit { refs });
+        }
+        self.settled = Some(Arc::new(SettledOutcomes { units }));
+    }
+
+    /// The seed `settled` gives this build's pending references: the kept
+    /// outcome of every reference lowered where and as its unit's reference
+    /// at the same position was. `None` when no reference takes one.
+    pub(super) fn seed_from(
+        &self,
+        pending: &[PendingRef],
+        settled: &SettledOutcomes,
+    ) -> Option<Seed> {
+        let mut outcomes = vec![None; pending.len()];
+        let mut seeded = false;
+        for (path, refs) in self.pending_by_unit(pending) {
+            let Some(unit) = settled.units.get(&path) else {
+                continue;
+            };
+            for (k, &(i, fingerprint)) in refs.iter().enumerate() {
+                if let Some(&(kept, outcome)) = unit.refs.get(k) {
+                    if kept == fingerprint {
+                        outcomes[i] = Some(outcome);
+                        seeded = true;
+                    }
+                }
+            }
+        }
+        seeded.then_some(Seed { outcomes })
+    }
+
+    /// Write the seed as the outcomes a pass would have written: a kept
+    /// target some row of this build carries, as a reference to that row;
+    /// anything else as unresolved.
+    pub(super) fn apply_seed(&mut self, pending: &[PendingRef], seed: &Seed) {
+        // this build's rows by id, and the frozen rows through the kept table
+        let frozen = self
+            .prefix_ids
+            .clone()
+            .filter(|ids| ids.len() == self.lib_boundary && self.elements.base_untouched());
+        let start = if frozen.is_some() {
+            self.lib_boundary
+        } else {
+            0
+        };
+        let own: crate::layered::IdMap<Uuid, usize> = self
+            .elements
+            .iter()
+            .enumerate()
+            .skip(start)
+            .map(|(i, e)| (e.id, i))
+            .collect();
+        for p in pending {
+            if let Some((key, _)) = p.key.split_once('#') {
+                self.elements[p.elem].props.insert(key, json!([]));
+            }
+        }
+        for (p, outcome) in pending.iter().zip(&seed.outcomes) {
+            let target = outcome
+                .flatten()
+                .and_then(|id| own.get(&id).or_else(|| frozen.as_ref()?.get(&id)).copied());
+            if let Some(si) = p.spec_idx {
+                self.record_spec_outcome(si, target, &[]);
+            }
+            let value = match target {
+                Some(target) => id_ref(self.elements[target].id),
+                None => crate::properties::Atom::from(json!({ "@ref": p.qn.to_ref_string() })),
+            };
+            self.set_pending_value(p.elem, &p.key, value);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::recorded_lookup::settled_passes;
+    use super::super::{ResolvedModel, passes};
+    use super::*;
+    use crate::model::Model;
+    use crate::prepared::PreparedLibrary;
+
+    const LIBRARY: &str = "package Lib { part def Base { attribute mass; attribute parts; } part def Other { attribute mass; } }";
+    const A: &str = "package A { part def Car :> Lib::Base { attribute :>> mass; } part car : Car { attribute :>> mass = 1; } }";
+    const B: &str = "package B { import A::*; part def Truck :> Car { attribute :>> mass = 2; } part truck : Truck { attribute :>> parts; } }";
+    const B_CHANGED: &str = "package B { import A::*; part def Truck :> Lib::Other { attribute :>> mass = 2; } part truck : Truck { attribute :>> parts; } }";
+
+    fn library() -> Arc<PreparedLibrary> {
+        let mut base = Model::new();
+        let parsed = base.add_library_source("lib.sysml", LIBRARY);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        base.prepare_library().unwrap()
+    }
+
+    /// A build of `a` and `b` on the library, starting from `start` when
+    /// given, with the outcomes it settled on.
+    fn build(
+        library: &Arc<PreparedLibrary>,
+        a: &str,
+        b: &str,
+        start: Option<Arc<SettledOutcomes>>,
+    ) -> (ResolvedModel, Option<Arc<SettledOutcomes>>) {
+        let mut model = Model::new();
+        Arc::clone(library).install(&mut model).unwrap();
+        for (name, text) in [("a.sysml", a), ("b.sysml", b)] {
+            let parsed = model.add_source(name, text);
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        }
+        match start {
+            Some(start) => model.start_from_settled(start),
+            None => model.keep_settled_outcomes(),
+        }
+        let r = ResolvedModel::build(&model);
+        assert!(r.b.library_facts.is_some(), "built on the prepared library");
+        let settled = model.settled_outcomes();
+        (r, settled)
+    }
+
+    /// What a build answers: its elements' metaclasses, identities and
+    /// properties, the references it could not resolve, and the sites
+    /// and imports it recorded.
+    fn answers(r: &ResolvedModel) -> String {
+        let mut out = serde_json::to_string(&r.source_compact_json()).unwrap();
+        out.push_str(&format!(
+            "\n{:?}\n{:?}\n{}\n{:?}",
+            r.b.unresolved,
+            r.b.ambiguous,
+            r.b.ref_sites.len(),
+            {
+                let mut used: Vec<_> = r.b.used_imports.iter().copied().collect();
+                used.sort_unstable();
+                used
+            }
+        ));
+        out
+    }
+
+    #[test]
+    fn the_same_units_settle_in_one_pass_from_the_kept_outcomes() {
+        let library = library();
+        let (cold, settled) = build(&library, A, B, None);
+        let settled = settled.expect("kept");
+        assert_eq!(settled.unit_count(), 2);
+        let passes_before = passes();
+        let settles_before = settled_passes();
+        let (warm, kept_again) = build(&library, A, B, Some(Arc::clone(&settled)));
+        assert_eq!(passes() - passes_before, 1, "one confirming pass");
+        assert_eq!(settled_passes() - settles_before, 1);
+        assert_eq!(answers(&warm), answers(&cold));
+        assert!(
+            kept_again.is_some(),
+            "the seeded build keeps its outcomes too"
+        );
+    }
+
+    #[test]
+    fn a_changed_reference_starts_unresolved_and_the_rest_from_their_outcomes() {
+        let library = library();
+        let (_, settled) = build(&library, A, B, None);
+        let settled = settled.unwrap();
+        let (cold, _) = build(&library, A, B_CHANGED, None);
+        let passes_before = passes();
+        let (warm, _) = build(&library, A, B_CHANGED, Some(settled));
+        let warm_passes = passes() - passes_before;
+        assert_eq!(answers(&warm), answers(&cold));
+        let passes_before = passes();
+        build(&library, A, B_CHANGED, None);
+        let cold_passes = passes() - passes_before;
+        assert!(
+            warm_passes <= cold_passes + 1,
+            "{warm_passes} passes, cold {cold_passes}"
+        );
+    }
+
+    #[test]
+    fn a_wrong_seed_costs_a_pass_and_no_answer() {
+        let library = library();
+        let (cold, settled) = build(&library, A, B, None);
+        let mut wrong = (*settled.unwrap()).clone();
+        // every kept outcome unresolved, and then every one pointing at
+        // the library's `Other::mass`
+        let other_mass = (0..cold.b.lib_boundary)
+            .rev()
+            .map(|i| &cold.b.elements[i])
+            .find(|e| {
+                e.ty == "AttributeUsage"
+                    && e.props.get("declaredName").and_then(|v| v.as_str()) == Some("mass")
+            })
+            .map(|e| e.id)
+            .unwrap();
+        for target in [None, Some(other_mass)] {
+            for unit in wrong.units.values_mut() {
+                for (_, outcome) in &mut unit.refs {
+                    *outcome = target;
+                }
+            }
+            let passes_before = passes();
+            let (warm, _) = build(&library, A, B, Some(Arc::new(wrong.clone())));
+            assert!(
+                passes() - passes_before >= 2,
+                "the wrong guess is corrected and confirmed"
+            );
+            assert_eq!(answers(&warm), answers(&cold));
+        }
+    }
+
+    #[test]
+    fn a_seeded_loop_that_does_not_settle_starts_over_cold() {
+        let library = library();
+        let (cold, settled) = build(&library, A, B, None);
+        let settled = settled.unwrap();
+        let passes_before = passes();
+        build(&library, A, B, None);
+        let cold_passes = passes() - passes_before;
+        set_seeded_passes(Some(0));
+        let abandoned = seeds_abandoned();
+        let passes_before = passes();
+        let (warm, kept) = build(&library, A, B, Some(settled));
+        set_seeded_passes(None);
+        assert_eq!(seeds_abandoned(), abandoned + 1);
+        assert_eq!(
+            passes() - passes_before,
+            cold_passes,
+            "the cold passes after the abandoned seed"
+        );
+        assert_eq!(answers(&warm), answers(&cold));
+        assert!(kept.is_some());
+    }
+
+    #[test]
+    fn outcomes_of_other_units_do_not_seed() {
+        let library = library();
+        let (_, settled) = build(&library, A, B, None);
+        let settled = settled.unwrap();
+        // the same texts under other unit names: no reference takes a seed
+        let renamed = |start: Option<Arc<SettledOutcomes>>| {
+            let mut model = Model::new();
+            Arc::clone(&library).install(&mut model).unwrap();
+            model.add_source("x.sysml", A);
+            model.add_source("y.sysml", B);
+            match start {
+                Some(start) => model.start_from_settled(start),
+                None => model.keep_settled_outcomes(),
+            }
+            ResolvedModel::build(&model)
+        };
+        let passes_before = passes();
+        let cold = renamed(None);
+        let cold_passes = passes() - passes_before;
+        let abandoned = seeds_abandoned();
+        let passes_before = passes();
+        let warm = renamed(Some(settled));
+        assert_eq!(passes() - passes_before, cold_passes, "a cold build");
+        assert_eq!(seeds_abandoned(), abandoned, "no seed to abandon");
+        assert_eq!(answers(&warm), answers(&cold));
+    }
+
+    /// A unit with an element inserted before its references: the
+    /// references after it lie elsewhere in the unit, so they take no
+    /// seed; the other unit's do, and the answers are the cold build's.
+    #[test]
+    fn references_after_an_inserted_element_start_unresolved() {
+        let library = library();
+        let (_, settled) = build(&library, A, B, None);
+        let settled = settled.unwrap();
+        let inserted = B.replacen("package B { ", "package B { part def Extra; ", 1);
+        assert_ne!(inserted, B);
+        let (cold, _) = build(&library, A, &inserted, None);
+        let (warm, _) = build(&library, A, &inserted, Some(settled));
+        assert_eq!(answers(&warm), answers(&cold));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/structural_index.rs b/crates/sysmlv2-model/src/json/structural_index.rs
new file mode 100644
index 0000000..7d92ac1
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/structural_index.rs
@@ -0,0 +1,2334 @@
+//! Reusable immutable stored-graph topology; never semantic proof results.
+//! Reuse requires identical element rows and authored/implied provenance.
+use super::Builder;
+use crate::{layered::Revision, metaclass::conforms};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, OnceLock},
+};
+use uuid::Uuid;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Carrier {
+    Missing,
+    Unique(usize),
+    Invalid,
+}
+
+/// All fields are structural identity facts, independent of names, closure
+/// policies, inheritance providers, source lookup contexts and proof budgets.
+#[derive(Default)]
+pub(super) struct StoredStructure {
+    revision: Option<Revision>,
+    authored_end: usize,
+    logical_work: usize,
+    ids: Arc<crate::layered::IdMap<Uuid, usize>>,
+    carriers: Vec<Carrier>,
+    multiple_membership_carriers: bool,
+    pub(super) type_featurings: HashMap<usize, Vec<usize>>,
+    pub(super) bad_chains: HashSet<usize>,
+    pub(super) bad_bases: HashSet<usize>,
+    source_incomplete: bool,
+    /// Lazy inverse projection of these same rows; ordinary consumers do not
+    /// allocate or scan it. A failed bounded scan is never published.
+    typing: OnceLock<Arc<StoredTyping>>,
+    // Candidate identities collected during the existing complete row scan.
+    // Includes standalone and generated rows, independent of source validity.
+    typing_rows: Vec<usize>,
+    memberships: OnceLock<Arc<MembershipDomains>>,
+    membership_rows: Vec<usize>,
+    imports: OnceLock<Arc<ImportDomains>>,
+    pub(super) ids_unique: bool,
+    /// Includes standalone/orphan authored Import rows, independent of owner
+    /// lists or a stored isImplied flag. Shared absence checks cost O(1).
+    pub(super) has_authored_import: bool,
+    pub(super) has_recursive_import: bool,
+    import_rows: Vec<usize>,
+    pub(super) metadata_annotation_targets: HashSet<usize>,
+    pub(super) metadata_annotation_sources: HashMap<usize, Vec<usize>>,
+    pub(super) annotations_incomplete: bool,
+}
+/// Inverse Feature.typing and Feature.subsetting, independent of carrier.
+/// Suffix rows remain subject to the shared semantic carrier certificate.
+#[derive(Default)]
+pub(super) struct StoredTyping {
+    pub(super) relationships: HashMap<usize, Vec<usize>>,
+    pub(super) sources_incomplete: bool,
+}
+
+/// Inverse ownership contradictions for authored Membership domains. This is
+/// structural row evidence, not a new semantic graph or family certificate.
+#[derive(Default)]
+pub(super) struct MembershipDomains {
+    bad_owners: HashSet<usize>,
+    unlocalized: bool,
+}
+impl MembershipDomains {
+    pub(super) fn owner_complete(&self, owner: usize) -> bool {
+        !self.unlocalized && !self.bad_owners.contains(&owner)
+    }
+}
+
+/// Authored Import ownership contradictions, kept separate from Membership
+/// evidence so a query that does not consume imports need not pay for them.
+#[derive(Default)]
+pub(super) struct ImportDomains {
+    recursive_owners: HashSet<usize>,
+    bad_owners: HashSet<usize>,
+    unlocalized: bool,
+}
+impl ImportDomains {
+    pub(super) fn localized(&self) -> bool {
+        !self.unlocalized
+    }
+    pub(super) fn recursive_owner(&self, owner: usize) -> bool {
+        self.recursive_owners.contains(&owner)
+    }
+    pub(super) fn owner_complete(&self, owner: usize) -> bool {
+        !self.unlocalized && !self.bad_owners.contains(&owner)
+    }
+}
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+/// First establish the unique annotating source independently of the target.
+/// A certified nonmetadata source cannot contribute semantic metadata, even
+/// when its unrelated annotation target is unresolved. Metadata sources still
+/// require the complete endpoint/ownership certificate before target admission.
+fn annotation_ends(
+    b: &Builder,
+    relationship: usize,
+    carriers: &[Carrier],
+    ids: &crate::layered::IdMap<Uuid, usize>,
+    unsatisfied: &mut HashSet<Uuid>,
+    steps: &mut usize,
+) -> Option<(usize, Option<usize>)> {
+    charge(steps, 1)?;
+    let relation = b.elements.get(relationship)?;
+    let Carrier::Unique(owner) = *carriers.get(relationship)? else {
+        return None;
+    };
+    let owner_elem = b.elements.get(owner)?;
+    if relation.owning_relationship.is_some() {
+        return None;
+    }
+    charge(steps, relation.children.len())?;
+    let mut children = HashSet::new();
+    let mut owned_annotating = None;
+    for &child in &relation.children {
+        let element = b.elements.get(child)?;
+        if !children.insert(child)
+            || element.owning_relationship != Some(relationship)
+            || element
+                .props
+                .get("owningRelationship")
+                .is_some_and(|value| value.as_reference() != Some(relation.id))
+        {
+            return None;
+        }
+        if conforms(element.ty, "AnnotatingElement") && owned_annotating.replace(child).is_some() {
+            return None;
+        }
+    }
+    let owning_annotating = conforms(owner_elem.ty, "AnnotatingElement").then_some(owner);
+    // Exactly one owned or owning annotating element, per XMI7633.
+    let source = match (owned_annotating, owning_annotating) {
+        (Some(source), None) | (None, Some(source)) => source,
+        _ => return None,
+    };
+    for (key, expected) in [
+        ("annotatingElement", Some(source)),
+        ("owningAnnotatingElement", owning_annotating),
+        ("ownedAnnotatingElement", owned_annotating),
+        ("owningRelatedElement", Some(owner)),
+    ] {
+        if let Some(value) = relation.props.get(key) {
+            let matches = match expected {
+                Some(element) => value.as_reference() == Some(b.elements[element].id),
+                None => value.is_null(),
+            };
+            if !matches {
+                return None;
+            }
+        }
+    }
+    let source_id = b.elements[source].id;
+    if let Some(value) = relation.props.get("source") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != 1 || values[0].as_reference() != Some(source_id) {
+            return None;
+        }
+    }
+    if let Some(value) = relation.props.get("relatedElement") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != 2 || values[0].as_reference() != Some(source_id) {
+            return None;
+        }
+    }
+    if let Some(value) = relation.props.get("ownedRelatedElement") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != relation.children.len()
+            || values
+                .iter()
+                .zip(relation.children.iter())
+                .any(|(v, &child)| v.as_reference() != Some(b.elements[child].id))
+        {
+            return None;
+        }
+    }
+    // Keep this early nonmetadata certificate bounded to the two normal
+    // ownership shapes. Additional owned endpoints still take the complete
+    // validation path below.
+    if !conforms(b.elements[source].ty, "MetadataFeature")
+        && (relation.children.is_empty()
+            || (relation.children.len() == 1 && owned_annotating == Some(relation.children[0])))
+    {
+        return Some((source, None));
+    }
+    let target = match relation.props.get("annotatedElement") {
+        Some(value) => {
+            let id = value.as_reference()?;
+            match ids.get(&id) {
+                Some(&target) => target,
+                None => {
+                    unsatisfied.insert(id);
+                    return None;
+                }
+            }
+        }
+        None if owned_annotating.is_some() => owner,
+        None => return None,
+    };
+    if owned_annotating.is_some() != (target == owner) {
+        return None;
+    }
+    for &child in &relation.children {
+        if child != source && child != target {
+            return None;
+        }
+    }
+    if let Some(value) = relation.props.get("owningAnnotatedElement") {
+        let matches = if target == owner {
+            value.as_reference() == Some(owner_elem.id)
+        } else {
+            value.is_null()
+        };
+        if !matches {
+            return None;
+        }
+    }
+    let target_id = b.elements.get(target)?.id;
+    if let Some(value) = relation.props.get("target") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != 1 || values[0].as_reference() != Some(target_id) {
+            return None;
+        }
+    }
+    // The source and array shape were validated before source classification.
+    if let Some(value) = relation.props.get("relatedElement") {
+        if value.as_array()?[1].as_reference() != Some(target_id) {
+            return None;
+        }
+    }
+    Some((source, Some(target)))
+}
+
+/// What a scan of a range of rows records: the ownership carriers, ids and
+/// import rows, the authored relationships' type featurings and base
+/// contradictions, and the annotations. The scan of a table's frozen rows
+/// is kept and reused ([`PrefixStructure`]); the rows after them are
+/// scanned again for every structure.
+#[derive(Clone, Default)]
+pub(super) struct Scanned {
+    carriers: Vec<Carrier>,
+    ids: crate::layered::IdMap<Uuid, usize>,
+    logical_work: usize,
+    source_incomplete: bool,
+    ids_unique: bool,
+    import_rows: Vec<usize>,
+    has_authored_import: bool,
+    has_recursive_import: bool,
+    type_featurings: HashMap<usize, Vec<usize>>,
+    bad_chains: HashSet<usize>,
+    bad_bases: HashSet<usize>,
+    metadata_annotation_targets: HashSet<usize>,
+    metadata_annotation_sources: HashMap<usize, Vec<usize>>,
+    annotation_pairs: HashSet<(usize, usize)>,
+    annotations_incomplete: bool,
+    /// Whether a membership row was claimed by more than one owner.
+    multiple_membership_carriers: bool,
+    /// The authored membership rows, and the typing and subsetting rows,
+    /// in row order: the candidates the domain projections read.
+    membership_rows: Vec<usize>,
+    typing_rows: Vec<usize>,
+    /// The ids the rows' references named that no row scanned carried: a
+    /// later row carrying one would be read as their target by a whole
+    /// scan, so a scan of later rows reports such a row (see [`scan`]).
+    unsatisfied: HashSet<Uuid>,
+    /// The budget the scan charged; a reuse charges it again, so the budget
+    /// reads as if the rows had been scanned.
+    steps: usize,
+}
+impl Scanned {
+    fn new(rows: usize) -> Self {
+        Self {
+            carriers: vec![Carrier::Missing; rows],
+            ids_unique: true,
+            ..Self::default()
+        }
+    }
+}
+
+/// The scan of a table's frozen rows, kept beside the rows it describes so
+/// that every build sharing them scans only its own rows. The scan reads
+/// every frozen relationship as its frozen owner's and every frozen id as
+/// its frozen row's, and every id a frozen reference named that no frozen
+/// row carried as unsatisfied, which holds while no later row claims one
+/// of them: a scan of the later rows that meets such a claim — a row
+/// claiming a frozen relationship, carrying a frozen row's id, or carrying
+/// an id a frozen reference named — says so, and the table is scanned whole
+/// instead (see [`scan`]). No production writer makes such a row —
+/// `new_relationship` pushes the row it appends, staged rows index staged
+/// rows, and a text-built library stores an unresolved reference as its
+/// spelling — so the whole scan is the guard, not the path.
+pub(crate) struct PrefixStructure {
+    base: Arc<Vec<super::Elem>>,
+    scanned: Scanned,
+}
+impl PrefixStructure {
+    /// A frozen table's rows are all authored: implied relationships are
+    /// materialized after a freeze and lie past them.
+    fn scan(b: &Builder, steps: &mut usize) -> Option<Self> {
+        let rows = b.elements.base_len();
+        let mut scanned = Scanned::new(rows);
+        let before = *steps;
+        // no rows precede these, so none is claimed
+        scan(b, &mut scanned, 0, rows, rows, steps)?;
+        scanned.steps = steps.saturating_sub(before);
+        Some(Self {
+            base: Arc::clone(b.elements.base_arc()),
+            scanned,
+        })
+    }
+}
+
+#[cfg(test)]
+thread_local! {
+    static PREFIX_REUSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+#[cfg(test)]
+pub(super) fn prefix_reuses() -> usize {
+    PREFIX_REUSES.with(|c| c.get())
+}
+#[cfg(test)]
+fn note_prefix_reuse() {
+    PREFIX_REUSES.with(|c| c.set(c.get() + 1));
+}
+#[cfg(not(test))]
+fn note_prefix_reuse() {}
+
+/// Scan the rows `start..end` into `scanned`. The rows before `start` must
+/// be scanned already: an annotation's ends are read through the carriers
+/// and ids, and a relationship's base through the ids. Returns whether the
+/// rows claimed only rows from `start`: a row claiming the relationship
+/// row, or the id, of a row before `start`, or carrying an id a reference
+/// of those rows named that none of them carried, makes the earlier scan
+/// read those as it would not have, and the caller scans whole.
+fn scan(
+    b: &Builder,
+    scanned: &mut Scanned,
+    start: usize,
+    end: usize,
+    authored_end: usize,
+    steps: &mut usize,
+) -> Option<bool> {
+    if scanned.carriers.len() < end {
+        scanned.carriers.resize(end, Carrier::Missing);
+    }
+    scanned.logical_work = scanned.logical_work.saturating_add(end - start);
+    let mut own = true;
+    let mut annotation_rows = Vec::new();
+    for owner in start..end {
+        let element = &b.elements[owner];
+        if owner < authored_end && conforms(element.ty, "Membership") {
+            scanned.membership_rows.push(owner);
+        }
+        if conforms(element.ty, "Annotation") {
+            annotation_rows.push(owner);
+        }
+        if conforms(element.ty, "FeatureTyping") || conforms(element.ty, "Subsetting") {
+            scanned.typing_rows.push(owner);
+        }
+        if conforms(element.ty, "Import") {
+            scanned.import_rows.push(owner);
+            scanned.has_recursive_import |= element
+                .props
+                .get("isRecursive")
+                .is_some_and(|v| v.as_bool() != Some(false));
+        }
+        own &= !scanned.unsatisfied.contains(&element.id);
+        if let Some(previous) = scanned.ids.insert(element.id, owner) {
+            scanned.ids_unique = false;
+            own &= previous >= start;
+        }
+        charge(steps, element.owned_relationships.len())?;
+        scanned.logical_work = scanned
+            .logical_work
+            .saturating_add(element.owned_relationships.len());
+        for &rel in &element.owned_relationships {
+            own &= rel >= start;
+            let entry = scanned.carriers.get_mut(rel)?;
+            if *entry != Carrier::Missing && conforms(b.elements[rel].ty, "Membership") {
+                scanned.multiple_membership_carriers = true;
+            }
+            *entry = match entry {
+                Carrier::Missing => Carrier::Unique(owner),
+                _ => Carrier::Invalid,
+            };
+        }
+    }
+    // Materialized relationships are owned through the semantic side table,
+    // not the authored ownership rows indexed here. Their bases are already
+    // supplied by the retained shared implied plan. A stored isImplied flag
+    // alone does not establish this provenance and must not bypass checks.
+    for rel in start..end.min(authored_end) {
+        let carrier = scanned.carriers[rel];
+        let element = &b.elements[rel];
+        if conforms(element.ty, "Import") {
+            scanned.has_authored_import = true;
+        }
+        let owner = match carrier {
+            Carrier::Unique(owner) => Some(owner),
+            _ => None,
+        };
+        let owned_feature = owner.filter(|&e| conforms(b.elements[e].ty, "Feature"));
+        let key = if conforms(element.ty, "TypeFeaturing") {
+            "featureOfType"
+        } else if conforms(element.ty, "FeatureChaining") {
+            "featureChained"
+        } else if conforms(element.ty, "Conjugation") {
+            "conjugatedType"
+        } else if conforms(element.ty, "Specialization") {
+            [
+                "specific",
+                "subclassifier",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ]
+            .into_iter()
+            .find(|key| element.props.get(key).is_some())
+            .unwrap_or("specific")
+        } else {
+            continue;
+        };
+        let ty = element.ty;
+        let source = match element.props.get(key) {
+            Some(value) => match value.as_reference() {
+                Some(id) => {
+                    let source = scanned.ids.get(&id).copied();
+                    if source.is_none() {
+                        scanned.unsatisfied.insert(id);
+                    }
+                    source
+                }
+                None => {
+                    scanned.source_incomplete = true;
+                    None
+                }
+            },
+            None => {
+                if conforms(ty, "TypeFeaturing") {
+                    owned_feature
+                } else {
+                    owner
+                }
+            }
+        };
+        if conforms(ty, "TypeFeaturing") {
+            if let Some(source) = source {
+                if !conforms(b.elements[source].ty, "Feature") {
+                    scanned.source_incomplete = true;
+                }
+                scanned.type_featurings.entry(source).or_default().push(rel);
+            } else {
+                // A missing standalone source might name any feature.
+                scanned.source_incomplete = true;
+            }
+        } else if let Some(source) = source {
+            if owner != Some(source) {
+                if conforms(ty, "FeatureChaining") {
+                    scanned.bad_chains.insert(source);
+                } else {
+                    scanned.bad_bases.insert(source);
+                }
+            }
+        }
+    }
+    // Validate the annotation candidates the row scan gathered: no second
+    // scan of the rows. We cannot ignore an annotation as non-metadata until
+    // its ends and ownership agree.
+    charge(steps, annotation_rows.len())?;
+    scanned.logical_work = scanned.logical_work.saturating_add(annotation_rows.len());
+    for relationship in annotation_rows {
+        let before = *steps;
+        let ends = annotation_ends(
+            b,
+            relationship,
+            &scanned.carriers,
+            &scanned.ids,
+            &mut scanned.unsatisfied,
+            steps,
+        );
+        scanned.logical_work = scanned
+            .logical_work
+            .saturating_add(steps.saturating_sub(before));
+        charge(steps, 0)?;
+        match ends {
+            Some((source, Some(target))) if conforms(b.elements[source].ty, "MetadataFeature") => {
+                scanned.metadata_annotation_targets.insert(target);
+                if scanned.annotation_pairs.insert((source, target)) {
+                    scanned
+                        .metadata_annotation_sources
+                        .entry(target)
+                        .or_default()
+                        .push(source);
+                }
+            }
+            Some(_) => {}
+            None => scanned.annotations_incomplete = true,
+        }
+    }
+    Some(own)
+}
+
+impl StoredStructure {
+    pub(super) fn has_import_rows(&self) -> bool {
+        self.has_authored_import
+            || self
+                .import_rows
+                .last()
+                .is_some_and(|&row| row >= self.authored_end)
+    }
+    /// Import absence requires inverse owner claims as well as the owner's
+    /// forward list. This is raw topology only, not an import contribution plan.
+    pub(super) fn import_domains(
+        &self,
+        b: &Builder,
+        steps: &mut usize,
+    ) -> Option<Arc<ImportDomains>> {
+        charge(steps, 1)?;
+        if !self.is_current(b) || !self.ids_unique {
+            return None;
+        }
+        if let Some(domains) = self.imports.get() {
+            return Some(Arc::clone(domains));
+        }
+        let mut domains = ImportDomains::default();
+        let mut claims: HashMap<usize, HashSet<usize>> = HashMap::new();
+        let mut bad_relations = HashSet::new();
+        let mut multiple_carriers = false;
+        if self.has_import_rows() {
+            charge(steps, self.import_rows.len())?;
+            for &relationship in &self.import_rows {
+                let row = &b.elements[relationship];
+                let actual = match self.carriers[relationship] {
+                    Carrier::Unique(owner) => Some(owner),
+                    Carrier::Invalid => {
+                        multiple_carriers = true;
+                        bad_relations.insert(relationship);
+                        None
+                    }
+                    _ => {
+                        bad_relations.insert(relationship);
+                        None
+                    }
+                };
+                // No current publisher certifies generated Import semantics.
+                // A mutated suffix row may not disappear from absence proofs.
+                if relationship >= self.authored_end
+                    || actual.is_some_and(|owner| !conforms(b.elements[owner].ty, "Namespace"))
+                    || row.owning_relationship.is_some()
+                    || !(row.children.is_empty()
+                        || (row.ty == "NamespaceImport"
+                            && row.children.len() == 1
+                            && b.elements.get(row.children[0]).is_some_and(|child| {
+                                child.ty == "Package"
+                                    && child.owning_relationship == Some(relationship)
+                                    && row
+                                        .props
+                                        .get("importedNamespace")
+                                        .and_then(|v| v.as_reference())
+                                        == Some(child.id)
+                            })))
+                {
+                    bad_relations.insert(relationship);
+                }
+                let mut owners = HashSet::new();
+                if let Some(owner) = actual {
+                    owners.insert(owner);
+                }
+                let mut claim = |value: &crate::properties::Atom| match value
+                    .as_reference()
+                    .and_then(|id| self.ids.get(&id).copied())
+                {
+                    Some(owner) => {
+                        owners.insert(owner);
+                        if actual != Some(owner) || !conforms(b.elements[owner].ty, "Namespace") {
+                            bad_relations.insert(relationship);
+                        }
+                    }
+                    None => {
+                        bad_relations.insert(relationship);
+                        if !value.is_null() {
+                            domains.unlocalized = true;
+                        }
+                    }
+                };
+                for key in ["owningRelatedElement", "importOwningNamespace"] {
+                    charge(steps, 1)?;
+                    if let Some(value) = row.props.get(key) {
+                        claim(value);
+                    }
+                }
+                let mut malformed_array = false;
+                let mut bad_shape = false;
+                for key in ["source", "relatedElement"] {
+                    charge(steps, 1)?;
+                    if let Some(value) = row.props.get(key) {
+                        if let Some(values) = value.as_array() {
+                            let count = if key == "source" {
+                                values.len()
+                            } else {
+                                usize::from(!values.is_empty())
+                            };
+                            charge(steps, count)?;
+                            bad_shape |= values.len() != if key == "source" { 1 } else { 2 };
+                            for value in values.iter().take(count) {
+                                claim(value);
+                            }
+                        } else {
+                            malformed_array = true;
+                        }
+                    }
+                }
+                if malformed_array {
+                    domains.unlocalized = true;
+                }
+                if malformed_array || bad_shape {
+                    bad_relations.insert(relationship);
+                }
+                if row
+                    .props
+                    .get("isRecursive")
+                    .is_some_and(|v| v.as_bool() != Some(false))
+                {
+                    charge(steps, owners.len())?;
+                    domains.recursive_owners.extend(owners.iter().copied());
+                }
+                claims.insert(relationship, owners);
+            }
+        }
+        if multiple_carriers {
+            // Only contradictory duplicate-carrier imports need the full owner
+            // recovery scan. Ordinary and orphan imports use the indexed rows.
+            charge(steps, self.authored_end)?;
+            for owner in 0..self.authored_end {
+                let relationships = &b.elements[owner].owned_relationships;
+                charge(steps, relationships.len())?;
+                for &relationship in relationships {
+                    if self.carriers.get(relationship) == Some(&Carrier::Invalid)
+                        && b.elements
+                            .get(relationship)
+                            .is_some_and(|r| conforms(r.ty, "Import"))
+                    {
+                        claims.entry(relationship).or_default().insert(owner);
+                    }
+                }
+            }
+        }
+        charge(steps, bad_relations.len())?;
+        for relationship in bad_relations {
+            let owners = claims.get(&relationship)?;
+            charge(steps, owners.len())?;
+            if owners.is_empty() {
+                domains.unlocalized = true;
+            } else {
+                domains.bad_owners.extend(owners.iter().copied());
+            }
+        }
+        let domains = Arc::new(domains);
+        let _ = self.imports.set(Arc::clone(&domains));
+        Some(Arc::clone(self.imports.get().unwrap()))
+    }
+
+    /// Lazy inverse check of every authored Membership owner and owned-member
+    /// backlink. Forward enumeration alone cannot prove a result/input unique.
+    /// This index depends only on this raw row revision; generated ownership is
+    /// checked by the existing semantic overlay at the consumer boundary.
+    pub(super) fn membership_domains(
+        &self,
+        b: &Builder,
+        steps: &mut usize,
+    ) -> Option<Arc<MembershipDomains>> {
+        charge(steps, 1)?;
+        if !self.is_current(b) || !self.ids_unique {
+            return None;
+        }
+        if let Some(domains) = self.memberships.get() {
+            return Some(Arc::clone(domains));
+        }
+        charge(steps, self.membership_rows.len())?;
+        let mut domains = MembershipDomains::default();
+        let mut claims: HashMap<usize, HashSet<usize>> = HashMap::new();
+        let mut bad_relations = HashSet::new();
+        for &relationship in &self.membership_rows {
+            let row = &b.elements[relationship];
+            let actual = match self.carriers[relationship] {
+                Carrier::Unique(owner) => Some(owner),
+                Carrier::Missing => None,
+                Carrier::Invalid => {
+                    bad_relations.insert(relationship);
+                    None
+                }
+            };
+            let mut owners = HashSet::new();
+            if let Some(owner) = actual {
+                owners.insert(owner);
+            }
+            let mut claim = |value: &crate::properties::Atom| match value
+                .as_reference()
+                .and_then(|id| self.ids.get(&id).copied())
+            {
+                Some(owner) => {
+                    owners.insert(owner);
+                    if actual != Some(owner) {
+                        bad_relations.insert(relationship);
+                    }
+                }
+                None => {
+                    if !value.is_null() {
+                        domains.unlocalized = true;
+                    }
+                    if actual.is_some() {
+                        bad_relations.insert(relationship);
+                    }
+                }
+            };
+            for key in [
+                "owningRelatedElement",
+                "membershipOwningNamespace",
+                "owningType",
+                "featureWithValue",
+            ] {
+                if key == "featureWithValue" && !conforms(row.ty, "FeatureValue") {
+                    continue;
+                }
+                if key == "owningType" && !conforms(row.ty, "FeatureMembership") {
+                    continue;
+                }
+                charge(steps, 1)?;
+                if let Some(value) = row.props.get(key) {
+                    claim(value);
+                }
+            }
+            let mut malformed_array = false;
+            for key in ["source", "relatedElement"] {
+                charge(steps, 1)?;
+                if let Some(value) = row.props.get(key) {
+                    if let Some(values) = value.as_array() {
+                        let count = if key == "source" {
+                            values.len()
+                        } else {
+                            usize::from(!values.is_empty())
+                        };
+                        charge(steps, count)?;
+                        for value in values.iter().take(count) {
+                            claim(value);
+                        }
+                    } else {
+                        malformed_array = true;
+                    }
+                }
+            }
+            if malformed_array {
+                domains.unlocalized = true;
+                bad_relations.insert(relationship);
+            }
+            claims.insert(relationship, owners);
+        }
+        // Invalid raw carrier cardinality still identifies every actual owner;
+        // localize those contradictions instead of poisoning unrelated domains.
+        if self.multiple_membership_carriers {
+            charge(steps, self.authored_end)?;
+            for owner in 0..self.authored_end {
+                let relationships = &b.elements[owner].owned_relationships;
+                charge(steps, relationships.len())?;
+                for &relationship in relationships {
+                    if self.carriers.get(relationship) == Some(&Carrier::Invalid)
+                        && b.elements
+                            .get(relationship)
+                            .is_some_and(|r| conforms(r.ty, "Membership"))
+                    {
+                        claims.entry(relationship).or_default().insert(owner);
+                    }
+                }
+            }
+        }
+        // The child side is independent evidence: an omitted extra child can
+        // claim a perfectly listed singleton Membership and defeat uniqueness.
+        charge(steps, self.authored_end)?;
+        for child in 0..self.authored_end {
+            let row = &b.elements[child];
+            let mut relationships = HashSet::new();
+            if let Some(relationship) = row.owning_relationship {
+                if b.elements.get(relationship).is_none() {
+                    domains.unlocalized = true;
+                }
+                if b.elements
+                    .get(relationship)
+                    .is_some_and(|r| conforms(r.ty, "Membership"))
+                {
+                    relationships.insert(relationship);
+                }
+            }
+            for key in [
+                "owningRelationship",
+                "owningMembership",
+                "owningFeatureMembership",
+                "owningParameterMembership",
+            ] {
+                if matches!(key, "owningFeatureMembership" | "owningParameterMembership")
+                    && !conforms(row.ty, "Feature")
+                {
+                    continue;
+                }
+                charge(steps, 1)?;
+                if let Some(value) = row.props.get(key) {
+                    if value.is_null() {
+                        continue;
+                    }
+                    match value
+                        .as_reference()
+                        .and_then(|id| self.ids.get(&id).copied())
+                    {
+                        Some(relationship)
+                            if conforms(b.elements[relationship].ty, "Membership") =>
+                        {
+                            relationships.insert(relationship);
+                        }
+                        Some(_) if key == "owningRelationship" => {}
+                        _ => domains.unlocalized = true,
+                    }
+                }
+            }
+            if conforms(row.ty, "Feature") {
+                if let Some(value) = row.props.get("owningType") {
+                    charge(steps, 1)?;
+                    let claimed = value
+                        .as_reference()
+                        .and_then(|id| self.ids.get(&id).copied());
+                    let actual = row.owning_relationship.and_then(|relationship| {
+                        let membership = b.elements.get(relationship)?;
+                        if !conforms(membership.ty, "FeatureMembership") {
+                            return None;
+                        }
+                        match self.carriers.get(relationship)? {
+                            Carrier::Unique(owner) => Some(*owner),
+                            _ => None,
+                        }
+                    });
+                    if claimed.is_none() && !value.is_null() {
+                        domains.unlocalized = true;
+                    }
+                    if claimed != actual {
+                        if let Some(owner) = claimed {
+                            domains.bad_owners.insert(owner);
+                        }
+                        if let Some(owner) = actual {
+                            domains.bad_owners.insert(owner);
+                        }
+                    }
+                }
+            }
+            for relationship in relationships {
+                charge(steps, 1)?;
+                let membership = &b.elements[relationship];
+                if !conforms(membership.ty, "OwningMembership")
+                    || membership.children.as_ref() != [child]
+                    || row.owning_relationship != Some(relationship)
+                {
+                    bad_relations.insert(relationship);
+                }
+                if conforms(membership.ty, "FeatureMembership") {
+                    if let Some(value) = row.props.get("owningType") {
+                        charge(steps, 1)?;
+                        let owner = value
+                            .as_reference()
+                            .and_then(|id| self.ids.get(&id).copied());
+                        let actual = match self.carriers[relationship] {
+                            Carrier::Unique(owner) => Some(owner),
+                            _ => None,
+                        };
+                        if owner != actual {
+                            bad_relations.insert(relationship);
+                            if let Some(owner) = owner {
+                                claims.entry(relationship).or_default().insert(owner);
+                            } else if !value.is_null() {
+                                domains.unlocalized = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        charge(steps, bad_relations.len())?;
+        for relationship in bad_relations {
+            if let Some(owners) = claims.get(&relationship) {
+                charge(steps, owners.len())?;
+                domains.bad_owners.extend(owners.iter().copied());
+            } else {
+                domains.unlocalized = true;
+            }
+        }
+        let domains = Arc::new(domains);
+        let _ = self.memberships.set(Arc::clone(&domains));
+        Some(domains)
+    }
+
+    /// Actual amortized work for a new projection. The legacy get() logical
+    /// charge is unchanged, including after this optional projection is built.
+    pub(super) fn typing(&self, b: &Builder, steps: &mut usize) -> Option<Arc<StoredTyping>> {
+        charge(steps, 1)?;
+        if !self.is_current(b) {
+            return None;
+        }
+        if let Some(typing) = self.typing.get() {
+            return Some(Arc::clone(typing));
+        }
+        // Feature.type reads inverse associations, including standalone rows
+        // and generated result subsettings. This is a projection of the same
+        // stored identities/carriers, never an independent semantic graph.
+        charge(steps, self.typing_rows.len())?;
+        let mut typing_relationships: HashMap<usize, Vec<usize>> = HashMap::new();
+        let mut typing_sources_incomplete = false;
+        for &relationship in &self.typing_rows {
+            let element = &b.elements[relationship];
+            let mut source_id = None;
+            let mut invalid = false;
+            for key in [
+                "specific",
+                "typedFeature",
+                "subsettingFeature",
+                "redefiningFeature",
+                "referencingFeature",
+                "crossingFeature",
+            ] {
+                if let Some(value) = element.props.get(key) {
+                    match value.as_reference() {
+                        Some(id) if source_id.is_none_or(|old| old == id) => source_id = Some(id),
+                        _ => invalid = true,
+                    }
+                }
+            }
+            let source = source_id
+                .and_then(|id| self.ids.get(&id).copied())
+                .or_else(|| {
+                    if source_id.is_some() || invalid {
+                        return None;
+                    }
+                    match self.carriers[relationship] {
+                        Carrier::Unique(owner) if conforms(b.elements[owner].ty, "Feature") => {
+                            Some(owner)
+                        }
+                        _ => None,
+                    }
+                });
+            // Contradictory generic source/relatedElement evidence may name
+            // another feature; it cannot be charged only to the scalar source.
+            for (key, length) in [("source", 1usize), ("relatedElement", 2usize)] {
+                if let Some(value) = element.props.get(key) {
+                    match value.as_array() {
+                        Some(values) => {
+                            charge(steps, values.len())?;
+                            if values.len() != length
+                                || source.is_none_or(|source| {
+                                    values[0].as_reference() != Some(b.elements[source].id)
+                                })
+                            {
+                                invalid = true;
+                            }
+                        }
+                        None => invalid = true,
+                    }
+                }
+            }
+            if source_id.is_none()
+                && element
+                    .props
+                    .get("owningRelatedElement")
+                    .is_some_and(|value| {
+                        value.as_reference() != source.map(|source| b.elements[source].id)
+                    })
+            {
+                invalid = true;
+            }
+            if invalid || source.is_none_or(|source| !conforms(b.elements[source].ty, "Feature")) {
+                // Missing/contradictory sources cannot be attributed to an
+                // arbitrary local feature, so completeness is globally unknown.
+                typing_sources_incomplete = true;
+                continue;
+            }
+            typing_relationships
+                .entry(source.unwrap())
+                .or_default()
+                .push(relationship);
+        }
+        charge(steps, 0)?;
+        let typing = Arc::new(StoredTyping {
+            relationships: typing_relationships,
+            sources_incomplete: typing_sources_incomplete,
+        });
+        // A concurrent structural reader could win publication; either value
+        // describes this same immutable row epoch. No proof facts are cached.
+        let _ = self.typing.set(Arc::clone(&typing));
+        Some(Arc::clone(self.typing.get().unwrap()))
+    }
+
+    pub(super) fn is_current(&self, b: &Builder) -> bool {
+        self.authored_end == b.implied_from.unwrap_or(b.elements.len())
+            && self
+                .revision
+                .as_ref()
+                .zip(b.elements.revision())
+                .is_some_and(|(stored, current)| stored.same_as(current))
+    }
+    /// New annotation absence consumers pay construction once, then actual
+    /// O(1) immutable-index access. This intentionally differs from get(), whose
+    /// legacy TypeRelations caller retains its historical logical scan charge.
+    /// No proof result is cached; only current raw topology may be reused.
+    pub(super) fn for_annotations(b: &mut Builder, steps: &mut usize) -> Option<Arc<Self>> {
+        Self::for_query(b, steps)
+    }
+    /// Amortized structural access for new bounded proof consumers. Existing
+    /// get() callers retain their historical logical scan charge.
+    pub(super) fn for_query(b: &mut Builder, steps: &mut usize) -> Option<Arc<Self>> {
+        if let Some(stored) = b.stored_structure.as_ref().filter(|s| s.is_current(b)) {
+            charge(steps, 1)?;
+            let stored = Arc::clone(stored);
+            // Sharing an existing immutable UUID map is also O(1), including
+            // after a caller cleared lookup caches without changing rows.
+            b.id_index = Some(Arc::clone(&stored.ids));
+            b.id_index_built_for = b.elements.len();
+            Some(stored)
+        } else {
+            Self::get(b, steps)
+        }
+    }
+    pub(super) fn get(b: &mut Builder, steps: &mut usize) -> Option<Arc<Self>> {
+        charge(steps, 1)?;
+        let n = b.elements.len();
+        if let Some(stored) = b.stored_structure.as_ref().filter(|s| s.is_current(b)) {
+            charge(steps, stored.logical_work)?;
+            if b.id_index.is_none() || b.id_index_built_for != n {
+                charge(steps, n)?;
+            }
+            // The same immutable UUID projection is shared, not rebuilt or
+            // copied. This also restores it after explicit cache clearing.
+            let stored = Arc::clone(stored);
+            b.id_index = Some(Arc::clone(&stored.ids));
+            b.id_index_built_for = n;
+            return Some(stored);
+        }
+        charge(steps, n)?;
+        if b.id_index.is_none() || b.id_index_built_for != n {
+            charge(steps, n)?;
+        }
+        let authored_end = b.implied_from.unwrap_or(n);
+        let scanned = Self::scanned(b, authored_end, steps)?;
+        let stored = Arc::new(Self {
+            revision: Some(b.elements.observe_revision()),
+            authored_end,
+            logical_work: scanned.logical_work,
+            ids: Arc::new(scanned.ids),
+            carriers: scanned.carriers,
+            multiple_membership_carriers: scanned.multiple_membership_carriers,
+            type_featurings: scanned.type_featurings,
+            bad_chains: scanned.bad_chains,
+            bad_bases: scanned.bad_bases,
+            source_incomplete: scanned.source_incomplete,
+            typing: OnceLock::new(),
+            typing_rows: scanned.typing_rows,
+            memberships: OnceLock::new(),
+            membership_rows: scanned.membership_rows,
+            imports: OnceLock::new(),
+            ids_unique: scanned.ids_unique,
+            has_authored_import: scanned.has_authored_import,
+            has_recursive_import: scanned.has_recursive_import,
+            import_rows: scanned.import_rows,
+            metadata_annotation_targets: scanned.metadata_annotation_targets,
+            metadata_annotation_sources: scanned.metadata_annotation_sources,
+            annotations_incomplete: scanned.annotations_incomplete,
+        });
+        b.id_index = Some(Arc::clone(&stored.ids));
+        b.id_index_built_for = n;
+        b.stored_structure = Some(Arc::clone(&stored));
+        Some(stored)
+    }
+
+    /// The scan behind a structure over every row: the frozen rows from the
+    /// scan their freeze kept, or one made and kept here, while no frozen
+    /// row has been written and the implied rows lie past them; the rows
+    /// after the frozen ones every time. A table without frozen rows, with
+    /// one written since, or with a later row claiming a frozen row or an
+    /// id a frozen reference named (see [`PrefixStructure`]) is scanned
+    /// whole.
+    fn scanned(b: &mut Builder, authored_end: usize, steps: &mut usize) -> Option<Scanned> {
+        let n = b.elements.len();
+        let base_len = b.elements.base_len();
+        let whole = |b: &Builder, steps: &mut usize| {
+            let mut scanned = Scanned::new(n);
+            scan(b, &mut scanned, 0, n, authored_end, steps)?;
+            Some(scanned)
+        };
+        if base_len == 0 || !b.elements.base_untouched() || authored_end < base_len {
+            return whole(b, steps);
+        }
+        let before = *steps;
+        let kept = b
+            .prefix_structure
+            .as_ref()
+            .filter(|prefix| Arc::ptr_eq(&prefix.base, b.elements.base_arc()));
+        let reused = kept.is_some();
+        let prefix = match kept {
+            Some(prefix) => {
+                // the budget a scan of those rows would charge
+                charge(steps, prefix.scanned.steps)?;
+                Arc::clone(prefix)
+            }
+            None => {
+                let prefix = Arc::new(PrefixStructure::scan(b, steps)?);
+                b.prefix_structure = Some(Arc::clone(&prefix));
+                prefix
+            }
+        };
+        let mut scanned = prefix.scanned.clone();
+        if !scan(b, &mut scanned, base_len, n, authored_end, steps)? {
+            // A row of this build claims a frozen relationship or a frozen
+            // row's id, which the kept scan read as the frozen rows' own:
+            // scan whole, charging what a whole scan charges.
+            *steps = before;
+            return whole(b, steps);
+        }
+        if reused {
+            note_prefix_reuse();
+        }
+        Some(scanned)
+    }
+
+    /// The scan of a table's frozen rows, for its freeze to keep: `None`
+    /// without frozen rows, with one written since, or past the budget.
+    pub(crate) fn prefix_of(b: &Builder) -> Option<Arc<PrefixStructure>> {
+        if b.elements.base_len() == 0 || !b.elements.base_untouched() {
+            return None;
+        }
+        let mut steps = 0;
+        PrefixStructure::scan(b, &mut steps).map(Arc::new)
+    }
+
+    pub(super) fn incomplete(&self) -> bool {
+        !self.ids_unique || self.source_incomplete
+    }
+
+    /// Resolve an endpoint in this exact, unique structural snapshot. Consumers
+    /// need not depend on the mutable ambient Builder lookup-cache lifecycle.
+    pub(super) fn element_for_uuid(&self, b: &Builder, id: Uuid) -> Option<usize> {
+        (self.ids_unique && self.is_current(b))
+            .then(|| self.ids.get(&id).copied())
+            .flatten()
+    }
+
+    /// Raw carrier cardinality without scalar alias agreement. A semantic
+    /// overlay may combine Missing with certified generated ownership; Invalid
+    /// must never become valid merely because an override supplies an owner.
+    pub(super) fn raw_carrier(&self, b: &Builder, rel: usize) -> Option<Carrier> {
+        self.is_current(b)
+            .then(|| self.carriers.get(rel).copied())
+            .flatten()
+    }
+
+    pub(super) fn carrier(&self, b: &Builder, rel: usize) -> Option<Option<usize>> {
+        let owner = match self.raw_carrier(b, rel)? {
+            Carrier::Missing => None,
+            Carrier::Unique(owner) => Some(owner),
+            Carrier::Invalid => return None,
+        };
+        if let Some(value) = b.elements.get(rel)?.props.get("owningRelatedElement") {
+            if value.as_reference() != owner.map(|e| b.elements[e].id) {
+                return None;
+            }
+        }
+        Some(owner)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    fn fixture() -> ResolvedModel {
+        let mut model = Model::new();
+        let parsed = model.add_source(
+            "structural.kerml",
+            "class A {feature x;} class B; featuring A::x by B;",
+        );
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn cache_hit_preserves_logical_budget_and_does_not_rebuild() {
+        let mut r = fixture();
+        let first_id = r.b.elements[0].id;
+        r.b.element_index_of_uuid(first_id);
+        let mut cold_steps = 0;
+        let cold = StoredStructure::get(&mut r.b, &mut cold_steps).unwrap();
+        let mut warm_steps = 0;
+        let warm = StoredStructure::get(&mut r.b, &mut warm_steps).unwrap();
+        assert!(Arc::ptr_eq(&cold, &warm));
+        assert_eq!(cold_steps, warm_steps);
+        r.b.id_index = None;
+        let mut cleared_steps = 0;
+        let restored = StoredStructure::get(&mut r.b, &mut cleared_steps).unwrap();
+        assert!(Arc::ptr_eq(&warm, &restored));
+        assert_eq!(cleared_steps, warm_steps + r.b.elements.len());
+        assert!(Arc::ptr_eq(r.b.id_index.as_ref().unwrap(), &restored.ids));
+    }
+
+    #[test]
+    fn clone_and_freeze_share_only_unchanged_rows() {
+        let mut r = fixture();
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let membership = r.b.elements[x].owning_relationship.unwrap();
+        let original = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        r.b.elements.freeze();
+        assert!(Arc::ptr_eq(
+            &original,
+            &StoredStructure::get(&mut r.b, &mut 0).unwrap()
+        ));
+        let mut copy = r.b.clone();
+        assert!(Arc::ptr_eq(
+            &original,
+            &StoredStructure::get(&mut copy, &mut 0).unwrap()
+        ));
+        let owner = original.carrier(&copy, membership).unwrap().unwrap();
+        copy.elements[owner].owned_relationships.push(membership);
+        assert!(!original.is_current(&copy));
+        let changed = StoredStructure::get(&mut copy, &mut 0).unwrap();
+        assert!(!Arc::ptr_eq(&original, &changed));
+        assert_eq!(changed.carrier(&copy, membership), None);
+        assert_eq!(original.carrier(&r.b, membership), Some(Some(owner)));
+        assert!(Arc::ptr_eq(
+            &original,
+            &StoredStructure::get(&mut r.b, &mut 0).unwrap()
+        ));
+    }
+
+    #[test]
+    fn same_length_ids_and_provenance_invalidate_without_stale_uuid_resolution() {
+        let mut r = fixture();
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let original = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(original.type_featurings.contains_key(&x));
+        let old_id = r.b.elements[x].id;
+        let new_id = Uuid::from_u128(0x7825786254891);
+        r.b.elements[x].id = new_id;
+        let changed = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!Arc::ptr_eq(&original, &changed));
+        assert!(
+            changed.incomplete(),
+            "old inverse source must become unresolved"
+        );
+        assert_eq!(r.b.element_index_of_uuid(new_id), Some(x));
+        assert_eq!(r.b.element_index_of_uuid(old_id), None);
+        r.b.implied_from = Some(0);
+        let generated = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!Arc::ptr_eq(&changed, &generated));
+        assert!(generated.type_featurings.is_empty());
+        assert!(!generated.incomplete());
+    }
+
+    #[test]
+    fn failed_budget_or_invalid_carrier_never_publishes_partial_index() {
+        let mut r = fixture();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(StoredStructure::get(&mut r.b, &mut exhausted).is_none());
+        assert!(r.b.stored_structure.is_none());
+        let complete = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        exhausted = crate::eval::MAX_STEPS - 1;
+        assert!(StoredStructure::get(&mut r.b, &mut exhausted).is_none());
+        assert!(Arc::ptr_eq(
+            &complete,
+            r.b.stored_structure.as_ref().unwrap()
+        ));
+        assert!(Arc::ptr_eq(
+            &complete,
+            &StoredStructure::get(&mut r.b, &mut 0).unwrap()
+        ));
+        let out_of_range = r.b.elements.len();
+        r.b.elements[0].owned_relationships.push(out_of_range);
+        assert!(StoredStructure::get(&mut r.b, &mut 0).is_none());
+        assert!(!complete.is_current(&r.b));
+        assert_eq!(
+            r.b.elements[0].owned_relationships.make_mut().pop(),
+            Some(out_of_range)
+        );
+        let repaired = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!Arc::ptr_eq(&complete, &repaired));
+        assert!(repaired.is_current(&r.b));
+        assert!(!repaired.incomplete());
+        assert!(Arc::ptr_eq(
+            &repaired,
+            &StoredStructure::get(&mut r.b, &mut 0).unwrap()
+        ));
+    }
+}
+
+#[cfg(test)]
+mod import_completeness_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    fn fixture() -> (ResolvedModel, usize, usize, usize, usize) {
+        let mut model = Model::new();
+        let parsed = model.add_source(
+            "import-domains.kerml",
+            "package P {feature x;} package A {private import P::*;} package B; package Unrelated;",
+        );
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let u = r.resolve_qualified("Unrelated").unwrap().0;
+        let import = r.b.elements[a]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "Import"))
+            .unwrap();
+        (r, a, b, u, import)
+    }
+
+    #[test]
+    fn inverse_import_claims_localize_actual_and_claimed_owners() {
+        for key in [
+            "owningRelatedElement",
+            "importOwningNamespace",
+            "source",
+            "relatedElement",
+        ] {
+            let (mut r, a, b, u, import) = fixture();
+            let claim = serde_json::json!({"@id": r.b.elements[b].id.to_string()});
+            let value = match key {
+                "source" => serde_json::json!([claim]),
+                "relatedElement" => {
+                    let p = r.resolve_qualified("P").unwrap().0;
+                    serde_json::json!([claim, {"@id": r.b.elements[p].id.to_string()}])
+                }
+                _ => claim,
+            };
+            r.b.set(import, key, value);
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            let domains = raw.import_domains(&r.b, &mut 0).unwrap();
+            assert!(!domains.owner_complete(a), "{key}");
+            assert!(!domains.owner_complete(b), "{key}");
+            assert!(domains.owner_complete(u), "{key}");
+        }
+    }
+
+    #[test]
+    fn orphan_and_duplicate_import_carriers_do_not_hide_inverse_claims() {
+        for duplicate in [false, true] {
+            let (mut r, a, b, u, import) = fixture();
+            if duplicate {
+                r.b.elements[b].owned_relationships.push(import);
+            } else {
+                r.b.elements[a]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&rel| rel != import);
+            }
+            r.b.set(import, "isImplied", serde_json::json!(true));
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            let domains = raw.import_domains(&r.b, &mut 0).unwrap();
+            assert!(!domains.owner_complete(a));
+            assert_eq!(domains.owner_complete(b), !duplicate);
+            assert!(domains.owner_complete(u));
+        }
+    }
+
+    #[test]
+    fn unknown_import_owner_claims_block_absence_without_inventing_an_owner() {
+        for value in [
+            serde_json::json!({"@ref": "Missing"}),
+            serde_json::json!(false),
+        ] {
+            let (mut r, a, _, u, import) = fixture();
+            r.b.set(import, "importOwningNamespace", value);
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            let domains = raw.import_domains(&r.b, &mut 0).unwrap();
+            assert!(!domains.owner_complete(a));
+            assert!(!domains.owner_complete(u));
+        }
+    }
+
+    #[test]
+    fn import_domain_is_lazy_budgeted_shared_and_revision_bound() {
+        let (mut r, a, b, _, import) = fixture();
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(raw.imports.get().is_none());
+        assert!(
+            raw.import_domains(&r.b, &mut (crate::eval::MAX_STEPS - 1))
+                .is_none()
+        );
+        assert!(raw.imports.get().is_none());
+        let first = raw.import_domains(&r.b, &mut 0).unwrap();
+        assert!(first.owner_complete(a));
+        let mut warm = 0;
+        let second = raw.import_domains(&r.b, &mut warm).unwrap();
+        assert!(Arc::ptr_eq(&first, &second));
+        assert_eq!(warm, 1);
+        let id = r.b.elements[b].id;
+        r.b.set(
+            import,
+            "importOwningNamespace",
+            serde_json::json!({"@id": id.to_string()}),
+        );
+        assert!(raw.import_domains(&r.b, &mut 0).is_none());
+        let changed = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        let domains = changed.import_domains(&r.b, &mut 0).unwrap();
+        assert!(!domains.owner_complete(a));
+        assert!(!domains.owner_complete(b));
+        let id = r.b.elements[a].id;
+        r.b.set(
+            import,
+            "importOwningNamespace",
+            serde_json::json!({"@id": id.to_string()}),
+        );
+        let repaired = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(
+            repaired
+                .import_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(a)
+        );
+    }
+
+    #[test]
+    fn suffix_import_rows_cannot_escape_the_authored_domain_scan() {
+        let (mut r, a, _, u, import) = fixture();
+        r.b.implied_from = Some(import);
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(raw.has_import_rows());
+        let domains = raw.import_domains(&r.b, &mut 0).unwrap();
+        assert!(!domains.owner_complete(a));
+        assert!(domains.owner_complete(u));
+    }
+}
+
+#[cfg(test)]
+mod annotation_completeness_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    fn annotation_fixture() -> (ResolvedModel, usize, usize, usize) {
+        let mut model = Model::new();
+        let p = model.add_source(
+            "annotations.kerml",
+            "metaclass M; class A; class B; @M about A;",
+        );
+        assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let rel =
+            r.b.elements
+                .iter()
+                .position(|e| e.ty == "Annotation")
+                .unwrap();
+        (r, a, b, rel)
+    }
+    #[test]
+    fn valid_annotation_records_target_and_non_metadata_is_ignored_only_after_validation() {
+        let (mut r, a, _, rel) = annotation_fixture();
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!raw.annotations_incomplete);
+        assert!(raw.metadata_annotation_targets.contains(&a));
+        let source = raw.carrier(&r.b, rel).unwrap().unwrap();
+        r.b.elements[source].ty = "Documentation";
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!raw.annotations_incomplete);
+        assert!(raw.metadata_annotation_targets.is_empty());
+        let owner = r.b.elements[source].id;
+        let wrong_source = r.b.elements[a].id;
+        r.b.elements[rel].props.insert(
+            "source",
+            serde_json::json!([{"@id":wrong_source.to_string()}]),
+        );
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(
+            raw.annotations_incomplete,
+            "a corrupt nonmetadata source must not prove absence for another target"
+        );
+        r.b.elements[rel]
+            .props
+            .insert("source", serde_json::json!([{"@id":owner.to_string()}]));
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert!(!raw.annotations_incomplete);
+    }
+    #[test]
+    fn contradictory_annotation_target_has_global_uncertainty_and_repair_rebuilds() {
+        for key in ["target", "relatedElement", "owningRelatedElement"] {
+            let (mut r, a, b, rel) = annotation_fixture();
+            let old = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            let owner = old.carrier(&r.b, rel).unwrap().unwrap();
+            let value = match key {
+                "target" => serde_json::json!([{"@id":r.b.elements[b].id.to_string()}]),
+                "relatedElement" => {
+                    serde_json::json!([{"@id":r.b.elements[owner].id.to_string()},{"@id":r.b.elements[b].id.to_string()}])
+                }
+                _ => serde_json::json!({"@id":r.b.elements[b].id.to_string()}),
+            };
+            let original_props = r.b.elements[rel].props.clone();
+            r.b.elements[rel].props.insert(key, value);
+            let new = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(new.annotations_incomplete, "{key}");
+            assert!(!Arc::ptr_eq(&old, &new));
+            assert!(!new.metadata_annotation_targets.contains(&b));
+            r.b.elements[rel].props = original_props;
+            let repaired = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(!repaired.annotations_incomplete);
+            assert!(repaired.metadata_annotation_targets.contains(&a));
+        }
+    }
+
+    /// Start from actual lowered rows, then express the other normative ownership
+    /// shape: annotated A carries Annotation, which owns the annotating element.
+    fn owned_annotation_fixture(documentation: bool) -> (ResolvedModel, usize, usize, usize) {
+        let (mut r, target, _, rel) = annotation_fixture();
+        let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        let source = raw.carrier(&r.b, rel).unwrap().unwrap();
+        let old_membership = r.b.elements[source].owning_relationship.unwrap();
+        let source_id = r.b.elements[source].id;
+        let target_id = r.b.elements[target].id;
+        let rel_id = r.b.elements[rel].id;
+        // Retain a non-owning namespace membership for the source identity.
+        r.b.elements[old_membership].ty = "Membership";
+        r.b.elements[old_membership].children.make_mut().clear();
+        r.b.elements[old_membership].props = Default::default();
+        r.b.elements[old_membership].props.insert(
+            "memberElement",
+            serde_json::json!({"@id":source_id.to_string()}),
+        );
+        r.b.elements[source]
+            .owned_relationships
+            .make_mut()
+            .retain(|&r| r != rel);
+        r.b.elements[source].owning_relationship = Some(rel);
+        r.b.elements[source].props.insert(
+            "owningRelationship",
+            serde_json::json!({"@id":rel_id.to_string()}),
+        );
+        r.b.elements[target].owned_relationships.push(rel);
+        r.b.elements[rel].children = vec![source].into();
+        r.b.elements[rel].props = Default::default();
+        r.b.elements[rel].props.insert(
+            "annotatedElement",
+            serde_json::json!({"@id":target_id.to_string()}),
+        );
+        r.b.elements[rel].props.insert(
+            "annotatingElement",
+            serde_json::json!({"@id":source_id.to_string()}),
+        );
+        r.b.elements[rel].props.insert(
+            "ownedAnnotatingElement",
+            serde_json::json!({"@id":source_id.to_string()}),
+        );
+        r.b.elements[rel].props.insert(
+            "owningAnnotatedElement",
+            serde_json::json!({"@id":target_id.to_string()}),
+        );
+        r.b.elements[rel].props.insert(
+            "owningRelatedElement",
+            serde_json::json!({"@id":target_id.to_string()}),
+        );
+        r.b.elements[rel].props.insert(
+            "ownedRelatedElement",
+            serde_json::json!([{"@id":source_id.to_string()}]),
+        );
+        if documentation {
+            r.b.elements[source].ty = "Documentation";
+        }
+        (r, target, source, rel)
+    }
+
+    #[test]
+    fn target_owned_annotation_admits_metadata_and_valid_documentation_only() {
+        for documentation in [false, true] {
+            let (mut r, target, _, _) = owned_annotation_fixture(documentation);
+            let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(!raw.annotations_incomplete);
+            assert_eq!(
+                raw.metadata_annotation_targets.contains(&target),
+                !documentation
+            );
+        }
+    }
+
+    #[test]
+    fn owned_annotation_duplicate_children_and_missing_backlink_cannot_prove_absence() {
+        for duplicate in [false, true] {
+            // Even a Documentation source must be structurally valid before it is
+            // excluded from possible semantic metadata evidence.
+            let (mut r, _, source, rel) = owned_annotation_fixture(true);
+            if duplicate {
+                let id = r.b.elements[source].id;
+                r.b.elements[rel].children.push(source);
+                r.b.elements[rel].props.insert(
+                    "ownedRelatedElement",
+                    serde_json::json!([{"@id":id.to_string()}, {"@id":id.to_string()}]),
+                );
+            } else {
+                r.b.elements[source].owning_relationship = None;
+            }
+            let raw = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(raw.annotations_incomplete);
+        }
+    }
+
+    #[test]
+    fn owned_annotation_child_scalar_backlink_must_match_topology() {
+        let (mut r, target, source, rel) = owned_annotation_fixture(true);
+        let wrong = r.b.elements[target].id;
+        r.b.elements[source].props.insert(
+            "owningRelationship",
+            serde_json::json!({"@id":wrong.to_string()}),
+        );
+        assert!(
+            StoredStructure::get(&mut r.b, &mut 0)
+                .unwrap()
+                .annotations_incomplete
+        );
+        let correct = r.b.elements[rel].id;
+        r.b.elements[source].props.insert(
+            "owningRelationship",
+            serde_json::json!({"@id":correct.to_string()}),
+        );
+        assert!(
+            !StoredStructure::get(&mut r.b, &mut 0)
+                .unwrap()
+                .annotations_incomplete
+        );
+    }
+    #[test]
+    fn unresolved_nonmetadata_target_requires_complete_source_certificate() {
+        for key in [
+            "annotatingElement",
+            "owningAnnotatingElement",
+            "ownedAnnotatingElement",
+            "owningRelatedElement",
+            "source",
+            "relatedElement",
+            "ownedRelatedElement",
+        ] {
+            let (mut r, a, _, rel) = annotation_fixture();
+            let source = StoredStructure::get(&mut r.b, &mut 0)
+                .unwrap()
+                .carrier(&r.b, rel)
+                .unwrap()
+                .unwrap();
+            r.b.elements[source].ty = "Comment";
+            r.b.elements[rel]
+                .props
+                .insert("annotatedElement", serde_json::json!({"@ref":"Missing"}));
+            let good = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(!good.annotations_incomplete);
+            assert!(good.metadata_annotation_targets.is_empty());
+            let wrong = r.b.elements[a].id.to_string();
+            let value = match key {
+                "source" | "ownedRelatedElement" => serde_json::json!([{"@id":wrong}]),
+                "relatedElement" => serde_json::json!([{"@id":wrong},{"@ref":"Missing"}]),
+                _ => serde_json::json!({"@id":wrong}),
+            };
+            r.b.elements[rel].props.insert(key, value);
+            assert!(
+                StoredStructure::get(&mut r.b, &mut 0)
+                    .unwrap()
+                    .annotations_incomplete,
+                "{key}"
+            );
+        }
+    }
+    #[test]
+    fn unresolved_metadata_target_still_qualifies_every_candidate_target() {
+        let (mut r, _, _, rel) = annotation_fixture();
+        r.b.elements[rel]
+            .props
+            .insert("annotatedElement", serde_json::json!({"@ref":"Missing"}));
+        assert!(
+            StoredStructure::get(&mut r.b, &mut 0)
+                .unwrap()
+                .annotations_incomplete
+        );
+    }
+    #[test]
+    fn owned_documentation_source_can_be_certified_independently_of_target() {
+        for conflicting in [false, true] {
+            let (mut r, _, source, rel) = owned_annotation_fixture(true);
+            r.b.elements[rel]
+                .props
+                .insert("annotatedElement", serde_json::json!({"@ref":"Missing"}));
+            r.b.elements[rel].props.insert(
+                "owningAnnotatedElement",
+                serde_json::json!({"@ref":"Missing"}),
+            );
+            let old = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+            assert!(!old.annotations_incomplete);
+            if conflicting {
+                // A second possible metadata source must defeat the certificate.
+                let metadata =
+                    r.b.elements
+                        .iter()
+                        .position(|e| e.ty == "Metaclass")
+                        .unwrap();
+                r.b.elements[metadata].ty = "MetadataFeature";
+                let id = r.b.elements[metadata].id.to_string();
+                r.b.elements[rel]
+                    .props
+                    .insert("annotatingElement", serde_json::json!({"@id":id}));
+                assert!(
+                    StoredStructure::get(&mut r.b, &mut 0)
+                        .unwrap()
+                        .annotations_incomplete
+                );
+            } else {
+                r.b.elements[source].ty = "MetadataFeature";
+                let mut exhausted = crate::eval::MAX_STEPS;
+                assert!(StoredStructure::get(&mut r.b, &mut exhausted).is_none());
+                let new = StoredStructure::get(&mut r.b, &mut 0).unwrap();
+                assert!(!Arc::ptr_eq(&old, &new));
+                assert!(new.annotations_incomplete);
+            }
+        }
+    }
+}
+#[cfg(test)]
+mod typing_cache_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    #[test]
+    fn typing_projection_is_lazy_budgeted_shared_and_row_bound() {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("typing-cache.kerml", "class A; class B; feature x:A;")
+                .diagnostics
+                .is_empty()
+        );
+        let unrelated: String = (0..1_000).map(|i| format!("class Unrelated{i};")).collect();
+        assert!(
+            model
+                .add_source("unrelated.kerml", &unrelated)
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        let x = r.resolve_qualified("x").unwrap().0;
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let structure = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(structure.typing.get().is_none());
+        let mut before = 0;
+        StoredStructure::get(&mut r.b, &mut before).unwrap();
+        let mut exhausted = crate::eval::MAX_STEPS - 1;
+        assert!(structure.typing(&r.b, &mut exhausted).is_none());
+        assert!(
+            structure.typing.get().is_none(),
+            "failed construction must not publish"
+        );
+        let mut cold = 0;
+        let typing = structure.typing(&r.b, &mut cold).unwrap();
+        assert_eq!(cold, 1 + structure.typing_rows.len());
+        let rel = typing.relationships[&x][0];
+        let mut warm = 0;
+        assert!(Arc::ptr_eq(
+            &typing,
+            &structure.typing(&r.b, &mut warm).unwrap()
+        ));
+        assert_eq!(warm, 1);
+        let mut after = 0;
+        StoredStructure::get(&mut r.b, &mut after).unwrap();
+        assert_eq!(before, after, "legacy logical charge is unchanged");
+        let a_id = r.b.elements[a].id;
+        let b_id = r.b.elements[b].id;
+        assert_eq!(
+            r.b.elements[rel]
+                .props
+                .get("type")
+                .and_then(|v| v.as_reference()),
+            Some(a_id)
+        );
+        r.b.elements[rel]
+            .props
+            .insert("type", super::super::id_ref(b_id));
+        assert!(structure.typing(&r.b, &mut 0).is_none());
+        let rebuilt = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(!Arc::ptr_eq(&structure, &rebuilt));
+        assert!(rebuilt.typing.get().is_none());
+        assert!(!Arc::ptr_eq(
+            &typing,
+            &rebuilt.typing(&r.b, &mut 0).unwrap()
+        ));
+    }
+}
+
+#[cfg(test)]
+mod membership_domain_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    fn fixture() -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_source(
+            "memberships.kerml",
+            "function A {return a;} function B {return b;} function Unrelated {return u;}",
+        );
+        ResolvedModel::build(&model)
+    }
+    #[test]
+    fn every_inverse_owner_alias_localizes_a_lying_membership() {
+        for key in [
+            "owningRelatedElement",
+            "membershipOwningNamespace",
+            "owningType",
+            "source",
+            "relatedElement",
+        ] {
+            let mut r = fixture();
+            let a = r.resolve_qualified("A").unwrap().0;
+            let b = r.resolve_qualified("B").unwrap().0;
+            let u = r.resolve_qualified("Unrelated").unwrap().0;
+            let child = r.resolve_qualified("B::b").unwrap().0;
+            let membership = r.b.elements[child].owning_relationship.unwrap();
+            let value = serde_json::json!({"@id":r.b.elements[a].id.to_string()});
+            let value = if key == "source" {
+                serde_json::json!([value])
+            } else if key == "relatedElement" {
+                serde_json::json!([value,{"@id":r.b.elements[child].id.to_string()}])
+            } else {
+                value
+            };
+            r.b.set(membership, key, value);
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            let domains = raw.membership_domains(&r.b, &mut 0).unwrap();
+            assert!(!domains.owner_complete(a), "{key}");
+            assert!(!domains.owner_complete(b), "{key}");
+            assert!(domains.owner_complete(u), "{key}");
+        }
+    }
+    #[test]
+    fn inverse_child_aliases_and_unlisted_owning_type_are_not_ignored() {
+        for key in [
+            "owningRelationship",
+            "owningMembership",
+            "owningFeatureMembership",
+            "owningParameterMembership",
+            "owningType",
+        ] {
+            let mut r = fixture();
+            let a = r.resolve_qualified("A").unwrap().0;
+            let ar = r.resolve_qualified("A::a").unwrap().0;
+            let u = r.resolve_qualified("Unrelated").unwrap().0;
+            let child = r.resolve_qualified("B::b").unwrap().0;
+            let target = if key == "owningType" {
+                a
+            } else {
+                r.b.elements[ar].owning_relationship.unwrap()
+            };
+            let id = r.b.elements[target].id;
+            r.b.set(child, key, serde_json::json!({"@id":id.to_string()}));
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            let domains = raw.membership_domains(&r.b, &mut 0).unwrap();
+            assert!(!domains.owner_complete(a), "{key}");
+            assert!(domains.owner_complete(u), "{key}");
+        }
+    }
+    #[test]
+    fn unresolved_owner_claim_refuses_without_fabricating_an_owner() {
+        let mut r = fixture();
+        let a = r.resolve_qualified("A").unwrap().0;
+        let child = r.resolve_qualified("B::b").unwrap().0;
+        let membership = r.b.elements[child].owning_relationship.unwrap();
+        r.b.set(
+            membership,
+            "owningType",
+            serde_json::json!({"@ref":"Missing"}),
+        );
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(
+            !raw.membership_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(a)
+        );
+    }
+    #[test]
+    fn detached_features_do_not_hide_unknown_owning_type_claims() {
+        for value in [
+            serde_json::json!({"@ref":"Missing"}),
+            serde_json::json!({"@id":uuid::Uuid::new_v4().to_string()}),
+            serde_json::json!(false),
+        ] {
+            let mut r = fixture();
+            let a = r.resolve_qualified("A").unwrap().0;
+            let child = r.resolve_qualified("B::b").unwrap().0;
+            r.b.elements[child].owning_relationship = None;
+            r.b.set(child, "owningType", value);
+            let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+            assert!(
+                !raw.membership_domains(&r.b, &mut 0)
+                    .unwrap()
+                    .owner_complete(a)
+            );
+        }
+    }
+    #[test]
+    fn out_of_range_internal_child_backlink_is_unknown() {
+        let mut r = fixture();
+        let a = r.resolve_qualified("A").unwrap().0;
+        let child = r.resolve_qualified("B::b").unwrap().0;
+        r.b.elements[child].owning_relationship = Some(usize::MAX);
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(
+            !raw.membership_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(a)
+        );
+    }
+    #[test]
+    fn duplicate_membership_carriers_recover_all_owners_after_row_changes() {
+        let mut r = fixture();
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let unrelated = r.resolve_qualified("Unrelated").unwrap().0;
+        let child = r.resolve_qualified("B::b").unwrap().0;
+        let membership = r.b.elements[child].owning_relationship.unwrap();
+        let clean = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(!clean.multiple_membership_carriers);
+        assert!(
+            clean
+                .membership_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(a)
+        );
+        r.b.elements[a]
+            .owned_relationships
+            .make_mut()
+            .push(membership);
+        assert!(clean.membership_domains(&r.b, &mut 0).is_none());
+        let duplicate = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(duplicate.multiple_membership_carriers);
+        let domains = duplicate.membership_domains(&r.b, &mut 0).unwrap();
+        assert!(!domains.owner_complete(a));
+        assert!(!domains.owner_complete(b));
+        assert!(domains.owner_complete(unrelated));
+        r.b.elements[a]
+            .owned_relationships
+            .make_mut()
+            .retain(|&m| m != membership);
+        let repaired = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(!repaired.multiple_membership_carriers);
+        let domains = repaired.membership_domains(&r.b, &mut 0).unwrap();
+        assert!(domains.owner_complete(a));
+        assert!(domains.owner_complete(b));
+    }
+
+    #[test]
+    fn lazy_domain_budget_retry_cache_and_row_revision_are_shared() {
+        let mut r = fixture();
+        let a = r.resolve_qualified("A").unwrap().0;
+        let child = r.resolve_qualified("B::b").unwrap().0;
+        let membership = r.b.elements[child].owning_relationship.unwrap();
+        let raw = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(raw.memberships.get().is_none());
+        let mut exhausted = crate::eval::MAX_STEPS - 1;
+        assert!(raw.membership_domains(&r.b, &mut exhausted).is_none());
+        assert!(raw.memberships.get().is_none());
+        let first = raw.membership_domains(&r.b, &mut 0).unwrap();
+        let mut warm = 0;
+        let second = raw.membership_domains(&r.b, &mut warm).unwrap();
+        assert!(Arc::ptr_eq(&first, &second));
+        assert_eq!(warm, 1);
+        let id = r.b.elements[a].id;
+        r.b.set(
+            membership,
+            "owningType",
+            serde_json::json!({"@id":id.to_string()}),
+        );
+        assert!(raw.membership_domains(&r.b, &mut 0).is_none());
+        let fresh = StoredStructure::for_query(&mut r.b, &mut 0).unwrap();
+        assert!(
+            !fresh
+                .membership_domains(&r.b, &mut 0)
+                .unwrap()
+                .owner_complete(a)
+        );
+    }
+}
+
+#[cfg(test)]
+mod prefix_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model, prepared::PreparedLibrary};
+
+    const LIBRARY: &str = "metaclass M; class A { feature x; doc /* a */ } class B :> A; featuring A::x by B; @M about A;";
+    const USER: &str =
+        "package U { class C :> B; metaclass N; @N about A; @N about C; import A::*; }";
+
+    /// A model built on a prepared library whose freeze kept the scan of
+    /// its rows, with user rows that annotate, specialize and import them.
+    fn prepared_fixture() -> (Arc<PreparedLibrary>, ResolvedModel) {
+        let mut base = Model::new();
+        let parsed = base.add_library_source("lib.kerml", LIBRARY);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let library = base.prepare_library().unwrap();
+        assert!(
+            library.builder.prefix_structure.is_some(),
+            "the freeze keeps the scan"
+        );
+        let mut model = Model::new();
+        Arc::clone(&library).install(&mut model).unwrap();
+        let parsed = model.add_source("user.kerml", USER);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let r = ResolvedModel::build(&model);
+        assert!(r.b.library_facts.is_some(), "built on the prepared library");
+        (library, r)
+    }
+
+    /// The same builder as a table without reusable frozen rows: a frozen
+    /// row written with its own clone, which changes nothing but the fact.
+    fn force_whole(b: &mut Builder) {
+        let row = b.elements[0].clone();
+        b.elements[0] = row;
+        assert!(!b.elements.base_untouched());
+    }
+
+    /// The structure `b` scans whole, with the budget it charges.
+    fn scanned_whole(b: &mut Builder) -> (Arc<StoredStructure>, usize) {
+        b.stored_structure = None;
+        force_whole(b);
+        let mut steps = 0;
+        let whole = StoredStructure::get(b, &mut steps).unwrap();
+        (whole, steps)
+    }
+
+    /// Field by field: the structure built through a kept scan equals one
+    /// scanned whole.
+    fn assert_same(layered: &StoredStructure, whole: &StoredStructure) {
+        assert_eq!(layered.logical_work, whole.logical_work);
+        assert_eq!(layered.authored_end, whole.authored_end);
+        assert_eq!(layered.carriers, whole.carriers);
+        assert_eq!(*layered.ids, *whole.ids);
+        assert_eq!(layered.type_featurings, whole.type_featurings);
+        assert_eq!(layered.bad_chains, whole.bad_chains);
+        assert_eq!(layered.bad_bases, whole.bad_bases);
+        assert_eq!(layered.source_incomplete, whole.source_incomplete);
+        assert_eq!(layered.ids_unique, whole.ids_unique);
+        assert_eq!(layered.has_authored_import, whole.has_authored_import);
+        assert_eq!(layered.has_recursive_import, whole.has_recursive_import);
+        assert_eq!(layered.import_rows, whole.import_rows);
+        assert_eq!(
+            layered.metadata_annotation_targets,
+            whole.metadata_annotation_targets
+        );
+        assert_eq!(
+            layered.metadata_annotation_sources,
+            whole.metadata_annotation_sources
+        );
+        assert_eq!(layered.annotations_incomplete, whole.annotations_incomplete);
+        assert_eq!(
+            layered.multiple_membership_carriers,
+            whole.multiple_membership_carriers
+        );
+        assert_eq!(layered.membership_rows, whole.membership_rows);
+        assert_eq!(layered.typing_rows, whole.typing_rows);
+    }
+
+    /// A user row claiming a library relationship row — which no production
+    /// writer makes — would make the kept scan read that relationship as the
+    /// library's: the build scans whole, and the budget is a whole scan's.
+    #[test]
+    fn a_row_claiming_a_frozen_relationship_scans_whole() {
+        let (_, mut r) = prepared_fixture();
+        let base_len = r.b.elements.base_len();
+        let annotation = (0..base_len)
+            .find(|&i| r.b.elements[i].ty == "Annotation")
+            .unwrap();
+        let c = r.resolve_qualified("U::C").unwrap().0;
+        assert!(c >= base_len);
+        r.b.elements[c].owned_relationships.push(annotation);
+        assert!(r.b.elements.base_untouched(), "a tail write");
+        r.b.stored_structure = None;
+        let reuses = prefix_reuses();
+        let mut layered_steps = 0;
+        let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+        assert_eq!(prefix_reuses(), reuses, "the kept scan did not serve");
+        assert_eq!(layered.carriers[annotation], Carrier::Invalid);
+        assert!(layered.annotations_incomplete);
+
+        let (_, mut w) = prepared_fixture();
+        w.b.elements[c].owned_relationships.push(annotation);
+        let (whole, whole_steps) = scanned_whole(&mut w.b);
+        assert_eq!(layered_steps, whole_steps);
+        assert_same(&layered, &whole);
+    }
+
+    /// A user row carrying a library row's id — no production writer makes
+    /// one either — would make the kept scan resolve that id to the library
+    /// row where a whole scan resolves it to the last row: scanned whole.
+    #[test]
+    fn a_row_sharing_a_frozen_id_scans_whole() {
+        let (_, mut r) = prepared_fixture();
+        let base_len = r.b.elements.base_len();
+        let b_row = r.resolve_qualified("B").unwrap().0;
+        let c = r.resolve_qualified("U::C").unwrap().0;
+        assert!(b_row < base_len && c >= base_len);
+        r.b.elements[c].id = r.b.elements[b_row].id;
+        assert!(r.b.elements.base_untouched());
+        r.b.stored_structure = None;
+        let reuses = prefix_reuses();
+        let mut layered_steps = 0;
+        let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+        assert_eq!(prefix_reuses(), reuses, "the kept scan did not serve");
+        assert!(!layered.ids_unique);
+        assert_eq!(layered.ids.get(&r.b.elements[c].id), Some(&c));
+
+        let (_, mut w) = prepared_fixture();
+        w.b.elements[c].id = w.b.elements[b_row].id;
+        let (whole, whole_steps) = scanned_whole(&mut w.b);
+        assert_eq!(layered_steps, whole_steps);
+        assert_same(&layered, &whole);
+    }
+
+    /// A frozen relationship whose reference names an id no frozen row
+    /// carries — only a corrupt or hand-made library stores one — and a row
+    /// of the build carrying that id, which a whole scan would read as the
+    /// relationship's source: the build scans whole.
+    #[test]
+    fn a_row_carrying_an_id_a_frozen_reference_names_scans_whole() {
+        let fresh = Uuid::from_u128(0x0123_4567_89ab_cdef_0123_4567_89ab_cdef);
+        let build = || {
+            let mut base = Model::new();
+            let parsed = base.add_library_source("lib.kerml", LIBRARY);
+            assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+            let mut library = PreparedLibrary::build(&base).unwrap();
+            // the `featuring A::x by B` row: its source named by an id no row carries
+            let featuring = (0..library.builder.elements.len())
+                .find(|&i| library.builder.elements[i].ty == "TypeFeaturing")
+                .unwrap();
+            library.builder.set(
+                featuring,
+                "featureOfType",
+                serde_json::json!({ "@id": fresh.to_string() }),
+            );
+            library.builder.elements.freeze();
+            library.builder.prefix_structure = StoredStructure::prefix_of(&library.builder);
+            let kept = library.builder.prefix_structure.as_ref().unwrap();
+            assert!(kept.scanned.source_incomplete, "unsatisfied at the freeze");
+            assert!(kept.scanned.unsatisfied.contains(&fresh));
+            let library = Arc::new(library);
+            let mut model = Model::new();
+            library.install(&mut model).unwrap();
+            model.add_source("user.kerml", "package U { feature c; }");
+            let mut r = ResolvedModel::build(&model);
+            let c = r.resolve_qualified("U::c").unwrap().0;
+            assert!(c >= r.b.elements.base_len());
+            r.b.elements[c].id = fresh;
+            assert!(r.b.elements.base_untouched());
+            r.b.stored_structure = None;
+            (r, c)
+        };
+        let (mut r, c) = build();
+        let reuses = prefix_reuses();
+        let mut layered_steps = 0;
+        let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+        assert_eq!(prefix_reuses(), reuses, "the kept scan did not serve");
+        assert!(!layered.source_incomplete, "the build's row is the source");
+        assert_eq!(layered.type_featurings.get(&c).map(Vec::len), Some(1));
+
+        let (mut w, _) = build();
+        let (whole, whole_steps) = scanned_whole(&mut w.b);
+        assert_eq!(layered_steps, whole_steps);
+        assert_same(&layered, &whole);
+    }
+
+    /// A library annotation whose target never resolved stores a spelling,
+    /// not a reference: incomplete in the kept scan as in a whole one.
+    #[test]
+    fn a_dangling_library_annotation_target_is_incomplete_either_way() {
+        const DANGLING: &str = "metaclass M; class A; @M about Missing;";
+        const USER: &str = "package U { class C; }";
+        let build = || {
+            let mut base = Model::new();
+            base.add_library_source("lib.kerml", DANGLING);
+            let library = base.prepare_library().unwrap();
+            let kept = library.builder.prefix_structure.as_ref().unwrap();
+            assert!(kept.scanned.annotations_incomplete);
+            let mut model = Model::new();
+            Arc::clone(&library).install(&mut model).unwrap();
+            model.add_source("user.kerml", USER);
+            ResolvedModel::build(&model)
+        };
+        let mut r = build();
+        r.b.stored_structure = None;
+        let reuses = prefix_reuses();
+        let mut layered_steps = 0;
+        let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+        assert_eq!(prefix_reuses(), reuses + 1);
+        assert!(layered.annotations_incomplete);
+        let mut w = build();
+        let (whole, whole_steps) = scanned_whole(&mut w.b);
+        assert_eq!(layered_steps, whole_steps);
+        assert_same(&layered, &whole);
+    }
+
+    /// Implied rows are materialized past the frozen rows; a table whose
+    /// implied rows began within them would scan whole, and one whose
+    /// implied rows begin exactly at their end keeps the scan.
+    #[test]
+    fn implied_rows_within_the_frozen_rows_scan_whole() {
+        for (implied_from, served) in [(-1isize, 0usize), (0, 1)] {
+            let (_, mut r) = prepared_fixture();
+            let base_len = r.b.elements.base_len();
+            let from = (base_len as isize + implied_from) as usize;
+            r.b.implied_from = Some(from);
+            r.b.stored_structure = None;
+            let reuses = prefix_reuses();
+            let mut layered_steps = 0;
+            let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+            assert_eq!(prefix_reuses(), reuses + served);
+            let (_, mut w) = prepared_fixture();
+            w.b.implied_from = Some(from);
+            let (whole, whole_steps) = scanned_whole(&mut w.b);
+            assert_eq!(layered_steps, whole_steps);
+            assert_same(&layered, &whole);
+            assert_eq!(layered.authored_end, from);
+            assert!(
+                !layered.has_authored_import,
+                "the user import lies past the authored rows"
+            );
+        }
+    }
+
+    #[test]
+    fn frozen_rows_scan_once_and_the_structure_equals_a_whole_scan() {
+        let (library, mut r) = prepared_fixture();
+        let kept = r.b.prefix_structure.as_ref().unwrap();
+        assert!(
+            Arc::ptr_eq(kept, library.builder.prefix_structure.as_ref().unwrap()),
+            "a build on the library shares the scan its freeze kept"
+        );
+        let base_len = r.b.elements.base_len();
+        assert!(base_len > 0 && r.b.elements.base_untouched());
+        let reuses = prefix_reuses();
+        r.b.stored_structure = None;
+        let mut layered_steps = 0;
+        let layered = StoredStructure::get(&mut r.b, &mut layered_steps).unwrap();
+        assert_eq!(
+            prefix_reuses(),
+            reuses + 1,
+            "the kept scan served the frozen rows"
+        );
+
+        // The same builder with a frozen row written: scanned whole.
+        let (_, mut whole) = prepared_fixture();
+        whole.b.stored_structure = None;
+        let row = whole.b.elements[0].clone();
+        whole.b.elements[0] = row;
+        assert!(!whole.b.elements.base_untouched());
+        let reuses = prefix_reuses();
+        let mut whole_steps = 0;
+        let scanned = StoredStructure::get(&mut whole.b, &mut whole_steps).unwrap();
+        assert_eq!(
+            prefix_reuses(),
+            reuses,
+            "a written frozen row forces a whole scan"
+        );
+
+        assert_eq!(
+            layered_steps, whole_steps,
+            "the budget reads as if scanned whole"
+        );
+        assert_same(&layered, &scanned);
+
+        // The scan is not trivial: it reaches library and user rows alike.
+        let a = r.resolve_qualified("A").unwrap().0;
+        let c = r.resolve_qualified("U::C").unwrap().0;
+        assert!(a < base_len && c >= base_len);
+        assert!(
+            layered.metadata_annotation_targets.contains(&a),
+            "a library target"
+        );
+        assert!(
+            layered.metadata_annotation_targets.contains(&c),
+            "a user target"
+        );
+        assert_eq!(
+            layered.metadata_annotation_sources[&a].len(),
+            2,
+            "a library and a user source"
+        );
+        assert!(!layered.type_featurings.is_empty());
+        assert!(layered.has_authored_import);
+        assert!(layered.ids_unique && !layered.annotations_incomplete);
+    }
+
+    /// The scan is not serialized: decoding freezes the rows again, and
+    /// that freeze makes the scan the decoded library keeps.
+    #[test]
+    fn a_decoded_library_keeps_a_scan_of_its_own() {
+        let (library, _) = prepared_fixture();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&library.to_bytes(9).unwrap(), 9).unwrap());
+        let kept = decoded.builder.prefix_structure.clone();
+        assert!(kept.is_some(), "the decoded library's freeze kept a scan");
+        assert!(
+            !Arc::ptr_eq(
+                kept.as_ref().unwrap(),
+                library.builder.prefix_structure.as_ref().unwrap()
+            ),
+            "its own, not the encoded library's"
+        );
+        let mut model = Model::new();
+        decoded.install(&mut model).unwrap();
+        model.add_source("user.kerml", USER);
+        let reuses = prefix_reuses();
+        let mut r = ResolvedModel::build(&model);
+        assert!(r.b.library_facts.is_some());
+        assert!(prefix_reuses() > reuses, "the build reused the kept scan");
+        assert!(Arc::ptr_eq(
+            kept.as_ref().unwrap(),
+            r.b.prefix_structure.as_ref().unwrap()
+        ));
+        r.b.stored_structure = None;
+        let before = prefix_reuses();
+        StoredStructure::get(&mut r.b, &mut 0).unwrap();
+        assert_eq!(prefix_reuses(), before + 1);
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/succession_endpoints.rs b/crates/sysmlv2-model/src/json/succession_endpoints.rs
new file mode 100644
index 0000000..8eebb6a
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/succession_endpoints.rs
@@ -0,0 +1,251 @@
+//! Lexical succession endpoints, projected into the shared implied graph.
+use super::{Builder, membership_evidence, structural_index::StoredStructure};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, hash_map::Entry};
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+/// Missing shorthand ends are resolved from the ordered owning Memberships.
+/// No source rows are changed, and the static publisher owns the new identities.
+pub(super) fn endpoints(b: &mut Builder, steps: &mut usize) -> Option<Vec<(usize, usize)>> {
+    let limit = b.explicit_len();
+    // Gather the small succession slice once. Scanning the whole graph again
+    // after proving existence wastes the cold query's shared work allowance.
+    charge(steps, limit)?;
+    let mut successions = Vec::new();
+    for i in 0..limit {
+        if b.elements[i].ty == "SuccessionAsUsage" {
+            charge(steps, 1)?;
+            successions.push(i);
+        }
+    }
+    if successions.is_empty() {
+        return Some(Vec::new());
+    }
+    let raw = StoredStructure::for_query(b, steps)?;
+    let domains = raw.membership_domains(b, steps)?;
+    let inverse = raw.typing(b, steps)?;
+    if inverse.sources_incomplete {
+        return Some(Vec::new());
+    }
+    type Neighbors = HashMap<(usize, usize), (Option<usize>, Option<usize>)>;
+    let mut bodies: HashMap<usize, Neighbors> = HashMap::new();
+    let mut out = Vec::new();
+    for succession in successions {
+        charge(steps, 1)?;
+        let Some(membership) = b.elements[succession].owning_relationship else {
+            continue;
+        };
+        let Some(Some(owner)) = raw.carrier(b, membership) else {
+            continue;
+        };
+        if !domains.owner_complete(owner)
+            || membership_evidence::member(b, &raw, owner, membership, steps) != Some(succession)
+        {
+            continue;
+        }
+        // Transition-owned successions use the transition's explicit source.
+        // Implicit transition-source Membership establishment is a distinct rule.
+        let explicit_transition = b.elements[owner].ty == "TransitionUsage";
+        if let Entry::Vacant(entry) = bodies.entry(owner) {
+            let mut members = Vec::new();
+            let mut complete = true;
+            charge(steps, b.elements[owner].owned_relationships.len())?;
+            for &rel in &b.elements[owner].owned_relationships {
+                let Some(relation) = b.elements.get(rel) else {
+                    complete = false;
+                    break;
+                };
+                if !conforms(relation.ty, "Membership") {
+                    continue;
+                }
+                if let Some(member) = membership_evidence::member(b, &raw, owner, rel, steps) {
+                    members.push((rel, member));
+                } else {
+                    complete = false;
+                    break;
+                }
+            }
+            charge(steps, 0)?;
+            let mut neighbors = HashMap::new();
+            if complete {
+                // Compute lexical neighbors once per owning body. Repeated
+                // shorthand successions must not rescan the whole body.
+                charge(steps, members.len().saturating_mul(3))?;
+                // A chained transition source needs featureTarget evidence.
+                // Do not skip an uncertain earlier candidate to pick a later one.
+                let mut chained_source = false;
+                if explicit_transition {
+                    for &(rel, member) in &members {
+                        charge(steps, 1)?;
+                        if conforms(b.elements[rel].ty, "FeatureMembership")
+                            || !conforms(b.elements[member].ty, "Feature")
+                        {
+                            continue;
+                        }
+                        if super::type_relations::checked_feature_target(
+                            b,
+                            &raw,
+                            member,
+                            &b.elements[member].owned_relationships,
+                            limit,
+                            steps,
+                        ) != Some(None)
+                        {
+                            chained_source = true;
+                            break;
+                        }
+                    }
+                }
+                let transition_source = (explicit_transition && !chained_source)
+                    .then(|| {
+                        members.iter().find_map(|&(rel, member)| {
+                            (!conforms(b.elements[rel].ty, "FeatureMembership")
+                                && conforms(b.elements[member].ty, "ActionUsage"))
+                            .then_some(member)
+                        })
+                    })
+                    .flatten();
+                let occurrence = |rel: usize, member: usize| {
+                    conforms(b.elements[rel].ty, "FeatureMembership")
+                        && conforms(b.elements[member].ty, "OccurrenceUsage")
+                };
+                let mut previous = None;
+                for &(rel, member) in &members {
+                    neighbors.insert(
+                        (rel, member),
+                        (
+                            if explicit_transition {
+                                transition_source
+                            } else {
+                                previous
+                            },
+                            None,
+                        ),
+                    );
+                    if occurrence(rel, member) {
+                        previous = Some(member);
+                    }
+                }
+                let mut next = None;
+                for &(rel, member) in members.iter().rev() {
+                    neighbors.get_mut(&(rel, member)).expect("checked member").1 = next;
+                    if occurrence(rel, member) {
+                        next = Some(member);
+                    }
+                }
+            }
+            entry.insert(neighbors);
+        }
+        let Some(&(source, next)) = bodies[&owner].get(&(membership, succession)) else {
+            continue;
+        };
+        let target = b.elements[succession]
+            .path
+            .ends_with("emptySuccession")
+            .then_some(next)
+            .flatten();
+        let mut ends = Vec::new();
+        let mut complete = domains.owner_complete(succession);
+        charge(steps, b.elements[succession].owned_relationships.len())?;
+        for &rel in &b.elements[succession].owned_relationships {
+            let Some(relation) = b.elements.get(rel) else {
+                complete = false;
+                break;
+            };
+            if relation.ty != "EndFeatureMembership" {
+                continue;
+            }
+            if let Some(end) = membership_evidence::member(b, &raw, succession, rel, steps) {
+                ends.push(end);
+            } else {
+                complete = false;
+                break;
+            }
+        }
+        charge(steps, 0)?;
+        if !complete || ends.len() != 2 {
+            continue;
+        }
+        for (end, target) in ends.into_iter().zip([source, target]) {
+            let Some(target) = target else { continue };
+            charge(steps, b.elements[end].owned_relationships.len())?;
+            let incoming = inverse
+                .relationships
+                .get(&end)
+                .map(Vec::as_slice)
+                .unwrap_or_default();
+            charge(steps, incoming.len())?;
+            if incoming.iter().any(|&r| r < limit) {
+                continue;
+            }
+            // An unknown row or authored specialization prevents inventing
+            // a replacement endpoint, including an existing reference subset.
+            if b.elements[end].owned_relationships.iter().any(|&r| {
+                b.elements
+                    .get(r)
+                    .is_none_or(|r| conforms(r.ty, "Specialization"))
+            }) {
+                continue;
+            }
+            if conforms(b.elements[end].ty, "Feature") && end != target {
+                out.push((end, target));
+            }
+        }
+    }
+    Some(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    fn build(count: usize) -> ResolvedModel {
+        let mut source = String::from("action owner {");
+        for n in 0..count {
+            source.push_str(&format!("action a{n}; then a{n};"));
+        }
+        source.push('}');
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("successions.sysml", &source)
+                .diagnostics
+                .is_empty()
+        );
+        ResolvedModel::build(&model)
+    }
+    #[test]
+    fn lexical_projection_scales_linearly_and_budget_failure_is_retryable() {
+        let mut r = build(2000);
+        let mut steps = 0;
+        let edges = endpoints(&mut r.b, &mut steps).unwrap();
+        assert_eq!(edges.len(), 2000);
+        assert!(steps < 2_000_000, "{steps}");
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(endpoints(&mut r.b, &mut exhausted).is_none());
+        assert_eq!(endpoints(&mut r.b, &mut 0).unwrap(), edges);
+    }
+    #[test]
+    fn standalone_specialization_of_empty_source_prevents_inference() {
+        let mut r = build(1);
+        let edges = endpoints(&mut r.b, &mut 0).unwrap();
+        let (end, target) = edges[0];
+        let owner = r.b.new_element("Namespace", None, "extra".into());
+        let relation = r.b.new_relationship("ReferenceSubsetting", owner, "source");
+        r.b.set(
+            relation,
+            "subsettingFeature",
+            serde_json::json!({"@id": r.b.elements[end].id.to_string()}),
+        );
+        r.b.set(
+            relation,
+            "referencedFeature",
+            serde_json::json!({"@id": r.b.elements[target].id.to_string()}),
+        );
+        assert!(endpoints(&mut r.b, &mut 0).unwrap().is_empty());
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/supertypes_checked_tests.rs b/crates/sysmlv2-model/src/json/supertypes_checked_tests.rs
new file mode 100644
index 0000000..f75ae93
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/supertypes_checked_tests.rs
@@ -0,0 +1,236 @@
+use super::*;
+use crate::{json::ResolvedModel, model::Model};
+fn fixture(source: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    assert!(model.add_library_source("bases.kerml", "standard library package Base {classifier Anything; datatype DataValue specializes Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Objects {struct Object specializes Occurrences::Occurrence;}").diagnostics.is_empty());
+    assert!(
+        model
+            .add_source("supertypes.kerml", source)
+            .diagnostics
+            .is_empty()
+    );
+    ResolvedModel::build(&model)
+}
+#[test]
+fn explicit_supertypes_exclude_implied_and_validate_the_complete_owned_projection() {
+    let mut r = fixture(
+        "class A; class B; class C specializes A, B; class D conjugates C; class T {feature x;} feature p:T; feature q chains p.x;",
+    );
+    let a = r.resolve_qualified("A").unwrap().0;
+    let b = r.resolve_qualified("B").unwrap().0;
+    let c = r.resolve_qualified("C").unwrap().0;
+    let d = r.resolve_qualified("D").unwrap().0;
+    let q = r.resolve_qualified("q").unwrap().0;
+    let x = r.resolve_qualified("T::x").unwrap().0;
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        Some(vec![a, b])
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, d, &mut 0),
+        Some(vec![c])
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, q, &mut 0),
+        Some(vec![x])
+    );
+    let relations: Vec<_> = r.b.elements[c]
+        .owned_relationships
+        .iter()
+        .copied()
+        .filter(|&e| conforms(r.b.elements[e].ty, "Specialization"))
+        .collect();
+    r.b.set(relations[1], "isImplied", serde_json::json!(true));
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        Some(vec![a])
+    );
+    assert_eq!(
+        TypeRelations::default().specializes(&mut r.b, c, b, &mut 0),
+        RelationFact::Yes
+    );
+    r.b.set(
+        relations[0],
+        "target",
+        serde_json::json!([{"@id":r.b.elements[b].id.to_string()}]),
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        None
+    );
+}
+#[test]
+fn exact_supertypes_refuses_duplicate_projection_but_compatibility_keeps_positive_identity() {
+    let mut r = fixture("class A; class C specializes A, A;");
+    let a = r.resolve_qualified("A").unwrap().0;
+    let c = r.resolve_qualified("C").unwrap().0;
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        None
+    );
+    assert_eq!(
+        TypeRelations::default().specializes(&mut r.b, c, a, &mut 0),
+        RelationFact::Yes
+    );
+    let mut steps = crate::eval::MAX_STEPS;
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut steps),
+        None
+    );
+    assert!(steps > crate::eval::MAX_STEPS);
+}
+#[test]
+fn feature_target_is_one_hop_and_self_is_not_appended() {
+    let mut r = fixture(
+        "feature a; feature b chains a; feature q chains b; feature same chains same; feature repeated subsets a chains a;",
+    );
+    let b = r.resolve_qualified("b").unwrap().0;
+    let q = r.resolve_qualified("q").unwrap().0;
+    let same = r.resolve_qualified("same").unwrap().0;
+    let repeated = r.resolve_qualified("repeated").unwrap().0;
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, q, &mut 0),
+        Some(vec![b])
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, same, &mut 0),
+        Some(vec![])
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, repeated, &mut 0),
+        None,
+        "duplicate append stays outside checked domain"
+    );
+}
+#[test]
+fn conjugation_and_feature_target_are_not_filtered_as_implied_specializations() {
+    let mut r = fixture(
+        "feature original; feature chainEnd; feature c conjugates original chains chainEnd;",
+    );
+    let c = r.resolve_qualified("c").unwrap().0;
+    let original = r.resolve_qualified("original").unwrap().0;
+    let chain = r.resolve_qualified("chainEnd").unwrap().0;
+    let relations = r.b.elements[c].owned_relationships.to_vec();
+    for &rel in &relations {
+        if conforms(r.b.elements[rel].ty, "Conjugation")
+            || conforms(r.b.elements[rel].ty, "FeatureChaining")
+        {
+            r.b.elements[rel]
+                .props
+                .insert("isImplied", serde_json::json!(true));
+        }
+    }
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        Some(vec![original, chain])
+    );
+    let last = *relations
+        .iter()
+        .find(|&&rel| conforms(r.b.elements[rel].ty, "FeatureChaining"))
+        .unwrap();
+    let wrong = r.b.elements[original].id;
+    r.b.elements[last]
+        .props
+        .insert("target", serde_json::json!([{"@id":wrong.to_string()}]));
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        None,
+        "last link cannot hide behind conjugation"
+    );
+}
+#[test]
+fn explicit_projection_uses_shared_semantic_ownership_after_materialization() {
+    use crate::json::{ClosurePolicy, Derived, DerivedValue, ElementRef};
+    let mut r = fixture("class A; class C specializes A; feature x; feature v=x;");
+    let a = r.resolve_qualified("A").unwrap().0;
+    let c = r.resolve_qualified("C").unwrap().0;
+    let v = r.resolve_qualified("v").unwrap();
+    let expression = r.members_via(v, "FeatureValue")[0];
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        Some(vec![a])
+    );
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let result = match r.derived(expression, "result") {
+        Derived::Value(DerivedValue::Element(result)) => result,
+        other => panic!("expected generated result: {other:?}"),
+    };
+    assert!(result.0 >= r.b.explicit_len());
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, c, &mut 0),
+        Some(vec![a])
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, result.0, &mut 0),
+        Some(vec![])
+    );
+    assert!(
+        r.implied_relationships(ElementRef(c))
+            .iter()
+            .all(|rel| r.is_implied(*rel))
+    );
+    let subsetting = r.b.elements[result.0].owned_relationships[0];
+    let wrong = r.b.elements[a].id;
+    r.b.elements[subsetting].props.insert(
+        "owningRelatedElement",
+        serde_json::json!({"@id":wrong.to_string()}),
+    );
+    assert_eq!(
+        TypeRelations::default().explicit_supertypes(&mut r.b, result.0, &mut 0),
+        None,
+        "excluded implied edge still requires certified ownership"
+    );
+}
+
+#[test]
+fn conjugated_supertypes_ignore_flag_but_preserve_complete_feature_append_and_limits() {
+    use crate::json::{DerivedValue, OperationError};
+    let mut r = fixture(
+        "feature original; feature chainSource {feature chainEnd;} feature c conjugates original chains chainSource.chainEnd; class A; class B conjugates A; class C conjugates B;",
+    );
+    let original = r.resolve_qualified("original").unwrap();
+    let last = r.resolve_qualified("chainSource::chainEnd").unwrap();
+    let c = r.resolve_qualified("c").unwrap();
+    let b = r.resolve_qualified("B").unwrap();
+    let capital_c = r.resolve_qualified("C").unwrap();
+    let declaration = "Core-Types-Type-supertypes_Boolean";
+    for value in [false, true] {
+        let out = r
+            .invoke_operation(c, declaration, &[DerivedValue::Bool(value)])
+            .unwrap();
+        assert_eq!(out.effective, "Core-Features-Feature-supertypes_Boolean");
+        assert_eq!(
+            out.value,
+            DerivedValue::References(vec![
+                super::super::Reference::Element(original),
+                super::super::Reference::Element(last)
+            ])
+        );
+        assert_eq!(
+            TypeRelations::default().checked_supertypes(&mut r.b, capital_c.0, value, &mut 0),
+            Ok(vec![b.0])
+        );
+    }
+    let mut steps = crate::eval::MAX_STEPS;
+    assert_eq!(
+        TypeRelations::default().checked_supertypes(&mut r.b, c.0, false, &mut steps),
+        Err(SupertypesFailure::Incomplete)
+    );
+    assert!(steps > crate::eval::MAX_STEPS);
+    let rel = r.b.elements[c.0]
+        .owned_relationships
+        .iter()
+        .copied()
+        .find(|&rel| conforms(r.b.elements[rel].ty, "Conjugation"))
+        .unwrap();
+    r.b.elements[rel].props.insert(
+        "originalType",
+        serde_json::json!({"@id":uuid::Uuid::new_v4().to_string()}),
+    );
+    assert!(matches!(
+        r.invoke_operation(c, declaration, &[DerivedValue::Bool(false)]),
+        Err(OperationError::Incomplete { .. })
+    ));
+}
diff --git a/crates/sysmlv2-model/src/json/type_features.rs b/crates/sysmlv2-model/src/json/type_features.rs
new file mode 100644
index 0000000..75a9094
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_features.rs
@@ -0,0 +1,564 @@
+//! Ordered Type projections over the shared checked Membership provider.
+use super::{
+    ElementRef, ResolvedModel, TypeInputIssue, membership_evidence,
+    membership_projection::Membership, semantic::certified_types::Stamp,
+    structural_index::StoredStructure, type_relations::TypeRelations,
+};
+use crate::metaclass::conforms;
+use std::collections::HashSet;
+
+/// Complete projections for supported ordinary Types. These values
+/// prove the selected membership domain, not whole-model validity. All vectors
+/// preserve semantic order and are unique by element or relationship identity.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct TypeFeatures {
+    pub owned_memberships: Vec<ElementRef>,
+    pub inherited_memberships: Vec<ElementRef>,
+    pub owned_feature_memberships: Vec<ElementRef>,
+    pub feature_memberships: Vec<ElementRef>,
+    pub features: Vec<ElementRef>,
+    pub inherited_features: Vec<ElementRef>,
+    pub inputs: Vec<ElementRef>,
+    pub outputs: Vec<ElementRef>,
+    pub directed_features: Vec<ElementRef>,
+    pub end_features: Vec<ElementRef>,
+    /// Root imports require a separate collision-pruned membership projection.
+    /// The feature components remain usable when their visibility-specific
+    /// inherited import contributions have complete shared evidence.
+    pub memberships: Result<Vec<ElementRef>, TypeInputIssue>,
+    pub members: Result<Vec<ElementRef>, TypeInputIssue>,
+}
+/// Complete ordered Type projections or an explicit qualification.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct TypeFeatureReport {
+    pub projections: Result<TypeFeatures, TypeInputIssue>,
+    pub steps: usize,
+}
+pub(super) struct MembershipSequence {
+    pub owned: Vec<Membership>,
+    pub inherited: Vec<Membership>,
+    // Only populated by the operation projection, keeping ordinary query work unchanged.
+    pub inheritable: Vec<Membership>,
+    pub non_private: Vec<Membership>,
+    pub root_import: bool,
+    pub required_positional: std::collections::HashMap<usize, Vec<usize>>,
+}
+pub(super) fn supported_root(ty: &str) -> bool {
+    matches!(
+        ty,
+        "Type"
+            | "Feature"
+            | "Classifier"
+            | "Class"
+            | "Structure"
+            | "DataType"
+            | "Behavior"
+            | "Function"
+            | "Definition"
+            | "AttributeDefinition"
+            | "OccurrenceDefinition"
+            | "ItemDefinition"
+            | "PartDefinition"
+    )
+}
+fn charge(steps: &mut usize, n: usize) -> Result<(), TypeInputIssue> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(TypeInputIssue::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+impl ResolvedModel {
+    /// Prove feature and membership projections for ordinary Kernel Types and
+    /// nonindividual, nonvariation Definition, AttributeDefinition,
+    /// OccurrenceDefinition, ItemDefinition and PartDefinition receivers.
+    /// Required library roles, complete ancestry and inverse ownership are checked.
+    /// Public/protected leaf-package imports share the central positional proof.
+    /// Conjugation, broader import dependencies and contextual subclasses stay qualified.
+    /// No relationships are published and compatibility projections are unchanged.
+    pub fn type_feature_report(&mut self, receiver: ElementRef) -> TypeFeatureReport {
+        self.type_feature_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn type_feature_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> TypeFeatureReport {
+        let mut steps = initial;
+        let mut projections = self.checked_type_features(receiver.0, &mut steps);
+        if steps > crate::eval::MAX_STEPS {
+            projections = Err(TypeInputIssue::WorkLimit);
+        }
+        TypeFeatureReport { projections, steps }
+    }
+    pub(super) fn checked_type_features(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+    ) -> Result<TypeFeatures, TypeInputIssue> {
+        self.b.checked_type_features(receiver, steps)
+    }
+}
+
+impl super::Builder {
+    pub(super) fn checked_type_features(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+    ) -> Result<TypeFeatures, TypeInputIssue> {
+        self.checked_type_features_with_relations(receiver, steps, &mut TypeRelations::default())
+    }
+    pub(super) fn checked_type_features_with_relations(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        relations: &mut TypeRelations,
+    ) -> Result<TypeFeatures, TypeInputIssue> {
+        let sequence = self.checked_type_memberships_with_relations(receiver, steps, relations)?;
+        let raw =
+            StoredStructure::for_query(self, steps).ok_or(TypeInputIssue::IncompleteProvider)?;
+        let stamp = Stamp::capture_builder(self);
+        charge(
+            steps,
+            sequence
+                .owned
+                .len()
+                .saturating_add(sequence.inherited.len())
+                .saturating_mul(12),
+        )?;
+        let owned_memberships = sequence
+            .owned
+            .iter()
+            .map(|m| ElementRef(m.relationship))
+            .collect();
+        let inherited_memberships = sequence
+            .inherited
+            .iter()
+            .map(|m| ElementRef(m.relationship))
+            .collect();
+        let mut owned_feature_memberships = Vec::new();
+        let mut feature_memberships = Vec::new();
+        let mut features = Vec::new();
+        let mut inherited_features = Vec::new();
+        let mut inputs = Vec::new();
+        let mut outputs = Vec::new();
+        let mut directed_features = Vec::new();
+        let mut end_features = Vec::new();
+        let mut seen_relationships = HashSet::new();
+        let mut seen_features = HashSet::new();
+        let mut seen_inherited = HashSet::new();
+        for (inherited, membership) in sequence
+            .owned
+            .iter()
+            .map(|m| (false, m))
+            .chain(sequence.inherited.iter().map(|m| (true, m)))
+        {
+            if !conforms(
+                self.elements[membership.relationship].ty,
+                "FeatureMembership",
+            ) {
+                continue;
+            }
+            if !inherited {
+                owned_feature_memberships.push(ElementRef(membership.relationship));
+            }
+            if seen_relationships.insert(membership.relationship) {
+                feature_memberships.push(ElementRef(membership.relationship));
+            }
+            let feature = ElementRef(membership.member);
+            if inherited && seen_inherited.insert(feature) {
+                inherited_features.push(feature);
+            }
+            if !seen_features.insert(feature) {
+                continue;
+            }
+            features.push(feature);
+            let direction = membership_evidence::parameter_direction(self, &raw, feature.0, steps)
+                .ok_or(TypeInputIssue::InvalidRelationship)?;
+            if matches!(direction, Some("in" | "inout")) {
+                inputs.push(feature);
+            }
+            if matches!(direction, Some("out" | "inout")) {
+                outputs.push(feature);
+            }
+            if direction.is_some() {
+                directed_features.push(feature);
+            }
+            // The provider already shape-checked every contributing isEnd.
+            if self.elements[feature.0]
+                .props
+                .get("isEnd")
+                .and_then(|v| v.as_bool())
+                == Some(true)
+            {
+                end_features.push(feature);
+            }
+        }
+        let (memberships, members) = if sequence.root_import {
+            (
+                Err(TypeInputIssue::UnsupportedConfiguration),
+                Err(TypeInputIssue::UnsupportedConfiguration),
+            )
+        } else {
+            let mut seen_memberships = HashSet::new();
+            let mut seen_members = HashSet::new();
+            let mut memberships = Vec::new();
+            let mut members = Vec::new();
+            for m in sequence.owned.iter().chain(&sequence.inherited) {
+                if seen_memberships.insert(m.relationship) {
+                    memberships.push(ElementRef(m.relationship));
+                }
+                if seen_members.insert(m.member) {
+                    members.push(ElementRef(m.member));
+                }
+            }
+            (Ok(memberships), Ok(members))
+        };
+        if !stamp.current_builder(self) {
+            return Err(TypeInputIssue::StaleEvidence);
+        }
+        Ok(TypeFeatures {
+            owned_memberships,
+            inherited_memberships,
+            owned_feature_memberships,
+            feature_memberships,
+            features,
+            inherited_features,
+            inputs,
+            outputs,
+            directed_features,
+            end_features,
+            memberships,
+            members,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ClosurePolicy, PropertyError},
+        model::{GraphFormat, Model},
+    };
+    use serde_json::json;
+    const LIB: &str = "standard library package Base { classifier Anything; datatype DataValue specializes Anything; feature things:Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things; } standard library package Objects { struct Object specializes Occurrences::Occurrence; } standard library package Performances { behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance { return result; } step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; }";
+    fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+        let mut m = Model::with_graph_format(format);
+        assert!(
+            m.add_library_source("types-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let unit = m.add_source("types.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&m)
+    }
+    fn refs(r: &mut ResolvedModel, names: &[&str]) -> Vec<ElementRef> {
+        names
+            .iter()
+            .map(|name| r.resolve_qualified(name).unwrap())
+            .collect()
+    }
+    fn complete(r: &mut ResolvedModel, name: &str) -> TypeFeatures {
+        let e = r.resolve_qualified(name).unwrap();
+        r.type_feature_report(e).projections.unwrap()
+    }
+    fn full(r: &mut ResolvedModel) {
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+    }
+
+    #[test]
+    fn shared_relation_evidence_preserves_features_and_refuses_changed_rows() {
+        let mut r = fixture(
+            "class A {feature a;} class B specializes A {feature b;}",
+            GraphFormat::CanonicalV3,
+        );
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        let expected_a = r.type_feature_report(a).projections.unwrap();
+        let expected_b = r.type_feature_report(b).projections.unwrap();
+        let mut relations = TypeRelations::default();
+        let mut steps = 0;
+        assert_eq!(
+            r.b.checked_type_features_with_relations(a.0, &mut steps, &mut relations),
+            Ok(expected_a)
+        );
+        assert_eq!(
+            r.b.checked_type_features_with_relations(b.0, &mut steps, &mut relations),
+            Ok(expected_b.clone())
+        );
+        let feature = r.resolve_qualified("B::b").unwrap();
+        r.b.elements[feature.0]
+            .props
+            .insert("direction", json!("in"));
+        assert!(
+            r.b.checked_type_features_with_relations(b.0, &mut steps, &mut relations)
+                .is_err()
+        );
+        let refreshed = r.type_feature_report(b).projections.unwrap();
+        assert_eq!(refreshed.features, expected_b.features);
+        assert_eq!(refreshed.inputs, [feature]);
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(relations.reset_with_budget(&mut exhausted).is_none());
+        relations.reset_with_budget(&mut 0).unwrap();
+        assert_eq!(
+            r.b.checked_type_features_with_relations(b.0, &mut 0, &mut relations),
+            Ok(refreshed)
+        );
+    }
+
+    #[test]
+    fn every_plain_root_requires_canonical_bases_and_preserves_default_projections() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            for keyword in [
+                "type",
+                "classifier",
+                "class",
+                "struct",
+                "datatype",
+                "behavior",
+                "function",
+            ] {
+                let source = format!("{keyword} A {{in feature x; out feature y;}}");
+                let mut r = fixture(&source, format);
+                let a = r.resolve_qualified("A").unwrap();
+                let old = r.derived(a, "feature");
+                let count = r.b.elements.len();
+                let p = r.type_feature_report(a).projections.unwrap();
+                assert_eq!(p.inputs, refs(&mut r, &["A::x"]), "{keyword}");
+                assert!(p.outputs.contains(&refs(&mut r, &["A::y"])[0]));
+                assert_eq!(r.b.elements.len(), count);
+                assert_eq!(r.derived(a, "feature"), old);
+                full(&mut r);
+                assert!(r.property(a, "feature").is_ok());
+                assert!(r.property(a, "output").is_ok());
+                if keyword != "function" {
+                    assert_eq!(
+                        r.function_result_report(a).result,
+                        Err(TypeInputIssue::UnsupportedConfiguration)
+                    );
+                }
+                let mut no_library = Model::with_graph_format(format);
+                no_library.add_source("types.kerml", &source);
+                let mut r = ResolvedModel::build(&no_library);
+                let a = r.resolve_qualified("A").unwrap();
+                assert!(r.type_feature_report(a).projections.is_err(), "{keyword}");
+            }
+        }
+    }
+    #[test]
+    fn owned_private_and_inherited_memberships_keep_separate_ordered_domains() {
+        let mut r = fixture(
+            "class A { private feature hidden; protected feature guarded; in feature a; out feature b; end feature edge; feature plain; class Nested; } class B specializes A { private inout feature own; feature local; }",
+            GraphFormat::LegacyV2,
+        );
+        let p = complete(&mut r, "B");
+        assert_eq!(
+            p.features,
+            refs(
+                &mut r,
+                &[
+                    "B::own",
+                    "B::local",
+                    "A::a",
+                    "A::b",
+                    "A::edge",
+                    "A::plain",
+                    "A::guarded"
+                ]
+            )
+        );
+        assert_eq!(p.inputs, refs(&mut r, &["B::own", "A::a"]));
+        assert_eq!(p.outputs, refs(&mut r, &["B::own", "A::b"]));
+        assert_eq!(
+            p.directed_features,
+            refs(&mut r, &["B::own", "A::a", "A::b"])
+        );
+        assert_eq!(p.end_features, refs(&mut r, &["A::edge"]));
+        assert_eq!(p.inherited_features, p.features[2..]);
+        assert_eq!(p.feature_memberships.len(), p.features.len());
+        assert_eq!(p.owned_memberships.len(), 2);
+        assert_eq!(p.inherited_memberships.len(), 6);
+        assert!(
+            p.members
+                .as_ref()
+                .unwrap()
+                .contains(&refs(&mut r, &["A::Nested"])[0])
+        );
+        assert!(
+            !p.members
+                .as_ref()
+                .unwrap()
+                .contains(&refs(&mut r, &["A::hidden"])[0])
+        );
+        let a = complete(&mut r, "A");
+        assert!(a.features.contains(&refs(&mut r, &["A::hidden"])[0]));
+    }
+    #[test]
+    fn private_import_qualifies_only_the_receivers_all_membership_component() {
+        let mut r = fixture(
+            "package P {class T;} class A { private import P::*; in feature x; } class B specializes A;",
+            GraphFormat::LegacyV2,
+        );
+        let a = complete(&mut r, "A");
+        assert_eq!(a.inputs, refs(&mut r, &["A::x"]));
+        assert!(a.memberships.is_err());
+        assert!(a.members.is_err());
+        let b = complete(&mut r, "B");
+        assert!(b.memberships.is_ok());
+        assert_eq!(b.inputs, a.inputs);
+        full(&mut r);
+        let a = r.resolve_qualified("A").unwrap();
+        assert!(r.property(a, "input").is_ok());
+        assert!(matches!(
+            r.property(a, "membership"),
+            Err(PropertyError::IncompleteTypeFeatures(_))
+        ));
+        let b = r.resolve_qualified("B").unwrap();
+        assert!(r.property(b, "membership").is_ok());
+    }
+    #[test]
+    fn aliases_are_memberships_without_becoming_feature_slots() {
+        let mut r = fixture(
+            "class A {feature x; alias other for x;} class B specializes A;",
+            GraphFormat::LegacyV2,
+        );
+        let a = complete(&mut r, "A");
+        assert_eq!(a.features, refs(&mut r, &["A::x"]));
+        assert_eq!(a.memberships.unwrap().len(), 2);
+        assert_eq!(a.members.unwrap().len(), 1);
+        let b = complete(&mut r, "B");
+        // The shared inherited-membership filter suppresses competing aliases
+        // of the same Feature by its reflexive redefinition closure.
+        assert!(b.feature_memberships.is_empty());
+        assert!(b.features.is_empty());
+    }
+    #[test]
+    fn malformed_suppressed_features_and_inverse_domains_refuse_complete_reports() {
+        for field in ["direction", "isEnd"] {
+            let mut r = fixture(
+                "class A {in feature x;} class B specializes A {in feature y redefines x;}",
+                GraphFormat::LegacyV2,
+            );
+            let b = r.resolve_qualified("B").unwrap();
+            assert!(r.type_feature_report(b).projections.is_ok());
+            let x = r.resolve_qualified("A::x").unwrap();
+            r.b.set(x.0, field, json!(false));
+            if field == "isEnd" {
+                r.b.set(x.0, field, json!("bad"));
+            }
+            assert!(r.type_feature_report(b).projections.is_err());
+        }
+        let mut r = fixture(
+            "class A {feature x;} class B specializes A;",
+            GraphFormat::CanonicalV3,
+        );
+        let b = r.resolve_qualified("B").unwrap();
+        assert!(r.type_feature_report(b).projections.is_ok());
+        let a = r.resolve_qualified("A").unwrap();
+        r.b.elements[a.0].owned_relationships = Vec::new().into();
+        assert!(r.type_feature_report(b).projections.is_err());
+    }
+    #[test]
+    fn diamond_preserves_membership_identity_and_own_then_inherited_order() {
+        let mut r = fixture(
+            "class A {in feature a; class Nested;} class B specializes A {feature b;} class C specializes A {feature c;} class D specializes B, C {private feature d;}",
+            GraphFormat::CanonicalV3,
+        );
+        let p = complete(&mut r, "D");
+        assert_eq!(p.features, refs(&mut r, &["D::d", "B::b", "A::a", "C::c"]));
+        assert_eq!(p.inherited_features, p.features[1..]);
+        assert_eq!(p.inputs, refs(&mut r, &["A::a"]));
+        assert_eq!(p.feature_memberships.len(), 4);
+        assert_eq!(p.inherited_memberships.len(), 4);
+        assert_eq!(p.owned_memberships.len(), 1);
+        let expected_members = refs(&mut r, &["D::d", "B::b", "A::a", "A::Nested", "C::c"]);
+        assert_eq!(p.members, Ok(expected_members));
+        let inherited: HashSet<_> = p.inherited_memberships.iter().collect();
+        assert_eq!(inherited.len(), p.inherited_memberships.len());
+        let root = r.resolve_qualified("D").unwrap();
+        full(&mut r);
+        for (property, expected) in [
+            ("featureMembership", p.feature_memberships),
+            ("inheritedMembership", p.inherited_memberships),
+            ("membership", p.memberships.unwrap()),
+        ] {
+            assert_eq!(
+                r.property(root, property).unwrap(),
+                json!(
+                    expected
+                        .iter()
+                        .map(|&e| json!({"@id":r.element_id(e)}))
+                        .collect::<Vec<_>>()
+                ),
+                "{property}"
+            );
+        }
+    }
+
+    #[test]
+    fn empty_complete_root_does_not_widen_to_contextual_subclasses() {
+        let mut r = fixture("class Empty;", GraphFormat::LegacyV2);
+        let e = r.resolve_qualified("Empty").unwrap();
+        let complete = r.type_feature_report(e).projections.unwrap();
+        assert!(complete.features.is_empty());
+        assert_eq!(complete.memberships, Ok(vec![]));
+        assert_eq!(complete.members, Ok(vec![]));
+        // An ordinary unfeatured Feature now has the same complete empty
+        // namespace projection. The same-ID kind edit must revalidate it.
+        r.b.elements[e.0].ty = "Feature";
+        assert_eq!(r.type_feature_report(e).projections, Ok(complete));
+        for kind in ["Association", "Expression", "PartUsage", "Predicate"] {
+            r.b.elements[e.0].ty = kind;
+            assert_eq!(
+                r.type_feature_report(e).projections,
+                Err(TypeInputIssue::UnsupportedConfiguration),
+                "{kind}"
+            );
+        }
+        assert_eq!(
+            r.type_feature_report(ElementRef(usize::MAX)).projections,
+            Err(TypeInputIssue::InvalidElement)
+        );
+    }
+
+    #[test]
+    fn directions_end_flags_and_budget_are_current_and_retryable() {
+        let mut r = fixture(
+            "class A {out feature x; in feature y; feature z;}",
+            GraphFormat::CanonicalV3,
+        );
+        let a = r.resolve_qualified("A").unwrap();
+        let x = r.resolve_qualified("A::x").unwrap();
+        let y = r.resolve_qualified("A::y").unwrap();
+        let before = r.b.elements.len();
+        let p = r.type_feature_report(a).projections.unwrap();
+        assert_eq!(p.features[..2], [x, y]);
+        r.b.set(x.0, "direction", json!("inout"));
+        r.b.set(x.0, "isEnd", json!(true));
+        let p = r.type_feature_report(a).projections.unwrap();
+        assert_eq!(p.inputs, [x, y]);
+        assert_eq!(p.outputs, [x]);
+        assert_eq!(p.end_features, [x]);
+        assert_eq!(
+            r.type_feature_report_with_budget(a, crate::eval::MAX_STEPS)
+                .projections,
+            Err(TypeInputIssue::WorkLimit)
+        );
+        assert!(r.type_feature_report(a).projections.is_ok());
+        assert_eq!(r.b.elements.len(), before);
+        full(&mut r);
+        assert_eq!(
+            r.property(a, "input"),
+            Ok(json!([{"@id":r.element_id(x)},{"@id":r.element_id(y)}]))
+        );
+        r.set_closure_policy(ClosurePolicy::Passthrough);
+        assert_eq!(r.property(a, "feature"), Err(PropertyError::Approximate));
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/type_inputs.rs b/crates/sysmlv2-model/src/json/type_inputs.rs
new file mode 100644
index 0000000..5847549
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_inputs.rs
@@ -0,0 +1,1686 @@
+//! Complete ordered input evidence over the shared Membership reduction.
+//! Compatibility projections and dynamic relationship publication are independent.
+use super::{
+    Builder, ElementRef, ResolvedModel, membership_evidence,
+    membership_projection::{Membership, MembershipFacts, Node, Reachability, Reduction},
+    semantic::certified_types::Stamp,
+    semantic_ownership,
+    structural_index::StoredStructure,
+    type_relations::{self, TypeRelations},
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+/// Why a complete ordered Type projection could not be certified. Errors never mean
+/// an empty input list. Additional supported domains may be added over time.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum TypeInputIssue {
+    InvalidElement,
+    InvalidRelationship,
+    IncompleteProvider,
+    UnsupportedConfiguration,
+    CyclicDependency,
+    StaleEvidence,
+    WorkLimit,
+}
+/// Complete ordered inputs or an explicit qualification, with bounded query work.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct TypeInputReport {
+    pub inputs: Result<Vec<ElementRef>, TypeInputIssue>,
+    pub steps: usize,
+}
+/// Complete ordinary Function result selection, or an explicit qualification.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct FunctionResultReport {
+    pub result: Result<Option<ElementRef>, TypeInputIssue>,
+    pub steps: usize,
+}
+fn charge(steps: &mut usize, n: usize) -> Result<(), TypeInputIssue> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(TypeInputIssue::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+fn relationships(
+    b: &Builder,
+    owner: usize,
+    steps: &mut usize,
+) -> Result<Vec<usize>, TypeInputIssue> {
+    let rows = semantic_ownership::owned_relationships(b, owner)
+        .ok_or(TypeInputIssue::InvalidRelationship)?;
+    charge(steps, rows.len())?;
+    let rows: Vec<_> = rows.iter().collect();
+    let mut seen = HashSet::new();
+    if rows.iter().any(|r| !seen.insert(*r)) {
+        return Err(TypeInputIssue::InvalidRelationship);
+    }
+    Ok(rows)
+}
+
+/// A structural owner's ordinary member has no end, parameter, subject, result
+/// or state-subaction positional role. Its subclass's internal features need
+/// their own certificates, but do not change this member's redefinition list.
+fn ordinary_usage_member(
+    b: &Builder,
+    raw: &StoredStructure,
+    feature: usize,
+    steps: &mut usize,
+) -> bool {
+    let row = &b.elements[feature];
+    if !matches!(
+        row.ty,
+        "PortUsage"
+            | "ActionUsage"
+            | "StateUsage"
+            | "ConstraintUsage"
+            | "ConnectionUsage"
+            | "InterfaceUsage"
+            | "AllocationUsage"
+            | "FlowUsage"
+            | "SuccessionAsUsage"
+    ) || row.props.get("direction").is_some_and(|v| !v.is_null())
+        || row
+            .props
+            .get("isEnd")
+            .is_some_and(|v| v.as_bool() != Some(false))
+    {
+        return false;
+    }
+    let Some(membership) = row.owning_relationship else {
+        return false;
+    };
+    if b.elements[membership].ty != "FeatureMembership" {
+        return false;
+    }
+    // The main proof checks reciprocal ownership and complete ancestry below.
+    // No assumption is made about features in an action/state/usage body.
+    let Some(Some(owner)) =
+        semantic_ownership::checked_relationship_carrier(b, raw, membership, steps)
+    else {
+        return false;
+    };
+    matches!(
+        b.elements[owner].ty,
+        "Type"
+            | "Classifier"
+            | "Class"
+            | "Structure"
+            | "DataType"
+            | "Definition"
+            | "AttributeDefinition"
+            | "OccurrenceDefinition"
+            | "ItemDefinition"
+            | "PartDefinition"
+    )
+}
+struct Facts<'a>(&'a Builder);
+impl MembershipFacts for Facts<'_> {
+    fn is_feature(&self, e: usize) -> bool {
+        conforms(self.0.elements[e].ty, "Feature")
+    }
+    fn is_feature_membership(&self, r: usize) -> bool {
+        conforms(self.0.elements[r].ty, "FeatureMembership")
+    }
+    fn is_protected(&self, r: usize) -> bool {
+        self.0.elements[r]
+            .props
+            .get("visibility")
+            .and_then(|v| v.as_str())
+            == Some("protected")
+    }
+}
+/// Every dependency is visited once; active marks distinguish cycles from diamonds.
+fn order(
+    graph: &HashMap<usize, Vec<usize>>,
+    steps: &mut usize,
+) -> Result<Vec<usize>, TypeInputIssue> {
+    let mut state = HashMap::new();
+    let mut ordered = Vec::new();
+    for &root in graph.keys() {
+        let mut todo = vec![(root, false)];
+        while let Some((e, exit)) = todo.pop() {
+            charge(steps, 1)?;
+            if exit {
+                state.insert(e, 2);
+                ordered.push(e);
+                continue;
+            }
+            match state.get(&e) {
+                Some(1) => return Err(TypeInputIssue::CyclicDependency),
+                Some(2) => continue,
+                _ => {}
+            }
+            state.insert(e, 1);
+            todo.push((e, true));
+            let next = graph.get(&e).ok_or(TypeInputIssue::IncompleteProvider)?;
+            charge(steps, next.len())?;
+            todo.extend(next.iter().rev().map(|&n| (n, false)));
+        }
+    }
+    Ok(ordered)
+}
+impl ResolvedModel {
+    /// Certify Type.input for supported ordinary Types with complete ancestry,
+    /// reciprocal memberships and nonconjugated directions. Public/protected
+    /// package imports require exact central positional selector agreement;
+    /// Contextual types and unsupported required families remain qualified.
+    /// This does not validate the whole Function or change compatibility reads,
+    /// evaluate it, or publish Invocation edges.
+    pub fn type_input_report(&mut self, receiver: ElementRef) -> TypeInputReport {
+        self.type_input_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn type_input_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> TypeInputReport {
+        let mut steps = initial;
+        let mut inputs = self.checked_inputs(receiver.0, &mut steps);
+        if steps > crate::eval::MAX_STEPS {
+            inputs = Err(TypeInputIssue::WorkLimit);
+        }
+        TypeInputReport { inputs, steps }
+    }
+    fn checked_inputs(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+    ) -> Result<Vec<ElementRef>, TypeInputIssue> {
+        Ok(self.checked_type_features(receiver, steps)?.inputs)
+    }
+
+    /// Select the first effective ReturnParameterMembership of an ordinary
+    /// Function. Absence is reported only for a complete supported provider.
+    /// This does not certify uniqueness or validity of the Function as a whole.
+    pub fn function_result_report(&mut self, receiver: ElementRef) -> FunctionResultReport {
+        self.function_result_report_with_budget(receiver, 0)
+    }
+    pub(in crate::json) fn function_result_report_with_budget(
+        &mut self,
+        receiver: ElementRef,
+        initial: usize,
+    ) -> FunctionResultReport {
+        let mut steps = initial;
+        let result = if self.b.elements.get(receiver.0).is_none() {
+            Err(TypeInputIssue::InvalidElement)
+        } else if self.b.elements[receiver.0].ty != "Function" {
+            Err(TypeInputIssue::UnsupportedConfiguration)
+        } else {
+            self.checked_type_features(receiver.0, &mut steps)
+                .and_then(|sequence| {
+                    let features = sequence.features;
+                    charge(&mut steps, features.len())?;
+                    Ok(features.into_iter().find(|f| {
+                        self.b.elements[f.0].owning_relationship.is_some_and(|m| {
+                            conforms(self.b.elements[m].ty, "ReturnParameterMembership")
+                        })
+                    }))
+                })
+        };
+        FunctionResultReport {
+            result: if steps > crate::eval::MAX_STEPS {
+                Err(TypeInputIssue::WorkLimit)
+            } else {
+                result
+            },
+            steps,
+        }
+    }
+}
+
+impl super::Builder {
+    pub(super) fn checked_type_memberships(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+    ) -> Result<super::type_features::MembershipSequence, TypeInputIssue> {
+        self.checked_type_memberships_with_relations(receiver, steps, &mut TypeRelations::default())
+    }
+    /// Reuse only the shared relation evidence within one caller-guarded query.
+    /// Membership reduction and positional verification remain per receiver.
+    pub(super) fn checked_type_memberships_with_relations(
+        &mut self,
+        receiver: usize,
+        steps: &mut usize,
+        relations: &mut TypeRelations,
+    ) -> Result<super::type_features::MembershipSequence, TypeInputIssue> {
+        self.checked_type_memberships_filtered(receiver, false, &[], None, steps, relations)
+    }
+    /// Select imports and ancestry only after certifying the complete provider.
+    pub(super) fn checked_type_membership_operation(
+        &mut self,
+        receiver: usize,
+        excluded_namespaces: &[usize],
+        excluded_types: &[usize],
+        exclude_implied: bool,
+        steps: &mut usize,
+    ) -> Result<super::type_features::MembershipSequence, TypeInputIssue> {
+        self.checked_type_memberships_filtered(
+            receiver,
+            exclude_implied,
+            excluded_namespaces,
+            Some(excluded_types),
+            steps,
+            &mut TypeRelations::default(),
+        )
+    }
+    pub(super) fn checked_type_memberships_for_visibility(
+        &mut self,
+        receiver: usize,
+        excluded_namespaces: &[usize],
+        exclude_implied: bool,
+        steps: &mut usize,
+    ) -> Result<super::type_features::MembershipSequence, TypeInputIssue> {
+        self.checked_type_memberships_filtered(
+            receiver,
+            exclude_implied,
+            excluded_namespaces,
+            None,
+            steps,
+            &mut TypeRelations::default(),
+        )
+    }
+    fn checked_type_memberships_filtered(
+        &mut self,
+        receiver: usize,
+        exclude_implied: bool,
+        excluded_namespaces: &[usize],
+        excluded_types: Option<&[usize]>,
+        steps: &mut usize,
+        relations: &mut TypeRelations,
+    ) -> Result<super::type_features::MembershipSequence, TypeInputIssue> {
+        charge(steps, 1)?;
+        let row = self
+            .elements
+            .get(receiver)
+            .ok_or(TypeInputIssue::InvalidElement)?;
+        if !super::type_features::supported_root(row.ty) || self.positional_planning {
+            return Err(TypeInputIssue::UnsupportedConfiguration);
+        }
+        if !self.ensure_positional_redefinitions_with_budget(steps) {
+            return Err(TypeInputIssue::IncompleteProvider);
+        }
+        let retained = self
+            .retained_typing_edges(steps)
+            .ok_or(TypeInputIssue::IncompleteProvider)?;
+        let raw =
+            StoredStructure::for_query(self, steps).ok_or(TypeInputIssue::IncompleteProvider)?;
+        if !raw.ids_unique || raw.annotations_incomplete || self.metadata_associations_incomplete {
+            return Err(TypeInputIssue::IncompleteProvider);
+        }
+        let domains = raw
+            .membership_domains(self, steps)
+            .ok_or(TypeInputIssue::IncompleteProvider)?;
+        let imports = raw
+            .import_domains(self, steps)
+            .ok_or(TypeInputIssue::IncompleteProvider)?;
+        let inverse = raw
+            .typing(self, steps)
+            .ok_or(TypeInputIssue::IncompleteProvider)?;
+        if inverse.sources_incomplete {
+            return Err(TypeInputIssue::IncompleteProvider);
+        }
+        let stamp = Stamp::capture_builder(self);
+        let b = &mut *self;
+        let mut nodes = HashMap::new();
+        let mut bases = HashMap::new();
+        let mut features = Vec::new();
+        let mut owned_memberships = Vec::new();
+        let mut root_import = false;
+        let mut visible_import_owners = HashSet::new();
+        let mut imported_features = HashSet::new();
+        let mut todo = vec![receiver];
+        while let Some(owner) = todo.pop() {
+            charge(steps, 1)?;
+            if nodes.contains_key(&owner) {
+                continue;
+            }
+            let element = b
+                .elements
+                .get(owner)
+                .ok_or(TypeInputIssue::InvalidElement)?;
+            if !super::type_features::supported_root(element.ty) || owner >= b.explicit_len() {
+                return Err(TypeInputIssue::UnsupportedConfiguration);
+            }
+            if element.ty == "Feature"
+                && (element
+                    .props
+                    .get("isEnd")
+                    .is_some_and(|v| v.as_bool() != Some(false))
+                    || element.props.get("direction").is_some_and(|v| !v.is_null()))
+            {
+                return Err(TypeInputIssue::UnsupportedConfiguration);
+            }
+            if !domains.owner_complete(owner)
+                || !imports.owner_complete(owner)
+                || raw.metadata_annotation_targets.contains(&owner)
+                || b.metadata_of.get(&owner).is_some_and(|m| !m.is_empty())
+            {
+                return Err(TypeInputIssue::IncompleteProvider);
+            }
+            if relations
+                .owned_conjugation(b, owner, steps)
+                .ok_or(TypeInputIssue::IncompleteProvider)?
+                .is_some()
+            {
+                return Err(TypeInputIssue::UnsupportedConfiguration);
+            }
+            let direct = relations
+                .complete_direct_bases(b, owner, steps)
+                .ok_or(TypeInputIssue::IncompleteProvider)?;
+            charge(steps, direct.len().saturating_mul(2))?;
+            todo.extend(direct.iter().copied());
+            bases.insert(owner, direct.clone());
+            let mut node = Node {
+                owned: Vec::new(),
+                owned_memberships: Vec::new(),
+                bases: direct,
+                public_imports: Vec::new(),
+                protected_imports: Vec::new(),
+                memberships_complete: true,
+            };
+            for rel in relationships(b, owner, steps)? {
+                charge(steps, 1)?;
+                if semantic_ownership::checked_relationship_carrier(b, &raw, rel, steps)
+                    != Some(Some(owner))
+                {
+                    return Err(TypeInputIssue::InvalidRelationship);
+                }
+                if conforms(b.elements[rel].ty, "Import") {
+                    super::import_memberships::checked_import_target(b, &raw, owner, rel, steps)
+                        .ok_or(TypeInputIssue::InvalidRelationship)?;
+                    if b.elements[rel]
+                        .props
+                        .get("visibility")
+                        .is_some_and(|v| v.as_str() != Some("private"))
+                    {
+                        visible_import_owners.insert(owner);
+                    }
+                    root_import |= owner == receiver;
+                }
+                let row = &b.elements[rel];
+                if !conforms(row.ty, "Membership") {
+                    continue;
+                }
+                let member = membership_evidence::member(b, &raw, owner, rel, steps)
+                    .ok_or(TypeInputIssue::InvalidRelationship)?;
+                let visibility = match row.props.get("visibility") {
+                    None => "public",
+                    Some(v) => v
+                        .as_str()
+                        .filter(|s| matches!(*s, "public" | "protected" | "private"))
+                        .ok_or(TypeInputIssue::InvalidRelationship)?,
+                };
+                let membership = Membership {
+                    relationship: rel,
+                    member,
+                };
+                if owner == receiver {
+                    owned_memberships.push(membership);
+                }
+                if conforms(row.ty, "FeatureMembership") {
+                    if !conforms(b.elements[member].ty, "Feature") {
+                        return Err(TypeInputIssue::InvalidRelationship);
+                    }
+                    node.owned.push(member);
+                }
+                if conforms(b.elements[member].ty, "Feature") {
+                    features.push(member);
+                }
+                if visibility != "private" {
+                    node.owned_memberships.push(membership);
+                }
+            }
+            if visible_import_owners.contains(&owner) {
+                let (public, protected) = super::operations::namespaces::imports::type_imports(
+                    b,
+                    &raw,
+                    owner,
+                    &[],
+                    steps,
+                )
+                .map_err(|_| TypeInputIssue::IncompleteProvider)?;
+                charge(steps, public.len().saturating_add(protected.len()))?;
+                for membership in public.iter().chain(&protected) {
+                    if conforms(b.elements[membership.member].ty, "Feature") {
+                        features.push(membership.member);
+                        imported_features.insert(membership.member);
+                        // External owning Types are proof dependencies, never extra
+                        // bases or inheritance contributions of the receiver.
+                        if let Some(declaring) = relations
+                            .owning_type(b, membership.member, steps)
+                            .ok_or(TypeInputIssue::IncompleteProvider)?
+                        {
+                            todo.push(declaring);
+                        }
+                    }
+                }
+                node.public_imports = public;
+                node.protected_imports = protected;
+            }
+            nodes.insert(owner, node);
+        }
+        let ordered = order(&bases, steps)?;
+        let mut redefinitions = HashMap::new();
+        let mut authored = HashMap::new();
+        let mut feature_owners = HashMap::new();
+        while let Some(feature) = features.pop() {
+            charge(steps, 1)?;
+            if redefinitions.contains_key(&feature) {
+                continue;
+            }
+            let row = b
+                .elements
+                .get(feature)
+                .ok_or(TypeInputIssue::InvalidElement)?;
+            if !conforms(row.ty, "Feature")
+                || (conforms(row.ty, "Usage")
+                    && !ordinary_usage_member(b, &raw, feature, steps)
+                    && !matches!(
+                        row.ty,
+                        "ReferenceUsage"
+                            | "AttributeUsage"
+                            | "OccurrenceUsage"
+                            | "ItemUsage"
+                            | "PartUsage"
+                    ))
+                || conforms(row.ty, "InvocationExpression")
+                || raw.bad_bases.contains(&feature)
+                || raw.metadata_annotation_targets.contains(&feature)
+                || b.metadata_of.get(&feature).is_some_and(|m| !m.is_empty())
+                || !b.dynamic_evidence_current(feature)
+                || !b.result_redefinition_evidence_current(feature)
+            {
+                return Err(TypeInputIssue::IncompleteProvider);
+            }
+            if relations
+                .owned_conjugation(b, feature, steps)
+                .ok_or(TypeInputIssue::IncompleteProvider)?
+                .is_some()
+            {
+                return Err(TypeInputIssue::UnsupportedConfiguration);
+            }
+            let owning_type = relations
+                .owning_type(b, feature, steps)
+                .ok_or(TypeInputIssue::IncompleteProvider)?;
+            let owner = match owning_type {
+                Some(owner) => {
+                    if membership_evidence::parameter_direction(b, &raw, feature, steps).is_none() {
+                        return Err(TypeInputIssue::InvalidRelationship);
+                    }
+                    owner
+                }
+                None if imported_features.contains(&feature)
+                    && b.elements[feature].ty == "Feature" =>
+                {
+                    let membership = b.elements[feature]
+                        .owning_relationship
+                        .filter(|&m| b.elements[m].ty == "OwningMembership")
+                        .ok_or(TypeInputIssue::IncompleteProvider)?;
+                    let owner = semantic_ownership::checked_relationship_carrier(
+                        b, &raw, membership, steps,
+                    )
+                    .flatten()
+                    .ok_or(TypeInputIssue::InvalidRelationship)?;
+                    if !matches!(
+                        b.elements[owner].ty,
+                        "Namespace" | "Package" | "LibraryPackage"
+                    ) || membership_evidence::member(b, &raw, owner, membership, steps)
+                        != Some(feature)
+                        || b.elements[feature]
+                            .props
+                            .get("direction")
+                            .is_some_and(|v| !v.is_null())
+                        || ["isEnd", "isPortion", "isComposite", "isVariable"]
+                            .iter()
+                            .any(|key| {
+                                b.elements[feature]
+                                    .props
+                                    .get(key)
+                                    .is_some_and(|v| v.as_bool() != Some(false))
+                            })
+                        || raw.metadata_annotation_targets.contains(&owner)
+                        || b.metadata_of.get(&owner).is_some_and(|m| !m.is_empty())
+                    {
+                        return Err(TypeInputIssue::UnsupportedConfiguration);
+                    }
+                    owner
+                }
+                None if matches!(b.elements[feature].ty, "Multiplicity" | "MultiplicityRange") => {
+                    // A named multiplicity can be an ordinary owned member of a
+                    // Type without being one of its features. It still participates
+                    // in Membership redefinition reduction, using the same complete
+                    // inverse ownership evidence. Directed or end multiplicities
+                    // require a separate FeatureMembership/positional certificate.
+                    let membership = b.elements[feature]
+                        .owning_relationship
+                        .filter(|&m| b.elements[m].ty == "OwningMembership")
+                        .ok_or(TypeInputIssue::IncompleteProvider)?;
+                    let owner = semantic_ownership::checked_relationship_carrier(
+                        b, &raw, membership, steps,
+                    )
+                    .flatten()
+                    .ok_or(TypeInputIssue::InvalidRelationship)?;
+                    if membership_evidence::member(b, &raw, owner, membership, steps)
+                        != Some(feature)
+                        || b.elements[feature]
+                            .props
+                            .get("direction")
+                            .is_some_and(|v| !v.is_null())
+                        || b.elements[feature]
+                            .props
+                            .get("isEnd")
+                            .is_some_and(|v| v.as_bool() != Some(false))
+                    {
+                        return Err(TypeInputIssue::InvalidRelationship);
+                    }
+                    owner
+                }
+                None => return Err(TypeInputIssue::IncompleteProvider),
+            };
+            if !visible_import_owners.is_empty() {
+                charge(steps, 1)?;
+                feature_owners.insert(feature, owner);
+            }
+            if !nodes.contains_key(&owner) && !imported_features.contains(&feature) {
+                return Err(TypeInputIssue::IncompleteProvider);
+            }
+            if !domains.owner_complete(owner)
+                || b.elements[feature]
+                    .props
+                    .get("isEnd")
+                    .is_some_and(|v| v.as_bool().is_none())
+            {
+                return Err(TypeInputIssue::InvalidRelationship);
+            }
+            let owned = relationships(b, feature, steps)?;
+            let mut actual = HashSet::new();
+            let mut targets = Vec::new();
+            let mut authored_targets = Vec::new();
+            for rel in owned.into_iter().chain(
+                inverse
+                    .relationships
+                    .get(&feature)
+                    .into_iter()
+                    .flatten()
+                    .copied(),
+            ) {
+                charge(steps, 1)?;
+                if !conforms(b.elements[rel].ty, "Redefinition") || !actual.insert(rel) {
+                    continue;
+                }
+                if !b.static_chain_row_current(rel) || !b.result_redefinition_row_current(rel) {
+                    return Err(TypeInputIssue::StaleEvidence);
+                }
+                let carrier = semantic_ownership::checked_relationship_carrier(b, &raw, rel, steps)
+                    .ok_or(TypeInputIssue::InvalidRelationship)?;
+                // The shared reducer uses one redefinition closure. Until its
+                // inverse-only and owned roles are distinct, qualify standalone
+                // Redefinitions rather than treating them as owned closure edges.
+                if carrier != Some(feature) {
+                    return Err(TypeInputIssue::UnsupportedConfiguration);
+                }
+                let target = type_relations::endpoint_with_carrier(
+                    b,
+                    feature,
+                    carrier,
+                    rel,
+                    &["specific", "subsettingFeature", "redefiningFeature"],
+                    &["general", "subsettedFeature", "redefinedFeature"],
+                    "Feature",
+                    steps,
+                )
+                .ok_or(TypeInputIssue::InvalidRelationship)?;
+                targets.push(target);
+                if rel < b.explicit_len() {
+                    authored_targets.push(target);
+                }
+            }
+            let implied = retained.get(&feature).map_or(&[][..], Vec::as_slice);
+            charge(steps, implied.len())?;
+            for &(kind, id) in implied {
+                if conforms(kind, "Redefinition") {
+                    targets.push(
+                        raw.element_for_uuid(b, id)
+                            .ok_or(TypeInputIssue::IncompleteProvider)?,
+                    );
+                }
+            }
+            authored.insert(feature, authored_targets);
+            charge(steps, targets.len().saturating_mul(2))?;
+            let mut seen = HashSet::new();
+            targets.retain(|t| seen.insert(*t));
+            features.extend(targets.iter().copied());
+            redefinitions.insert(feature, targets);
+        }
+        if b.positional_redefinition_sources_match(&authored, steps) != Some(true) {
+            return Err(TypeInputIssue::StaleEvidence);
+        }
+        // A proof-only foreign owner is not ordered before the importing Type
+        // by the positional planner's ancestry traversal. Its generated edges
+        // can change inherited suppression even through an alias Membership.
+        // Legacy retains that planner, so require actual ancestry. Canonical
+        // planning certifies and schedules the supported foreign prerequisites
+        // below using these same complete source/owner proof nodes.
+        if b.graph_format == crate::model::GraphFormat::LegacyV2
+            && !visible_import_owners.is_empty()
+        {
+            let mut closure = Reachability::sparse();
+            let mut ancestry = Reachability::sparse();
+            for &owner in &visible_import_owners {
+                let node = &nodes[&owner];
+                charge(
+                    steps,
+                    node.public_imports
+                        .len()
+                        .saturating_add(node.protected_imports.len()),
+                )?;
+                for membership in node.public_imports.iter().chain(&node.protected_imports) {
+                    if !conforms(b.elements[membership.member].ty, "Feature") {
+                        continue;
+                    }
+                    let reached = closure
+                        .reachable_budget(membership.member, &redefinitions, &mut Some(steps))
+                        .ok_or(TypeInputIssue::WorkLimit)?;
+                    charge(steps, reached.len())?;
+                    for &feature in reached {
+                        if b.elements[feature]
+                            .props
+                            .get("isEnd")
+                            .and_then(|v| v.as_bool())
+                            != Some(true)
+                            && !b.is_parameter(feature)
+                        {
+                            continue;
+                        }
+                        let declaring = *feature_owners
+                            .get(&feature)
+                            .ok_or(TypeInputIssue::IncompleteProvider)?;
+                        if !ancestry
+                            .reaches_budget(owner, declaring, &bases, &mut Some(steps))
+                            .ok_or(TypeInputIssue::WorkLimit)?
+                        {
+                            return Err(TypeInputIssue::IncompleteProvider);
+                        }
+                    }
+                }
+            }
+        }
+        let positional = b
+            .plan_checked_positional(&nodes, &bases, &visible_import_owners, steps)
+            .ok_or(TypeInputIssue::IncompleteProvider)?;
+        charge(steps, nodes.len())?;
+        if nodes
+            .keys()
+            .any(|owner| positional.incomplete.contains(owner))
+        {
+            return Err(TypeInputIssue::IncompleteProvider);
+        }
+        let required_positional = positional.targets;
+        for (&feature, targets) in &required_positional {
+            charge(steps, targets.len().saturating_add(1))?;
+            if targets
+                .iter()
+                .any(|target| !redefinitions.contains_key(target))
+            {
+                return Err(TypeInputIssue::IncompleteProvider);
+            }
+            redefinitions
+                .get_mut(&feature)
+                .ok_or(TypeInputIssue::IncompleteProvider)?
+                .extend(targets.iter().copied());
+        }
+        order(&redefinitions, steps)?;
+        // Excluding implied supertypes changes only inheritance selection.
+        // Redefinition suppression still uses the complete semantic certificate.
+        let ordered = if exclude_implied {
+            let mut explicit_bases = HashMap::new();
+            for (&owner, node) in &mut nodes {
+                charge(steps, 1)?;
+                let direct = relations
+                    .checked_supertypes(b, owner, true, steps)
+                    .map_err(|_| TypeInputIssue::IncompleteProvider)?;
+                charge(steps, direct.len())?;
+                if direct.iter().any(|target| !bases.contains_key(target)) {
+                    return Err(TypeInputIssue::IncompleteProvider);
+                }
+                node.bases = direct.clone();
+                explicit_bases.insert(owner, direct);
+            }
+            order(&explicit_bases, steps)?
+        } else {
+            ordered
+        };
+        // Selection exclusions must not hide incomplete ancestry, malformed
+        // redefinitions, or positional evidence. The full certificate above is
+        // established before changing any contributing edge. Cycles remain
+        // qualified, so path-specific excludingSelf adds no additional cuts.
+        if let Some(excluded) = excluded_types {
+            charge(steps, excluded.len())?;
+            let excluded: HashSet<_> = excluded.iter().copied().collect();
+            for node in nodes.values_mut() {
+                charge(steps, node.bases.len())?;
+                node.bases.retain(|base| !excluded.contains(base));
+            }
+        }
+        if !excluded_namespaces.is_empty() {
+            for &owner in &visible_import_owners {
+                charge(steps, 1)?;
+                let (public, protected) = super::operations::namespaces::imports::type_imports(
+                    b,
+                    &raw,
+                    owner,
+                    excluded_namespaces,
+                    steps,
+                )
+                .map_err(|_| TypeInputIssue::IncompleteProvider)?;
+                let node = nodes
+                    .get_mut(&owner)
+                    .ok_or(TypeInputIssue::IncompleteProvider)?;
+                node.public_imports = public;
+                node.protected_imports = protected;
+            }
+        }
+        let mut reduction = Reduction::default();
+        let mut reachability = Reachability::sparse();
+        let mut exported = HashMap::new();
+        let mut inherited = Vec::new();
+        let mut inheritable = Vec::new();
+        for owner in ordered {
+            let node = &nodes[&owner];
+            if owner == receiver && excluded_types.is_some() {
+                inheritable = reduction
+                    .inheritable(node, &exported, &mut Some(steps))
+                    .ok_or(TypeInputIssue::WorkLimit)?;
+            }
+            let (_, surviving) = reduction
+                .reduce(
+                    node,
+                    &exported,
+                    &redefinitions,
+                    &mut reachability,
+                    &Facts(b),
+                    &mut Some(steps),
+                )
+                .ok_or(TypeInputIssue::WorkLimit)?;
+            if owner == receiver {
+                charge(steps, surviving.len())?;
+                inherited = surviving.clone();
+            }
+            let visible = reduction
+                .export(node, surviving, &Facts(b), &mut Some(steps))
+                .ok_or(TypeInputIssue::WorkLimit)?;
+            exported.insert(owner, visible);
+        }
+        if !stamp.current_builder(self) {
+            return Err(TypeInputIssue::StaleEvidence);
+        }
+        Ok(super::type_features::MembershipSequence {
+            owned: owned_memberships,
+            inherited,
+            inheritable,
+            non_private: if excluded_types.is_some() {
+                exported
+                    .remove(&receiver)
+                    .ok_or(TypeInputIssue::IncompleteProvider)?
+            } else {
+                Vec::new()
+            },
+            root_import,
+            required_positional,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ClosurePolicy, PropertyError},
+        model::{GraphFormat, Model},
+    };
+    const LIB: &str = "standard library package Base { classifier Anything; feature things:Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things; } standard library package Performances { behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance { return result; } step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances; }";
+    fn fixture(source: &str) -> ResolvedModel {
+        fixture_format(source, GraphFormat::LegacyV2)
+    }
+    fn fixture_format(source: &str, format: GraphFormat) -> ResolvedModel {
+        let mut m = Model::with_graph_format(format);
+        assert!(
+            m.add_library_source("inputs-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let unit = m.add_source("inputs.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&m)
+    }
+    #[test]
+    fn visible_package_imports_preserve_aliases_order_and_redefinition() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture_format(
+                "class External {feature original; feature kept;} package P {class Scalar; alias Named for Scalar; feature slot; alias original for External::original; alias kept for External::kept;} class A {public import P::Named; public import P::slot; public import P::original; protected import P::kept; protected feature own;} class B specializes A {feature replacement redefines External::original;}",
+                format,
+            );
+            let p = r.resolve_qualified("P").unwrap().0;
+            let b = r.resolve_qualified("B").unwrap().0;
+            let alias = |r: &ResolvedModel, name: &str| {
+                *r.b.elements[p]
+                    .owned_relationships
+                    .iter()
+                    .find(|&&m| {
+                        r.b.elements[m].ty == "Membership"
+                            && r.b.elements[m]
+                                .props
+                                .get("memberName")
+                                .and_then(|v| v.as_str())
+                                == Some(name)
+                    })
+                    .unwrap()
+            };
+            let named = alias(&r, "Named");
+            let original = alias(&r, "original");
+            let kept = alias(&r, "kept");
+            let slot = r.resolve_qualified("P::slot").unwrap().0;
+            let slot = r.b.elements[slot].owning_relationship.unwrap();
+            let own = r.resolve_qualified("A::own").unwrap().0;
+            let own = r.b.elements[own].owning_relationship.unwrap();
+            let proof =
+                r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0)
+                    .unwrap();
+            assert_eq!(
+                proof
+                    .inheritable
+                    .iter()
+                    .map(|m| m.relationship)
+                    .collect::<Vec<_>>(),
+                [named, slot, original, own, kept]
+            );
+            assert_eq!(
+                proof
+                    .inherited
+                    .iter()
+                    .map(|m| m.relationship)
+                    .collect::<Vec<_>>(),
+                [named, slot, own, kept]
+            );
+            let features = r.type_feature_report(ElementRef(b)).projections.unwrap();
+            assert_eq!(features.features.len(), 2);
+            // Alias memberships inherit without turning the imported Features
+            // into FeatureMembership slots or adding their owner's own members.
+            assert!(features.inherited_memberships.contains(&ElementRef(kept)));
+        }
+    }
+    #[test]
+    fn namespace_exclusions_select_imports_after_full_proof_and_budget_is_retryable() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture_format(
+                "package P {class Imported;} class A {public import P::*; class Local;} class B specializes A;",
+                format,
+            );
+            let b = r.resolve_qualified("B").unwrap().0;
+            let p = r.resolve_qualified("P").unwrap().0;
+            let a = r.resolve_qualified("A").unwrap().0;
+            let baseline =
+                r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0)
+                    .unwrap();
+            assert_eq!(baseline.inherited.len(), 2);
+            let selected =
+                r.b.checked_type_membership_operation(b, &[p], &[], true, &mut 0)
+                    .unwrap();
+            assert_eq!(selected.inherited.len(), 1);
+            assert_eq!(
+                selected.inherited[0].member,
+                r.resolve_qualified("A::Local").unwrap().0
+            );
+            let mut exhausted_steps = crate::eval::MAX_STEPS;
+            assert!(
+                r.b.checked_type_membership_operation(b, &[], &[], true, &mut exhausted_steps)
+                    .is_err()
+            );
+            assert_eq!(
+                r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0)
+                    .unwrap()
+                    .inherited
+                    .len(),
+                2
+            );
+            let import = *r.b.elements[a]
+                .owned_relationships
+                .iter()
+                .find(|&&rel| conforms(r.b.elements[rel].ty, "Import"))
+                .unwrap();
+            let wrong = r.b.elements[a].id.to_string();
+            r.b.set(import, "importedElement", serde_json::json!({"@id":wrong}));
+            assert!(
+                r.b.checked_type_membership_operation(b, &[p], &[a], true, &mut 0)
+                    .is_err()
+            );
+        }
+    }
+    #[test]
+    fn broader_import_providers_do_not_bypass_central_positional_completeness() {
+        for source in [
+            "package P {class Imported;} package Q {public import P::*;} class A {public import Q::*;} class B specializes A;",
+            "package P {package Q;} class A {public import P::**;} class B specializes A;",
+            "class External {feature original;} class A {public import External::original;} class B specializes A;",
+        ] {
+            let mut r = fixture(source);
+            let b = r.resolve_qualified("B").unwrap().0;
+            let a = r.resolve_qualified("A").unwrap().0;
+            assert!(
+                r.b.checked_type_membership_operation(b, &[], &[a], true, &mut 0)
+                    .is_err()
+            );
+        }
+    }
+    #[test]
+    fn canonical_imports_compose_transitive_packages_and_foreign_ordinary_features() {
+        for (source, names) in [
+            (
+                "package P {class Imported;} package Q {public import P::*;} class A {public import Q::*;} class B specializes A;",
+                vec!["P::Imported"],
+            ),
+            (
+                "class Ancestor {feature original;} class External specializes Ancestor {feature selected redefines Ancestor::original;} class A {public import External::selected;} class B specializes A; class C specializes B {feature replacement redefines External::selected;}",
+                vec!["External::selected"],
+            ),
+        ] {
+            for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+                let mut r = fixture_format(source, format);
+                let b = r.resolve_qualified("B").unwrap().0;
+                let selected =
+                    r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0);
+                if format == GraphFormat::LegacyV2 {
+                    assert!(selected.is_err(), "{source}");
+                    continue;
+                }
+                let expected: Vec<_> = names
+                    .iter()
+                    .map(|name| r.resolve_qualified(name).unwrap().0)
+                    .collect();
+                assert_eq!(
+                    selected
+                        .unwrap_or_else(|error| panic!("{format:?}: {source}: {error:?}"))
+                        .inherited
+                        .iter()
+                        .map(|m| m.member)
+                        .collect::<Vec<_>>(),
+                    expected,
+                    "{source}"
+                );
+                if let Some(c) = r.resolve_qualified("C") {
+                    assert!(
+                        r.b.checked_type_membership_operation(c.0, &[], &[], true, &mut 0)
+                            .unwrap()
+                            .inherited
+                            .is_empty()
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn many_cold_importing_types_share_recorded_edge_proof_within_the_work_limit() {
+        let mut source = String::from(
+            "class Source {feature shared;} package P {alias sharedAlias for Source::shared;} class Parent {end feature original;} class NoiseBase;",
+        );
+        for i in 0..1000 {
+            source.push_str(&format!("class Noise{i} specializes NoiseBase;"));
+        }
+        for i in 0..3000 {
+            source.push_str(&format!("class Child{i} specializes Parent {{public import P::sharedAlias; end feature replacement;}}"));
+        }
+        let mut r = fixture_format(&source, GraphFormat::CanonicalV3);
+        let child = r.resolve_qualified("Child2999").unwrap();
+        let replacement = r.resolve_qualified("Child2999::replacement").unwrap();
+        let original = r.resolve_qualified("Parent::original").unwrap();
+        // The first checked query prepares the complete positional table. Its
+        // imported-source equality proof must not rescan all unrelated recorded
+        // specializations for each importing Type and exhaust the fixed budget.
+        let report = r.type_feature_report(child);
+        let features = report
+            .projections
+            .unwrap_or_else(|error| panic!("{} steps: {error:?}", report.steps));
+        assert!(report.steps < crate::eval::MAX_STEPS);
+        assert!(features.features.contains(&replacement));
+        assert!(!features.features.contains(&original));
+        assert_eq!(
+            r.b.positional_redefinitions
+                .as_ref()
+                .unwrap()
+                .targets
+                .get(&replacement.0),
+            Some(&vec![original.0])
+        );
+    }
+
+    #[test]
+    fn canonical_transitive_import_exclusions_follow_full_proof_and_retries_are_bounded() {
+        let source = "package P {class Imported;} package Q {public import P::*;} class A {public import Q::*;} class B specializes A;";
+        let mut r = fixture_format(source, GraphFormat::CanonicalV3);
+        let b = r.resolve_qualified("B").unwrap().0;
+        let p = r.resolve_qualified("P").unwrap().0;
+        let q = r.resolve_qualified("Q").unwrap().0;
+        let a = r.resolve_qualified("A").unwrap().0;
+        let mut used = 0;
+        assert_eq!(
+            r.b.checked_type_membership_operation(b, &[], &[], true, &mut used)
+                .unwrap()
+                .inherited
+                .len(),
+            1
+        );
+        assert!(used > 1 && used < crate::eval::MAX_STEPS);
+        for excluded in [p, q] {
+            assert!(
+                r.b.checked_type_membership_operation(b, &[excluded], &[], true, &mut 0)
+                    .unwrap()
+                    .inherited
+                    .is_empty()
+            );
+        }
+        let mut steps = crate::eval::MAX_STEPS;
+        assert!(
+            r.b.checked_type_membership_operation(b, &[], &[], true, &mut steps)
+                .is_err()
+        );
+        assert_eq!(
+            r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0)
+                .unwrap()
+                .inherited
+                .len(),
+            1
+        );
+        let import = *r.b.elements[q]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| conforms(r.b.elements[rel].ty, "Import"))
+            .unwrap();
+        let wrong = r.b.elements[a].id.to_string();
+        r.b.set(import, "importedElement", serde_json::json!({"@id":wrong}));
+        assert!(
+            r.b.checked_type_membership_operation(b, &[p, q], &[a], true, &mut 0)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn canonical_imported_positional_dependencies_remain_qualified() {
+        for source in [
+            "class Marker; package P {package Q {alias Alias for Marker;}} class A {public import P::**;} class B specializes A;",
+            "package P {class Marker; public import Q::*;} package Q {public import P::*;} class A {public import P::*;} class B specializes A;",
+            "function Foreign {in original;} class Parent; class External specializes Parent {feature selected redefines Foreign::original;} class A {public import External::selected;} class B specializes A;",
+            "package P {class Nested {feature original;}} class A {public import P::**;} class B specializes A;",
+        ] {
+            let mut r = fixture_format(source, GraphFormat::CanonicalV3);
+            let b = r.resolve_qualified("B").unwrap().0;
+            let a = r.resolve_qualified("A").unwrap().0;
+            assert!(
+                r.b.checked_type_membership_operation(b, &[], &[], true, &mut 0)
+                    .is_err(),
+                "{source}"
+            );
+            assert!(
+                r.b.checked_type_membership_operation(b, &[], &[a], true, &mut 0)
+                    .is_err(),
+                "{source}"
+            );
+        }
+    }
+
+    #[test]
+    fn exclude_implied_filters_inheritance_without_disabling_redefinition_suppression() {
+        for redefinition in ["redefines A::a", ""] {
+            let mut r = fixture(&format!(
+                "function A {{ in a; feature kept; }} function B specializes A {{ in x {redefinition}; }}"
+            ));
+            let receiver = r.resolve_qualified("B").unwrap();
+            let kept = r.resolve_qualified("A::kept").unwrap();
+            let replaced = r.resolve_qualified("A::a").unwrap();
+            let implicit = r
+                .resolve_qualified("Performances::Evaluation::result")
+                .unwrap();
+            let ordinary = r.b.checked_type_memberships(receiver.0, &mut 0).unwrap();
+            let explicit =
+                r.b.checked_type_memberships_for_visibility(receiver.0, &[], true, &mut 0)
+                    .unwrap();
+            let ordinary: Vec<_> = ordinary
+                .inherited
+                .iter()
+                .map(|m| ElementRef(m.member))
+                .collect();
+            let explicit: Vec<_> = explicit
+                .inherited
+                .iter()
+                .map(|m| ElementRef(m.member))
+                .collect();
+            assert!(ordinary.contains(&kept));
+            assert!(ordinary.contains(&implicit));
+            assert!(!ordinary.contains(&replaced));
+            assert_eq!(explicit, [kept]);
+        }
+    }
+
+    fn read(r: &mut ResolvedModel, name: &str) -> Result<Vec<String>, TypeInputIssue> {
+        let e = r.resolve_qualified(name).unwrap();
+        r.type_input_report(e)
+            .inputs
+            .map(|v| v.into_iter().map(|e| r.element_id(e).to_string()).collect())
+    }
+    fn ids(r: &mut ResolvedModel, names: &[&str]) -> Vec<String> {
+        names
+            .iter()
+            .map(|n| {
+                let e = r.resolve_qualified(n).unwrap();
+                r.element_id(e).to_string()
+            })
+            .collect()
+    }
+    #[test]
+    fn function_result_reuses_complete_order_and_checked_multiplicity() {
+        let mut r = fixture(
+            "function A {return resultA;} function B {return resultB;} function C specializes A, B;",
+        );
+        let c = r.resolve_qualified("C").unwrap();
+        let first = r.resolve_qualified("A::resultA").unwrap();
+        assert_eq!(r.function_result_report(c).result, Ok(Some(first)));
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(
+            r.property(c, "result").unwrap(),
+            serde_json::json!({"@id":r.element_id(first)})
+        );
+        let membership = r.b.elements[first.0].owning_relationship.unwrap();
+        r.b.elements[membership]
+            .props
+            .insert("ownedMemberParameter", serde_json::Value::Null);
+        assert!(r.function_result_report(c).result.is_err());
+    }
+    #[test]
+    fn function_result_does_not_treat_missing_evidence_as_absence() {
+        let mut r = fixture("function F {return r;} function G specializes F {return s;}");
+        let g = r.resolve_qualified("G").unwrap();
+        let s = r.resolve_qualified("G::s").unwrap();
+        assert_eq!(r.function_result_report(g).result, Ok(Some(s)));
+        assert_eq!(
+            r.function_result_report_with_budget(g, crate::eval::MAX_STEPS)
+                .result,
+            Err(TypeInputIssue::WorkLimit)
+        );
+        assert_eq!(r.function_result_report(g).result, Ok(Some(s)));
+        let mut missing = Model::new();
+        missing.add_source("missing.kerml", "function F;");
+        let mut r = ResolvedModel::build(&missing);
+        let f = r.resolve_qualified("F").unwrap();
+        assert!(r.function_result_report(f).result.is_err());
+    }
+    #[test]
+    fn ordered_inputs_and_checked_read_preserve_compatibility() {
+        let mut r = fixture(
+            "function F { out feature diagnostic; in a; inout b; feature plain; return answer; } function Empty;",
+        );
+        let f = r.resolve_qualified("F").unwrap();
+        let expected = ids(&mut r, &["F::a", "F::b"]);
+        let before = r.derived(f, "input");
+        assert_eq!(read(&mut r, "F"), Ok(expected.clone()));
+        assert_eq!(read(&mut r, "Empty"), Ok(vec![]));
+        assert_eq!(r.property(f, "input"), Err(PropertyError::Approximate));
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(
+            r.property(f, "input"),
+            Ok(serde_json::json!(
+                expected
+                    .iter()
+                    .map(|id| serde_json::json!({"@id":id}))
+                    .collect::<Vec<_>>()
+            ))
+        );
+        assert_eq!(r.derived(f, "input"), before);
+    }
+    #[test]
+    fn inherited_order_redefinition_and_private_visibility() {
+        let mut r = fixture(
+            "function A { in a; private in secret; protected in b; } function B specializes A { in x redefines a; } function C specializes B;",
+        );
+        let expected = ids(&mut r, &["B::x", "A::b"]);
+        assert_eq!(read(&mut r, "C"), Ok(expected));
+        let expected = ids(&mut r, &["A::a", "A::secret", "A::b"]);
+        assert_eq!(read(&mut r, "A"), Ok(expected));
+    }
+    #[test]
+    fn malformed_direction_membership_and_inverse_claims_are_not_empty_inputs() {
+        for damage in 0..5 {
+            let mut r = fixture("function F { in a; out feature b; }");
+            let f = r.resolve_qualified("F").unwrap();
+            let a = r.resolve_qualified("F::a").unwrap();
+            let b = r.resolve_qualified("F::b").unwrap();
+            assert!(r.type_input_report(f).inputs.is_ok());
+            let membership = r.b.elements[a.0].owning_relationship.unwrap();
+            match damage {
+                0 => {
+                    r.b.elements[b.0]
+                        .props
+                        .insert("direction", serde_json::json!("invalid"));
+                }
+                1 => {
+                    r.b.elements[membership]
+                        .props
+                        .insert("visibility", serde_json::json!("unknown"));
+                }
+                2 => {
+                    let wrong = r.element_id(b).to_string();
+                    r.b.elements[membership]
+                        .props
+                        .insert("memberElement", serde_json::json!({"@id":wrong}));
+                }
+                3 => {
+                    r.b.elements[f.0]
+                        .owned_relationships
+                        .make_mut()
+                        .retain(|&rel| rel != membership);
+                }
+                _ => {
+                    r.b.elements[b.0].owning_relationship = Some(membership);
+                }
+            }
+            assert!(r.type_input_report(f).inputs.is_err(), "damage {damage}");
+        }
+    }
+    #[test]
+    fn missing_library_unsupported_imports_and_budget_retry() {
+        let mut model = Model::new();
+        model.add_source("no-library.kerml", "function F;");
+        let mut r = ResolvedModel::build(&model);
+        assert!(read(&mut r, "F").is_err());
+        let mut r = fixture("package P { in feature a; } function F { public import P::*; }");
+        assert!(read(&mut r, "F").is_err());
+        let mut r = fixture("function F { in a; }");
+        let f = r.resolve_qualified("F").unwrap();
+        assert_eq!(
+            r.type_input_report_with_budget(f, crate::eval::MAX_STEPS)
+                .inputs,
+            Err(TypeInputIssue::WorkLimit)
+        );
+        assert!(r.type_input_report(f).inputs.is_ok());
+    }
+    #[test]
+    fn private_imports_and_unrelated_local_import_damage_preserve_inputs() {
+        let mut r = fixture(
+            "package P {feature x;} function A {private import P::*; in a;} function B specializes A; package Q {private import P::*;}",
+        );
+        let expected = ids(&mut r, &["A::a"]);
+        assert_eq!(read(&mut r, "B"), Ok(expected.clone()));
+        let q = r.resolve_qualified("Q").unwrap().0;
+        let import = r.b.elements[q]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "Import"))
+            .unwrap();
+        r.b.elements[q]
+            .owned_relationships
+            .make_mut()
+            .retain(|&rel| rel != import);
+        assert_eq!(read(&mut r, "B"), Ok(expected));
+    }
+    #[test]
+    fn orphan_import_on_ancestor_refuses_inputs_even_when_marked_implied() {
+        for visibility in ["private", "public", "protected"] {
+            let mut r = fixture(&format!(
+                "package P {{in feature x;}} function A {{{visibility} import P::*; in a;}} function B specializes A;"
+            ));
+            let initial = read(&mut r, "B");
+            assert_eq!(initial.is_ok(), visibility == "private");
+            let a = r.resolve_qualified("A").unwrap().0;
+            let import = r.b.elements[a]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&rel| conforms(r.b.elements[rel].ty, "Import"))
+                .unwrap();
+            let position = r.b.elements[a]
+                .owned_relationships
+                .iter()
+                .position(|&rel| rel == import)
+                .unwrap();
+            r.b.elements[a]
+                .owned_relationships
+                .make_mut()
+                .remove(position);
+            r.b.set(import, "isImplied", serde_json::json!(true));
+            assert!(read(&mut r, "B").is_err(), "{visibility}");
+            r.b.elements[a]
+                .owned_relationships
+                .make_mut()
+                .insert(position, import);
+            r.b.set(import, "isImplied", serde_json::json!(false));
+            assert_eq!(read(&mut r, "B").is_ok(), visibility == "private");
+        }
+    }
+    #[test]
+    fn real_library_functions_in_both_formats() {
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        if !dir.exists() {
+            return;
+        }
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut m = Model::with_graph_format(format);
+            m.load_library_dir(&dir).unwrap();
+            assert!(m.add_source("real-inputs.kerml", "function F { in a; out feature diagnostic; inout b; return result; } function G specializes F;").diagnostics.is_empty());
+            let mut r = ResolvedModel::build(&m);
+            let expected = ids(&mut r, &["F::a", "F::b"]);
+            assert_eq!(read(&mut r, "F"), Ok(expected.clone()), "{format:?}");
+            assert_eq!(read(&mut r, "G"), Ok(expected), "{format:?}");
+            assert_eq!(read(&mut r, "Performances::Evaluation"), Ok(vec![]));
+        }
+    }
+    #[test]
+    fn cold_large_library_input_slice_stays_within_shared_budget() {
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        if !dir.exists() {
+            return;
+        }
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut m = Model::with_graph_format(format);
+            m.load_library_dir(&dir).unwrap();
+            let mut source = String::from(
+                "function A {in a; inout b; return r;} function B specializes A {in x redefines a;} function C specializes B;",
+            );
+            for i in 0..10_000 {
+                source.push_str(&format!("class Unused{i};"));
+            }
+            assert!(
+                m.add_source("large-inputs.kerml", &source)
+                    .diagnostics
+                    .is_empty()
+            );
+            let mut r = ResolvedModel::build(&m);
+            let c = r.resolve_qualified("C").unwrap();
+            let x = r.resolve_qualified("B::x").unwrap();
+            let b = r.resolve_qualified("A::b").unwrap();
+            let report = r.type_input_report(c);
+            eprintln!("{format:?} cold large-library input work: {}", report.steps);
+            assert_eq!(
+                report.inputs,
+                Ok(vec![x, b]),
+                "{format:?}, {}",
+                report.steps
+            );
+            assert!(report.steps <= crate::eval::MAX_STEPS);
+            assert!(r.b.implied.is_none());
+        }
+    }
+    #[test]
+    fn nullable_ordinary_direction_and_parameter_defaults_are_distinct() {
+        let mut r = fixture("function F { in a; feature plain; return r; }");
+        let f = r.resolve_qualified("F").unwrap();
+        let a = r.resolve_qualified("F::a").unwrap();
+        let membership = r.b.elements[a.0].owning_relationship.unwrap();
+        // Ordinary directed declarations use FeatureMembership; parameter
+        // membership is a distinct abstract-syntax defaulting case.
+        assert_eq!(r.b.elements[membership].ty, "FeatureMembership");
+        r.b.elements[a.0]
+            .props
+            .entries
+            .make_mut()
+            .retain(|(key, _)| key.name() != "direction");
+        assert_eq!(r.type_input_report(f).inputs, Ok(vec![]));
+        r.b.elements[membership].ty = "ParameterMembership";
+        assert_eq!(r.type_input_report(f).inputs, Ok(vec![a]));
+        r.b.elements[a.0]
+            .props
+            .insert("direction", serde_json::Value::Null);
+        assert!(r.type_input_report(f).inputs.is_err());
+    }
+    #[test]
+    fn same_length_direction_redefinition_and_identity_edits_are_observed() {
+        let mut r =
+            fixture("function A { in a; in b; } function F specializes A { in x redefines a; }");
+        let f = r.resolve_qualified("F").unwrap();
+        let x = r.resolve_qualified("F::x").unwrap();
+        let expected = ids(&mut r, &["F::x", "A::b"]);
+        assert_eq!(read(&mut r, "F"), Ok(expected.clone()));
+        r.b.elements[x.0]
+            .props
+            .insert("direction", serde_json::json!("out"));
+        let output_only = ids(&mut r, &["A::b"]);
+        assert_eq!(read(&mut r, "F"), Ok(output_only));
+        r.b.elements[x.0]
+            .props
+            .insert("direction", serde_json::json!("in"));
+        assert_eq!(read(&mut r, "F"), Ok(expected));
+        let target = r.resolve_qualified("A::b").unwrap();
+        let rel = r.b.elements[x.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&i| r.b.elements[i].ty == "Redefinition")
+            .unwrap();
+        let id = r.element_id(target);
+        r.b.elements[rel]
+            .props
+            .insert("redefinedFeature", serde_json::json!({"@id":id}));
+        // A stale positional/provider cache must not certify the old answer.
+        let expected = ids(&mut r, &["F::x"]);
+        let report = read(&mut r, "F");
+        assert!(
+            report.as_ref().is_err() || report.as_ref().is_ok_and(|v| v == &expected),
+            "{report:?}"
+        );
+        r.b.elements[x.0].id = r.b.elements[target.0].id;
+        assert!(r.type_input_report(f).inputs.is_err());
+    }
+    #[test]
+    fn ordinary_authored_redefinition_does_not_exempt_parameter_ordinal() {
+        let mut r =
+            fixture("function A { in a; in b; } function F specializes A { in x redefines A::b; }");
+        let expected = ids(&mut r, &["F::x"]);
+        assert_eq!(read(&mut r, "F"), Ok(expected));
+    }
+    #[test]
+    fn malformed_end_roles_and_external_redefinition_owners_are_qualified() {
+        for value in [serde_json::Value::Null, serde_json::json!("true")] {
+            let mut r = fixture("function A { in a; } function F specializes A { feature x; }");
+            let a = r.resolve_qualified("A::a").unwrap();
+            let x = r.resolve_qualified("F::x").unwrap();
+            r.b.elements[a.0]
+                .props
+                .insert("isEnd", serde_json::json!(true));
+            r.b.elements[x.0]
+                .props
+                .insert("isEnd", serde_json::json!(false));
+            let expected = ids(&mut r, &["A::a"]);
+            assert_eq!(read(&mut r, "F"), Ok(expected));
+            r.b.elements[x.0]
+                .props
+                .insert("isEnd", serde_json::json!(true));
+            assert_eq!(read(&mut r, "F"), Ok(vec![]));
+            r.b.elements[x.0].props.insert("isEnd", value);
+            assert!(read(&mut r, "F").is_err());
+        }
+        let mut r = fixture("function A { in a; } function F { in x redefines A::a; }");
+        assert!(read(&mut r, "F").is_err());
+    }
+    #[test]
+    fn cold_input_read_does_not_publish_rows_and_checks_supported_receivers() {
+        let mut r = fixture("function F { in a; } class A;");
+        let f = r.resolve_qualified("F").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        let before = r.b.elements.len();
+        assert!(r.b.implied.is_none());
+        assert!(r.type_input_report(f).inputs.is_ok());
+        assert_eq!(r.b.elements.len(), before);
+        assert!(r.b.implied.is_none());
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert!(r.derived_exact(f, "input").is_ok());
+        assert_eq!(r.property(a, "input"), Ok(serde_json::json!([])));
+        assert_eq!(r.type_input_report(a).inputs, Ok(vec![]));
+        assert_eq!(
+            r.function_result_report(a).result,
+            Err(TypeInputIssue::UnsupportedConfiguration)
+        );
+    }
+    #[test]
+    fn diamonds_multiple_base_order_and_transitive_redefinitions() {
+        let mut r = fixture(
+            "function A { in a; } function B specializes A; function C specializes A; function D specializes B,C; function E { in e; } function F specializes D,E; function G specializes F { in g redefines A::a; } function H specializes G { in h redefines G::g; }",
+        );
+        let expected = ids(&mut r, &["A::a", "E::e"]);
+        assert_eq!(read(&mut r, "F"), Ok(expected));
+        let expected = ids(&mut r, &["H::h", "E::e"]);
+        assert_eq!(read(&mut r, "H"), Ok(expected));
+    }
+    #[test]
+    fn inverse_redefinition_claims_and_conjugation_do_not_certify_absence() {
+        for damage in 0..4 {
+            let mut r =
+                fixture("function A { in a; } function F specializes A { in x redefines a; }");
+            assert!(read(&mut r, "F").is_ok());
+            let f = r.resolve_qualified("F").unwrap();
+            let x = r.resolve_qualified("F::x").unwrap();
+            let rel = r.b.elements[x.0]
+                .owned_relationships
+                .iter()
+                .copied()
+                .find(|&i| r.b.elements[i].ty == "Redefinition")
+                .unwrap();
+            match damage {
+                0 => r.b.elements[x.0]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&i| i != rel),
+                1 => {
+                    r.b.elements[rel].props.insert(
+                        "redefiningFeature",
+                        serde_json::json!({"@id":uuid::Uuid::nil()}),
+                    );
+                }
+                2 => {
+                    r.b.elements[rel].props.insert(
+                        "redefinedFeature",
+                        serde_json::json!({"@id":uuid::Uuid::nil()}),
+                    );
+                }
+                _ => {
+                    r.b.elements[f.0]
+                        .props
+                        .insert("isConjugated", serde_json::json!(true));
+                }
+            }
+            assert!(r.type_input_report(f).inputs.is_err(), "damage {damage}");
+        }
+        let mut r = fixture("function A specializes B; function B specializes A;");
+        assert!(read(&mut r, "A").is_err());
+    }
+    #[test]
+    fn real_library_recorded_prepared_and_full_emission_preserve_inputs_and_graphs() {
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        if !dir.exists() {
+            return;
+        }
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut cold = Model::with_graph_format(format);
+            cold.load_library_dir(&dir).unwrap();
+            cold.record_library_cache();
+            ResolvedModel::build(&cold);
+            let cache = cold.take_recorded_library_cache().unwrap();
+            let prepared = cold.prepare_library().unwrap();
+            let bytes = prepared.to_bytes(119).unwrap();
+            let decoded = std::sync::Arc::new(
+                crate::prepared::PreparedLibrary::from_bytes(&bytes, 119).unwrap(),
+            );
+            let mut warm = Model::with_graph_format(format);
+            decoded.install(&mut warm).unwrap();
+            let mut prepared_model = Model::with_graph_format(format);
+            prepared.install(&mut prepared_model).unwrap();
+            let mut recorded = Model::with_graph_format(format);
+            recorded.load_library_dir(&dir).unwrap();
+            recorded.set_library_cache(cache);
+            let source = "function F { in a; inout b; return answer; } function G specializes F; feature call=G(b=2); class A {out feature x; in feature y;} class B specializes A;";
+            let mut expected = None;
+            let mut expected_features = None;
+            for m in [&mut cold, &mut recorded, &mut prepared_model, &mut warm] {
+                m.add_source("input-replay.kerml", source);
+                let mut r = ResolvedModel::build(m);
+                let g = r.resolve_qualified("G").unwrap();
+                let call = ElementRef(
+                    (r.b.lib_boundary..r.b.elements.len())
+                        .find(|&e| r.b.elements[e].ty == "InvocationExpression")
+                        .unwrap(),
+                );
+                let mapping = r.invocation_binding_report(call).arguments.unwrap();
+                assert_eq!(mapping.bindings.len(), 1);
+                assert_eq!(
+                    mapping.bindings[0].input,
+                    r.resolve_qualified("F::b").unwrap()
+                );
+                let before =
+                    crate::full::resolved_to_full_json(&mut r, m, Default::default()).unwrap();
+                assert_eq!(r.invocation_binding_report(call).arguments, Ok(mapping));
+                let b = r.resolve_qualified("B").unwrap();
+                let p = r.type_feature_report(b).projections.unwrap();
+                let projection_ids: Vec<Vec<_>> = [
+                    &p.features,
+                    &p.feature_memberships,
+                    &p.inherited_memberships,
+                    &p.inputs,
+                    &p.outputs,
+                    &p.directed_features,
+                    &p.end_features,
+                    p.memberships.as_ref().unwrap(),
+                    p.members.as_ref().unwrap(),
+                ]
+                .into_iter()
+                .map(|refs| refs.iter().map(|&e| r.element_id(e)).collect())
+                .collect();
+                if let Some(ref expected) = expected_features {
+                    assert_eq!(&projection_ids, expected);
+                } else {
+                    expected_features = Some(projection_ids);
+                }
+                let value = read(&mut r, "G").unwrap();
+                if let Some(ref expected) = expected {
+                    assert_eq!(&value, expected);
+                } else {
+                    expected = Some(value);
+                }
+                assert_eq!(
+                    crate::full::resolved_to_full_json(&mut r, m, Default::default()).unwrap(),
+                    before
+                );
+                assert!(
+                    r.type_input_report_with_budget(g, crate::eval::MAX_STEPS)
+                        .inputs
+                        .is_err()
+                );
+                assert!(r.type_input_report(g).inputs.is_ok());
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod import_dependencies;
+
+#[cfg(test)]
+mod parameter_dependencies;
+
+#[cfg(test)]
+mod authored_dependencies;
+
+#[cfg(test)]
+mod visible_dependencies;
diff --git a/crates/sysmlv2-model/src/json/type_inputs/authored_dependencies.rs b/crates/sysmlv2-model/src/json/type_inputs/authored_dependencies.rs
new file mode 100644
index 0000000..a3ef55d
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_inputs/authored_dependencies.rs
@@ -0,0 +1,177 @@
+//! Authored positional sources depend only on already ordered actual ancestors.
+use super::*;
+use crate::model::{GraphFormat, Model};
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_library_source("authored-library.kerml", LIB)
+            .diagnostics
+            .is_empty()
+    );
+    let unit = model.add_source("authored-dependencies.kerml", source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+fn id(r: &mut ResolvedModel, name: &str) -> usize {
+    r.resolve_qualified(name).unwrap().0
+}
+
+#[test]
+fn authored_ancestor_roles_keep_checked_and_published_targets_in_order() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early in [false, true] {
+            for (declaration, role, consumer_role) in [
+                ("class", "end feature", "end feature"),
+                ("behavior", "in", "in"),
+                ("function", "return", "return"),
+            ] {
+                let foreign = format!(
+                    "{declaration} Original {{{role} seed;}} {declaration} Middle specializes Original {{{role} middle;}} {declaration} Foreign specializes Middle {{{role} selected redefines Middle::middle;}}"
+                );
+                let consumer = format!(
+                    "{declaration} Provider {{public import Foreign::selected;}} {declaration} Bridge specializes Provider; {declaration} Child specializes Bridge {{{consumer_role} replacement;}}"
+                );
+                let source = if early {
+                    format!("{foreign} {consumer}")
+                } else {
+                    format!("{consumer} {foreign}")
+                };
+                let mut r = fixture(&source, format);
+                let child = id(&mut r, "Child");
+                let selected = id(&mut r, "Foreign::selected");
+                let middle = id(&mut r, "Middle::middle");
+                let seed = id(&mut r, "Original::seed");
+                let replacement = id(&mut r, "Child::replacement");
+                let proof =
+                    r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0);
+                if format == GraphFormat::LegacyV2 {
+                    assert!(proof.is_err());
+                    continue;
+                }
+                let proof = proof.unwrap_or_else(|e| panic!("{declaration} early={early}: {e:?}"));
+                assert_eq!(proof.required_positional.get(&middle), Some(&vec![seed]));
+                // The authored ancestor edge supplies the requirement; no duplicate implied edge.
+                assert!(!proof.required_positional.contains_key(&selected));
+                // A parameter, like an end or a result, pairs with the slot
+                // the import became after an inheritance step.
+                assert_eq!(
+                    proof.required_positional.get(&replacement),
+                    Some(&vec![selected])
+                );
+                assert!(proof.inherited.is_empty());
+                let plan = r.b.positional_redefinitions.as_ref().unwrap();
+                assert!(!plan.targets.contains_key(&selected));
+                assert_eq!(plan.targets.get(&middle), Some(&vec![seed]));
+            }
+        }
+    }
+}
+
+#[test]
+fn authored_role_cycles_same_owner_and_external_role_targets_stay_qualified() {
+    for foreign in [
+        "class Foreign {end feature selected redefines Foreign::another; end feature another;}",
+        "class Other {end feature otherEnd;} class Foreign {end feature selected redefines Other::otherEnd;}",
+        "class Original {end feature seed redefines Foreign::selected;} class Foreign specializes Original {end feature selected redefines Original::seed;}",
+        // A future generated selected -> seed edge would close this cycle.
+        // The non-end relay is structural input, not a conformant end redefinition.
+        "class Root {feature relay redefines Foreign::selected;} class Original specializes Root {end feature seed redefines Root::relay;} class Foreign specializes Original {end feature selected;}",
+        // A role-free authored cycle reaching a role is only structural input,
+        // not a model satisfying Redefinition end conformance.
+        "class Original {end feature seed;} class Foreign specializes Original {end feature selected;} class Relay {feature a redefines Relay::b,Foreign::selected; feature b redefines Relay::a;}",
+    ] {
+        let imported = if foreign.contains("class Relay") {
+            "Relay::a"
+        } else {
+            "Foreign::selected"
+        };
+        let mut r = fixture(
+            &format!(
+                "{foreign} class Provider {{public import {imported};}} class Child specializes Provider {{end feature replacement;}}"
+            ),
+            GraphFormat::CanonicalV3,
+        );
+        let child = id(&mut r, "Child");
+        let provider = id(&mut r, "Provider");
+        for excluded in [vec![], vec![provider]] {
+            assert!(
+                r.b.checked_type_membership_operation(child, &[], &excluded, true, &mut 0)
+                    .is_err(),
+                "{foreign}"
+            );
+        }
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(
+            r.b.positional_redefinitions
+                .as_ref()
+                .unwrap()
+                .incomplete
+                .contains(&child),
+            "{foreign}"
+        );
+    }
+}
+
+#[test]
+fn authored_prerequisite_budget_endpoint_and_carrier_damage_recover() {
+    let mut r = fixture(
+        "class Original {end feature seed;} class Foreign specializes Original {end feature selected redefines Original::seed;} class Other {end feature unrelated;} class Provider {public import Foreign::selected;} class Bridge specializes Provider; class Child specializes Bridge {end feature replacement;}",
+        GraphFormat::CanonicalV3,
+    );
+    let child = id(&mut r, "Child");
+    let selected = id(&mut r, "Foreign::selected");
+    let replacement = id(&mut r, "Child::replacement");
+    let unrelated = id(&mut r, "Other::unrelated");
+    let mut exhausted = crate::eval::MAX_STEPS;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut exhausted)
+            .is_err()
+    );
+    let healthy =
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .unwrap();
+    assert_eq!(
+        healthy.required_positional.get(&replacement),
+        Some(&vec![selected])
+    );
+    let relationship = *r.b.elements[selected]
+        .owned_relationships
+        .iter()
+        .find(|&&e| r.b.elements[e].ty == "Redefinition")
+        .unwrap();
+    let original = r.b.elements[relationship].props.clone();
+    let wrong = r.b.elements[unrelated].id.to_string();
+    // Change the same relationship's endpoint, preserving its identity and the
+    // old bootstrap target. Neither retained publication nor local domain memo
+    // may turn this mismatch into complete source evidence.
+    for key in ["general", "subsettedFeature", "redefinedFeature"] {
+        if original.get(key).is_some() {
+            r.b.set(relationship, key, serde_json::json!({"@id":wrong}));
+        }
+    }
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.elements[relationship].props = original;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    let owned = r.b.elements[selected].owned_relationships.clone();
+    r.b.elements[selected]
+        .owned_relationships
+        .make_mut()
+        .retain(|&e| e != relationship);
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.elements[selected].owned_relationships = owned;
+    let recovered =
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .unwrap();
+    assert_eq!(recovered.required_positional, healthy.required_positional);
+}
diff --git a/crates/sysmlv2-model/src/json/type_inputs/import_dependencies.rs b/crates/sysmlv2-model/src/json/type_inputs/import_dependencies.rs
new file mode 100644
index 0000000..0fa8672
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_inputs/import_dependencies.rs
@@ -0,0 +1,257 @@
+//! Foreign imported positional roles cannot be proved by unrelated root order.
+use super::*;
+use crate::model::{GraphFormat, Model};
+
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;}";
+fn fixture(
+    format: GraphFormat,
+    early_foreign: bool,
+    ancestor: bool,
+    indirect: bool,
+    sibling: bool,
+) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    let library = model.add_library_source("import-dependency-library.kerml", LIB);
+    assert!(library.diagnostics.is_empty(), "{:?}", library.diagnostics);
+    let foreign = if indirect {
+        "class ForeignEndOwner specializes B {end feature a;} class Relay {feature selected redefines ForeignEndOwner::a;} package P {alias importedEnd for Relay::selected;}"
+    } else {
+        "class ForeignEndOwner specializes B {end feature a;} package P {alias importedEnd for ForeignEndOwner::a;}"
+    };
+    let consumer = if ancestor {
+        "class Provider specializes ForeignEndOwner {public import P::importedEnd;} class Child specializes Provider,B; class Grand specializes Child {end feature g;}"
+    } else if sibling {
+        "class Provider {public import P::importedEnd;} class Child specializes Provider,B; class Grand specializes Child,ForeignEndOwner {end feature g;}"
+    } else {
+        "class Provider {public import P::importedEnd;} class Child specializes Provider,B; class Grand specializes Child {end feature g;}"
+    };
+    let source = format!(
+        "class B {{end feature b;}} {} {}",
+        if early_foreign { foreign } else { consumer },
+        if early_foreign { consumer } else { foreign }
+    );
+    let unit = model.add_source("import-dependency.kerml", &source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+
+#[test]
+fn foreign_alias_dependencies_are_scheduled_only_for_the_supported_canonical_domain() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early_foreign in [true, false] {
+            for indirect in [false, true] {
+                let mut r = fixture(format, early_foreign, false, indirect, false);
+                let grand = r.resolve_qualified("Grand").unwrap().0;
+                let provider = r.resolve_qualified("Provider").unwrap().0;
+                let package = r.resolve_qualified("P").unwrap().0;
+                if format == GraphFormat::CanonicalV3 {
+                    let g = r.resolve_qualified("Grand::g").unwrap().0;
+                    let a = r.resolve_qualified("ForeignEndOwner::a").unwrap().0;
+                    let b = r.resolve_qualified("B::b").unwrap().0;
+                    assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+                    let published = r.b.positional_redefinitions.as_ref().unwrap();
+                    assert!(!published.targets.contains_key(&g));
+                    assert!(!published.incomplete.contains(&grand));
+                    assert_eq!(published.targets.get(&a), Some(&vec![b]));
+                }
+                // Canonical orders the foreign end owner before Provider.
+                // The indirect non-end relay is a structural query fixture, not
+                // a claim of whole-model Redefinition end conformance.
+                for (namespaces, types) in [(vec![], vec![]), (vec![package], vec![provider])] {
+                    let result = r.b.checked_type_membership_operation(
+                        grand,
+                        &namespaces,
+                        &types,
+                        true,
+                        &mut 0,
+                    );
+                    if format == GraphFormat::CanonicalV3 && !indirect {
+                        let proof = result.unwrap_or_else(|e| {
+                            panic!("{format:?} early_foreign={early_foreign}: {e:?}")
+                        });
+                        assert_eq!(proof.inherited.len(), 1);
+                        let g = r.resolve_qualified("Grand::g").unwrap().0;
+                        assert!(!proof.required_positional.contains_key(&g));
+                    } else {
+                        assert!(
+                            result.is_err(),
+                            "{format:?} early_foreign={early_foreign} indirect={indirect}"
+                        );
+                    }
+                }
+                assert_eq!(
+                    r.type_feature_report(ElementRef(grand)).projections.is_ok(),
+                    format == GraphFormat::CanonicalV3 && !indirect
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn imported_positional_owner_in_contribution_ancestry_keeps_the_ordered_proof() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early_foreign in [true, false] {
+            let mut r = fixture(format, early_foreign, true, false, false);
+            let grand = r.resolve_qualified("Grand").unwrap().0;
+            let g = r.resolve_qualified("Grand::g").unwrap().0;
+            let a = r.resolve_qualified("ForeignEndOwner::a").unwrap().0;
+            let b = r.resolve_qualified("B::b").unwrap().0;
+            let proof =
+                r.b.checked_type_membership_operation(grand, &[], &[], true, &mut 0)
+                    .unwrap_or_else(|e| panic!("{format:?} early_foreign={early_foreign}: {e:?}"));
+            assert!(proof.inherited.is_empty());
+            assert_eq!(proof.required_positional.get(&a), Some(&vec![b]));
+            assert!(
+                !proof.required_positional.contains_key(&g),
+                "suppressed ancestor ends do not create a Grand positional target"
+            );
+        }
+    }
+}
+
+#[test]
+fn canonical_prerequisites_order_the_importing_branch_before_a_sibling_contributes() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early_foreign in [true, false] {
+            let mut r = fixture(format, early_foreign, false, false, true);
+            let grand = r.resolve_qualified("Grand").unwrap().0;
+            let proof =
+                r.b.checked_type_membership_operation(grand, &[], &[], true, &mut 0);
+            if format == GraphFormat::CanonicalV3 {
+                let g = r.resolve_qualified("Grand::g").unwrap().0;
+                let a = r.resolve_qualified("ForeignEndOwner::a").unwrap().0;
+                let proof = proof
+                    .unwrap_or_else(|e| panic!("{format:?} early_foreign={early_foreign}: {e:?}"));
+                assert_eq!(proof.required_positional.get(&g), Some(&vec![a]));
+                assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+                assert_eq!(
+                    r.b.positional_redefinitions
+                        .as_ref()
+                        .unwrap()
+                        .targets
+                        .get(&g),
+                    Some(&vec![a])
+                );
+            } else {
+                assert!(proof.is_err());
+            }
+        }
+    }
+}
+
+#[test]
+fn direct_foreign_end_prerequisites_preserve_feature_slots_and_retry() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        assert!(
+            model
+                .add_library_source("end-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let unit = model.add_source("direct-end-prerequisite.kerml", "class BaseOwner {end feature baseEnd;} class Foreign specializes BaseOwner {end feature selected; feature unrelated;} class Provider {public import Foreign::selected;} class Intermediate specializes Provider; class Child specializes Intermediate {end feature replacement;}");
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let child = r.resolve_qualified("Child").unwrap().0;
+        let replacement = r.resolve_qualified("Child::replacement").unwrap().0;
+        let selected = r.resolve_qualified("Foreign::selected").unwrap().0;
+        let base = r.resolve_qualified("BaseOwner::baseEnd").unwrap().0;
+        let unrelated = r.resolve_qualified("Foreign::unrelated").unwrap();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut exhausted)
+                .is_err()
+        );
+        let result =
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0);
+        if format == GraphFormat::LegacyV2 {
+            assert!(result.is_err());
+            continue;
+        }
+        let proof = result.unwrap();
+        assert_eq!(proof.required_positional.get(&selected), Some(&vec![base]));
+        assert_eq!(
+            proof.required_positional.get(&replacement),
+            Some(&vec![selected])
+        );
+        assert!(proof.inherited.is_empty());
+        let features = r
+            .type_feature_report(ElementRef(child))
+            .projections
+            .unwrap();
+        assert!(!features.features.contains(&unrelated));
+        for missing in [false, true] {
+            if missing {
+                let original = r.b.elements[selected].props.to_json();
+                let mut without_end = crate::properties::Properties::new();
+                for (key, value) in original {
+                    if key != "isEnd" {
+                        without_end.insert(&key, value);
+                    }
+                }
+                r.b.elements[selected].props = without_end;
+            } else {
+                r.b.set(selected, "isEnd", serde_json::json!(false));
+            }
+            assert!(
+                r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                    .is_err()
+            );
+            r.b.set(selected, "isEnd", serde_json::json!(true));
+        }
+        r.b.set(selected, "direction", serde_json::json!("in"));
+        assert!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .is_err()
+        );
+        r.b.set(selected, "direction", serde_json::Value::Null);
+        assert_eq!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .unwrap()
+                .required_positional
+                .get(&replacement),
+            Some(&vec![selected])
+        );
+    }
+}
+
+#[test]
+fn foreign_owner_mixed_sources_and_cyclic_dependencies_remain_qualified() {
+    for source in [
+        // An unimported ordinary Feature still changes the owner's end reduction.
+        "class Other {end feature otherEnd;} class Foreign {end feature selected; feature ordinary redefines Other::otherEnd;} class Provider {public import Foreign::selected;} class Child specializes Provider {end feature replacement;}",
+        "class Other {end feature otherEnd;} class Foreign {end feature selected redefines Other::otherEnd;} class Provider {public import Foreign::selected;} class Child specializes Provider {end feature replacement;}",
+        // Closing a prerequisite through real inheritance must not become a base.
+        "class Provider {public import Foreign::selected;} class Foreign specializes Provider {end feature selected;} class Child specializes Provider {end feature replacement;}",
+    ] {
+        let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+        assert!(
+            model
+                .add_library_source("end-library.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        let unit = model.add_source("incomplete-end-prerequisite.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let child = r.resolve_qualified("Child").unwrap().0;
+        let provider = r.resolve_qualified("Provider").unwrap().0;
+        let replacement = r.resolve_qualified("Child::replacement").unwrap().0;
+        for excluded in [vec![], vec![provider]] {
+            assert!(
+                r.b.checked_type_membership_operation(child, &[], &excluded, true, &mut 0)
+                    .is_err(),
+                "{source}"
+            );
+        }
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(
+            !r.b.positional_redefinitions
+                .as_ref()
+                .unwrap()
+                .targets
+                .contains_key(&replacement)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/type_inputs/parameter_dependencies.rs b/crates/sysmlv2-model/src/json/type_inputs/parameter_dependencies.rs
new file mode 100644
index 0000000..5d9a5e9
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_inputs/parameter_dependencies.rs
@@ -0,0 +1,279 @@
+//! Imported parameters require owner scheduling: an alias invents no parameter slot, a direct import becomes one after an inheritance step.
+use super::*;
+use crate::model::{GraphFormat, Model};
+
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_library_source("parameter-library.kerml", LIB)
+            .diagnostics
+            .is_empty()
+    );
+    let unit = model.add_source("parameter-dependencies.kerml", source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+fn id(r: &mut ResolvedModel, name: &str) -> usize {
+    r.resolve_qualified(name).unwrap().0
+}
+
+#[test]
+fn foreign_parameters_suppress_and_become_slots_only_after_inheritance() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early in [false, true] {
+            let foreign = "behavior Original {in seed;} behavior Foreign specializes Original {in selected; feature unrelated;} package P {alias selectedAlias for Foreign::selected;}";
+            let consumer = "behavior Provider {public import P::selectedAlias;} behavior Child specializes Provider,Original; behavior Grand specializes Child {in replacement;} behavior DirectProvider {public import Foreign::selected;} behavior DirectBridge specializes DirectProvider; behavior DirectGrand specializes DirectBridge {in replacement;}";
+            let source = if early {
+                format!("{foreign} {consumer}")
+            } else {
+                format!("{consumer} {foreign}")
+            };
+            let mut r = fixture(&source, format);
+            let grand = id(&mut r, "Grand");
+            let direct = id(&mut r, "DirectGrand");
+            let selected = id(&mut r, "Foreign::selected");
+            let seed = id(&mut r, "Original::seed");
+            let unrelated = id(&mut r, "Foreign::unrelated");
+            let replacement = id(&mut r, "Grand::replacement");
+            let direct_replacement = id(&mut r, "DirectGrand::replacement");
+            let result =
+                r.b.checked_type_membership_operation(grand, &[], &[], true, &mut 0);
+            if format == GraphFormat::LegacyV2 {
+                assert!(result.is_err());
+                continue;
+            }
+            let proof = result.unwrap();
+            assert_eq!(
+                proof.inherited.iter().map(|m| m.member).collect::<Vec<_>>(),
+                vec![selected]
+            );
+            assert_eq!(proof.required_positional.get(&selected), Some(&vec![seed]));
+            assert!(!proof.required_positional.contains_key(&replacement));
+            let direct_proof =
+                r.b.checked_type_membership_operation(direct, &[], &[], true, &mut 0)
+                    .unwrap();
+            // The directly imported parameter is a slot one inheritance step
+            // later, which `DirectGrand`'s own parameter takes over.
+            assert!(!direct_proof.inherited.iter().any(|m| m.member == selected));
+            assert_eq!(
+                direct_proof.required_positional.get(&direct_replacement),
+                Some(&vec![selected])
+            );
+            let features = r
+                .type_feature_report(ElementRef(direct))
+                .projections
+                .unwrap();
+            assert!(features.features.contains(&ElementRef(direct_replacement)));
+            assert!(!features.features.contains(&ElementRef(selected)));
+            assert!(!features.features.contains(&ElementRef(unrelated)));
+            let plan = r.b.positional_redefinitions.as_ref().unwrap();
+            assert_eq!(plan.targets.get(&selected), Some(&vec![seed]));
+            assert!(!plan.targets.contains_key(&replacement));
+            assert_eq!(plan.targets.get(&direct_replacement), Some(&vec![selected]));
+        }
+    }
+}
+
+#[test]
+fn foreign_returns_create_effective_results_after_inheritance() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for early in [false, true] {
+            let foreign = "function Original {in seedInput; return seed;} function Foreign specializes Original {in selectedInput; return selected; feature unrelated;}";
+            let consumer = "function Provider {public import Foreign::selected;} function Bridge specializes Provider; function Grand specializes Bridge {in localInput; return replacement;}";
+            let source = if early {
+                format!("{foreign} {consumer}")
+            } else {
+                format!("{consumer} {foreign}")
+            };
+            let mut r = fixture(&source, format);
+            let grand = id(&mut r, "Grand");
+            let selected = id(&mut r, "Foreign::selected");
+            let seed = id(&mut r, "Original::seed");
+            let replacement = id(&mut r, "Grand::replacement");
+            let local = id(&mut r, "Grand::localInput");
+            let result =
+                r.b.checked_type_membership_operation(grand, &[], &[], true, &mut 0);
+            if format == GraphFormat::LegacyV2 {
+                assert!(result.is_err());
+                continue;
+            }
+            let proof = result.unwrap();
+            assert_eq!(proof.required_positional.get(&selected), Some(&vec![seed]));
+            assert_eq!(
+                proof.required_positional.get(&replacement),
+                Some(&vec![selected])
+            );
+            assert!(!proof.required_positional.contains_key(&local));
+            assert!(proof.inherited.is_empty());
+            assert_eq!(
+                r.function_result_report(ElementRef(grand)).result,
+                Ok(Some(ElementRef(replacement)))
+            );
+        }
+    }
+}
+
+#[test]
+fn parameter_prerequisite_role_damage_and_budget_are_retryable() {
+    let mut r = fixture(
+        "behavior Original {in seed;} behavior Foreign specializes Original {in selected;} behavior Provider {public import Foreign::selected;} behavior Child specializes Provider;",
+        GraphFormat::CanonicalV3,
+    );
+    let child = id(&mut r, "Child");
+    let selected = id(&mut r, "Foreign::selected");
+    let membership = r.b.elements[selected].owning_relationship.unwrap();
+    let mut exhausted = crate::eval::MAX_STEPS;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut exhausted)
+            .is_err()
+    );
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    r.b.elements[membership].ty = "ParameterMembership";
+    r.b.elements[selected]
+        .props
+        .entries
+        .make_mut()
+        .retain(|(key, _)| key.name() != "direction");
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    for value in [
+        serde_json::Value::Null,
+        serde_json::json!("out"),
+        serde_json::json!("bad"),
+    ] {
+        r.b.set(selected, "direction", value);
+        assert!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .is_err()
+        );
+    }
+    r.b.set(selected, "direction", serde_json::json!("in"));
+    r.b.set(selected, "isEnd", serde_json::json!(true));
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.set(selected, "isEnd", serde_json::json!(false));
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    r.b.elements[membership].ty = "SubjectMembership";
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+}
+
+#[test]
+fn return_prerequisite_direction_damage_cannot_change_role_defaults() {
+    let mut r = fixture(
+        "function Foreign {return selected;} function Provider {public import Foreign::selected;} function Child specializes Provider;",
+        GraphFormat::CanonicalV3,
+    );
+    let child = id(&mut r, "Child");
+    let selected = id(&mut r, "Foreign::selected");
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    for value in [
+        serde_json::Value::Null,
+        serde_json::json!("in"),
+        serde_json::json!("inout"),
+    ] {
+        r.b.set(selected, "direction", value);
+        assert!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .is_err()
+        );
+    }
+    r.b.elements[selected]
+        .props
+        .entries
+        .make_mut()
+        .retain(|(key, _)| key.name() != "direction");
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    let carrier = r.b.elements[selected].owning_relationship.take().unwrap();
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.elements[selected].owning_relationship = Some(carrier);
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+}
+
+#[test]
+fn ambiguous_results_mixed_sources_and_nested_foreign_roles_stay_qualified() {
+    for foreign in [
+        "function Foreign {return selected; return another;}",
+        "behavior Other {in outside;} function Foreign {return selected; feature ordinary redefines Other::outside;}",
+        "function Other {return outside;} function Foreign {return selected redefines Other::outside;}",
+        "class Extra {end feature value;} package P {alias role for Extra::value;} function Foreign {public import P::role; return selected;}",
+    ] {
+        let mut r = fixture(
+            &format!(
+                "{foreign} function Provider {{public import Foreign::selected;}} function Child specializes Provider;"
+            ),
+            GraphFormat::CanonicalV3,
+        );
+        let child = id(&mut r, "Child");
+        let provider = id(&mut r, "Provider");
+        for excluded in [vec![], vec![provider]] {
+            assert!(
+                r.b.checked_type_membership_operation(child, &[], &excluded, true, &mut 0)
+                    .is_err(),
+                "{foreign}"
+            );
+        }
+    }
+}
+
+#[test]
+fn inherited_result_ambiguity_does_not_invalidate_independent_parameter_evidence() {
+    let mut r = fixture(
+        "function First {return firstResult;} function Second {return secondResult;} function Foreign specializes First,Second {in selected;} behavior Provider {public import Foreign::selected;} behavior Child specializes Provider; function Descendant specializes Foreign {return replacement;}",
+        GraphFormat::CanonicalV3,
+    );
+    let child = id(&mut r, "Child");
+    let selected = id(&mut r, "Foreign::selected");
+    let descendant = id(&mut r, "Descendant");
+    let replacement = id(&mut r, "Descendant::replacement");
+    let proof =
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .unwrap();
+    assert_eq!(
+        proof.inherited.iter().map(|m| m.member).collect::<Vec<_>>(),
+        vec![selected]
+    );
+    assert_eq!(
+        r.type_input_report(ElementRef(child)).inputs,
+        Ok(vec![ElementRef(selected)])
+    );
+    // Imported input evidence needs no unique effective result. A descendant
+    // actually pairing its own return with that ambiguous result must refuse.
+    assert!(
+        r.b.checked_type_membership_operation(descendant, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    assert!(
+        !r.b.positional_redefinitions
+            .as_ref()
+            .unwrap()
+            .targets
+            .contains_key(&replacement)
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/type_inputs/visible_dependencies.rs b/crates/sysmlv2-model/src/json/type_inputs/visible_dependencies.rs
new file mode 100644
index 0000000..140e47d
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_inputs/visible_dependencies.rs
@@ -0,0 +1,233 @@
+//! Visible foreign-owner imports share selectors without adding inheritance.
+use super::*;
+use crate::model::{GraphFormat, Model};
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn fixture(source: &str, format: GraphFormat) -> ResolvedModel {
+    let mut model = Model::with_graph_format(format);
+    assert!(
+        model
+            .add_library_source("visible-library.kerml", LIB)
+            .diagnostics
+            .is_empty()
+    );
+    let unit = model.add_source("visible-dependencies.kerml", source);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    ResolvedModel::build(&model)
+}
+fn id(r: &mut ResolvedModel, name: &str) -> usize {
+    r.resolve_qualified(name).unwrap().0
+}
+
+#[test]
+fn visible_foreign_and_ancestor_imports_preserve_positional_roles_and_memberships() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for (declaration, role) in [
+            ("class", "end feature"),
+            ("behavior", "in"),
+            ("function", "return"),
+        ] {
+            let source = format!(
+                "class Extras {{feature auxiliary;}} package Catalog {{class Marker; alias MarkerAlias for Marker; feature extra; alias featureAlias for Extras::auxiliary;}} {declaration} Original {{protected import Catalog::extra; {role} original;}} {declaration} Foreign specializes Original {{public import Catalog::Marker; protected import Catalog::MarkerAlias; public import Catalog::featureAlias; {role} selected;}} {declaration} Provider {{public import Foreign::selected;}} {declaration} Bridge specializes Provider; {declaration} Child specializes Bridge {{{role} replacement;}} {declaration} Actual specializes Foreign;"
+            );
+            let mut r = fixture(&source, format);
+            let child = id(&mut r, "Child");
+            let actual = id(&mut r, "Actual");
+            let selected = id(&mut r, "Foreign::selected");
+            let original = id(&mut r, "Original::original");
+            let replacement = id(&mut r, "Child::replacement");
+            let marker = id(&mut r, "Catalog::Marker");
+            let extra = id(&mut r, "Catalog::extra");
+            let auxiliary = id(&mut r, "Extras::auxiliary");
+            let result =
+                r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0);
+            if format == GraphFormat::LegacyV2 {
+                assert!(result.is_err());
+                continue;
+            }
+            let proof = result.unwrap_or_else(|e| panic!("{declaration}: {e:?}"));
+            assert_eq!(
+                proof.required_positional.get(&selected),
+                Some(&vec![original])
+            );
+            // A parameter pairs with the inherited one at its position as
+            // an end or a result does.
+            assert_eq!(
+                proof.required_positional.get(&replacement),
+                Some(&vec![selected])
+            );
+            assert!(proof.inherited.is_empty());
+            let actual =
+                r.b.checked_type_membership_operation(actual, &[], &[], true, &mut 0)
+                    .unwrap();
+            let members = actual
+                .inherited
+                .iter()
+                .map(|m| m.member)
+                .collect::<Vec<_>>();
+            assert!(members.contains(&selected));
+            assert!(members.contains(&extra));
+            assert!(members.contains(&auxiliary));
+            assert_eq!(members.iter().filter(|&&m| m == marker).count(), 2);
+        }
+    }
+}
+
+#[test]
+fn foreign_namespace_imports_use_complete_acyclic_package_selection() {
+    for package in [
+        "package Catalog {}",
+        "package Catalog {class Marker; feature extra;}",
+        "package Leaf {class Marker; feature extra;} package Catalog {public import Leaf::*;}",
+    ] {
+        let mut r = fixture(
+            &format!(
+                "{package} class Foreign {{public import Catalog::*; end feature selected;}} class Provider {{public import Foreign::selected;}} class Child specializes Provider;"
+            ),
+            GraphFormat::CanonicalV3,
+        );
+        let child = id(&mut r, "Child");
+        let selected = id(&mut r, "Foreign::selected");
+        let proof =
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .unwrap();
+        assert_eq!(
+            proof.inherited.iter().map(|m| m.member).collect::<Vec<_>>(),
+            vec![selected]
+        );
+    }
+}
+
+#[test]
+fn nested_positional_imports_and_unproved_lookup_domains_stay_qualified() {
+    for prefix in [
+        "class Extra {end feature outside;} package Catalog {alias extra for Extra::outside;}",
+        // Structural rejection fixture: the non-end relay is not a conformant
+        // end redefinition, and cannot conceal the nested role dependency.
+        "class Extra {end feature outside;} class Relay {feature selected redefines Extra::outside;} package Catalog {alias extra for Relay::selected;}",
+        "package Leaf {class Marker;} package Catalog {public import Leaf::**;}",
+        "package Catalog {public import Other::*;} package Other {public import Catalog::*;}",
+    ] {
+        let mut r = fixture(
+            &format!(
+                "{prefix} class Foreign {{public import Catalog::*; end feature selected;}} class Provider {{public import Foreign::selected;}} class Child specializes Provider;"
+            ),
+            GraphFormat::CanonicalV3,
+        );
+        let child = id(&mut r, "Child");
+        let foreign = id(&mut r, "Foreign");
+        let catalog = id(&mut r, "Catalog");
+        assert!(
+            r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+                .is_err(),
+            "{prefix}"
+        );
+        assert!(
+            r.b.checked_type_membership_operation(child, &[catalog], &[foreign], true, &mut 0)
+                .is_err(),
+            "{prefix}"
+        );
+    }
+}
+
+#[test]
+fn foreign_import_endpoint_inverse_and_visibility_mutations_are_observed() {
+    let mut r = fixture(
+        "package Catalog {class Marker;} class Foreign {public import Catalog::*; end feature selected;} class Provider {public import Foreign::selected;} class Child specializes Provider; class Actual specializes Foreign;",
+        GraphFormat::CanonicalV3,
+    );
+    let child = id(&mut r, "Child");
+    let foreign = id(&mut r, "Foreign");
+    let selected = id(&mut r, "Foreign::selected");
+    let actual = id(&mut r, "Actual");
+    let marker = id(&mut r, "Catalog::Marker");
+    let mut exhausted = crate::eval::MAX_STEPS;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut exhausted)
+            .is_err()
+    );
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    let import = *r.b.elements[foreign]
+        .owned_relationships
+        .iter()
+        .find(|&&e| conforms(r.b.elements[e].ty, "Import"))
+        .unwrap();
+    let props = r.b.elements[import].props.clone();
+    let wrong = r.b.elements[selected].id.to_string();
+    r.b.set(
+        import,
+        "importedNamespace",
+        serde_json::json!({"@id":wrong}),
+    );
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.elements[import].props = props;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    r.b.set(import, "visibility", serde_json::json!("unknown"));
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.set(import, "visibility", serde_json::json!("protected"));
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    let exported =
+        r.b.checked_type_membership_operation(actual, &[], &[], true, &mut 0)
+            .unwrap();
+    assert!(exported.inherited.iter().any(|m| m.member == marker));
+    r.b.set(import, "visibility", serde_json::json!("private"));
+    let hidden =
+        r.b.checked_type_membership_operation(actual, &[], &[], true, &mut 0)
+            .unwrap();
+    assert!(!hidden.inherited.iter().any(|m| m.member == marker));
+    let proof_only =
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .unwrap();
+    assert_eq!(
+        proof_only
+            .inherited
+            .iter()
+            .map(|m| m.member)
+            .collect::<Vec<_>>(),
+        vec![selected]
+    );
+    r.b.set(import, "visibility", serde_json::json!("public"));
+    let restored =
+        r.b.checked_type_membership_operation(actual, &[], &[], true, &mut 0)
+            .unwrap();
+    assert!(restored.inherited.iter().any(|m| m.member == marker));
+    let metadata = r.b.metadata_of.clone();
+    r.b.metadata_of.insert(foreign, vec![selected]);
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.metadata_of = metadata;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+    let owned = r.b.elements[foreign].owned_relationships.clone();
+    r.b.elements[foreign]
+        .owned_relationships
+        .make_mut()
+        .retain(|&e| e != import);
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_err()
+    );
+    r.b.elements[foreign].owned_relationships = owned;
+    assert!(
+        r.b.checked_type_membership_operation(child, &[], &[], true, &mut 0)
+            .is_ok()
+    );
+}
diff --git a/crates/sysmlv2-model/src/json/type_relations.rs b/crates/sysmlv2-model/src/json/type_relations.rs
new file mode 100644
index 0000000..d141db7
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/type_relations.rs
@@ -0,0 +1,2893 @@
+//! Query-local, bounded evidence for stored type specialization.
+//!
+//! Positive witnesses use declaration identities. Negative facts require a
+//! complete stored/provider walk and audited required library bases at every
+//! visited non-conjugated type. Other families remain unknown; no unsupported
+//! base omission is a negative fact.
+use super::{Builder, provider_completeness::ProviderCompleteness, semantic_ownership};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum SupertypesFailure {
+    Incomplete,
+    UnsupportedConfiguration,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum FeatureRequirementsFailure {
+    Unsupported,
+    InvalidRelationship,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum RelationFact {
+    Yes,
+    No,
+    Unknown,
+}
+
+impl RelationFact {
+    /// A complete universal condition is refuted by any decisive negative,
+    /// even when another member's compatibility remains unproved.
+    pub(super) fn all(facts: impl IntoIterator<Item = Self>) -> Self {
+        let mut unknown = false;
+        for fact in facts {
+            match fact {
+                Self::Yes => {}
+                Self::No => return Self::No,
+                Self::Unknown => unknown = true,
+            }
+        }
+        if unknown { Self::Unknown } else { Self::Yes }
+    }
+}
+
+#[derive(Clone)]
+struct Bases {
+    targets: Vec<usize>,
+    complete: bool,
+}
+
+struct StoredBases {
+    targets: Vec<usize>,
+    target_set: HashSet<usize>,
+    complete: bool,
+    conjugated: bool,
+    final_chain: Option<usize>,
+    duplicate_targets: bool,
+    feature_chain_complete: bool,
+}
+
+/// Reuse only within one query over an unchanged model.
+#[derive(Default)]
+pub(super) struct TypeRelations {
+    publication: Option<super::publication::Revision>,
+    rows: Option<crate::layered::Revision>,
+    metadata: Option<Option<std::sync::Arc<()>>>,
+    providers: ProviderCompleteness,
+    planner_state: Option<(bool, bool)>,
+    retained_plan: Option<std::sync::Arc<super::implied::SupportedImpliedSpecializations>>,
+    bases: HashMap<usize, Bases>,
+    // allSupertypes reachability only; receiver conjugation normalization is
+    // separate and must never reuse a reflexive closure fact as specializes.
+    known: HashMap<(usize, usize, usize), bool>,
+    conjugations: HashMap<usize, Option<usize>>,
+    owned_feature_witness: HashMap<usize, bool>,
+    evidence: FeaturingEvidence,
+    required_library: Option<HashMap<&'static str, Option<usize>>>,
+}
+
+/// Positive type-kind facts for a composition's Feature owner. Checked readers
+/// supply these only after a complete projection; static planning uses validated
+/// owned typing witnesses and therefore cannot infer absent facts.
+#[derive(Clone, Copy, Debug, Default)]
+pub(super) struct CompositionOwner {
+    pub(super) object: bool,
+    pub(super) occurrence: bool,
+}
+
+/// Conditional composition requirements, including certified Feature owners.
+pub(super) fn composite_roles(
+    kind: &str,
+    owner: &str,
+    object: bool,
+    occurrence: bool,
+    owner_types: CompositionOwner,
+) -> Vec<&'static str> {
+    let mut roles = Vec::new();
+    if (conforms(owner, "Class") || owner_types.occurrence || conforms(owner, "OccurrenceUsage"))
+        && (occurrence || conforms(kind, "OccurrenceUsage"))
+    {
+        roles.push("Occurrences::Occurrence::suboccurrences");
+    }
+    if (conforms(owner, "Structure") || owner_types.object) && object {
+        roles.push("Objects::Object::subobjects");
+    }
+    if conforms(owner, "ItemDefinition") || conforms(owner, "ItemUsage") {
+        if conforms(kind, "ItemUsage") {
+            roles.push("Items::Item::subitems");
+        }
+        if conforms(kind, "PartUsage") {
+            roles.push("Items::Item::subparts");
+        }
+    }
+    roles
+}
+
+pub(super) const COMPOSITE_ROLES: [&str; 4] = [
+    "Occurrences::Occurrence::suboccurrences",
+    "Objects::Object::subobjects",
+    "Items::Item::subitems",
+    "Items::Item::subparts",
+];
+
+fn charge(steps: &mut usize, amount: usize) -> Option<()> {
+    *steps = steps.saturating_add(amount);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+impl TypeRelations {
+    /// Discard query-local facts after the caller's semantic stamp changes.
+    /// Charge owned containers before traversing or releasing their contents.
+    pub(super) fn reset_with_budget(&mut self, steps: &mut usize) -> Option<()> {
+        charge(
+            steps,
+            1usize
+                .saturating_add(self.bases.capacity())
+                .saturating_add(self.known.capacity())
+                .saturating_add(self.conjugations.capacity())
+                .saturating_add(self.owned_feature_witness.capacity())
+                .saturating_add(self.required_library.as_ref().map_or(0, HashMap::capacity))
+                .saturating_add(self.evidence.owners.capacity())
+                .saturating_add(self.evidence.featuring.capacity()),
+        )?;
+        for bases in self.bases.values() {
+            charge(steps, bases.targets.len())?;
+        }
+        for features in self.evidence.featuring.values() {
+            charge(steps, features.len())?;
+        }
+        self.providers.reset_with_budget(steps)?;
+        *self = Self::default();
+        Some(())
+    }
+
+    fn refresh_planner_state(&mut self, b: &mut Builder, steps: &mut usize) -> Option<()> {
+        if b.positional_planning {
+            return None;
+        }
+        b.refresh_supported_chain_evidence(Some(&mut *steps))?;
+        b.certify_materialized_static_prefix(steps)?;
+        let state = (b.semantic_ready, b.positional_redefinitions.is_some());
+        let same_plan = match (&self.retained_plan, &b.supported_implied) {
+            (None, None) => true,
+            (Some(old), Some(current)) => std::sync::Arc::ptr_eq(old, current),
+            _ => false,
+        };
+        if self.planner_state != Some(state) || !same_plan {
+            charge(
+                steps,
+                self.bases
+                    .capacity()
+                    .saturating_add(self.known.capacity())
+                    .saturating_add(self.required_library.as_ref().map_or(0, HashMap::capacity)),
+            )?;
+            self.bases.clear();
+            self.known.clear();
+            self.required_library = None;
+            self.planner_state = Some(state);
+            self.retained_plan = b.supported_implied.clone();
+        }
+        Some(())
+    }
+
+    fn current(&mut self, b: &mut Builder) -> bool {
+        if let Some(previous) = &self.metadata {
+            let unchanged = match (previous, &b.metadata_association_generation) {
+                (None, None) => true,
+                (Some(a), Some(z)) => std::sync::Arc::ptr_eq(a, z),
+                _ => false,
+            };
+            if !unchanged {
+                return false;
+            }
+        } else {
+            self.metadata = Some(b.metadata_association_generation.clone());
+        }
+        let rows = b.elements.observe_revision();
+        if self
+            .rows
+            .as_ref()
+            .is_some_and(|previous| !previous.same_as(&rows))
+        {
+            return false;
+        }
+        self.rows.get_or_insert(rows);
+        let epoch = b.publication.revision();
+        match &self.publication {
+            Some(previous) => previous.same_as(&epoch),
+            None => {
+                self.publication = Some(epoch);
+                true
+            }
+        }
+    }
+
+    pub(super) fn specializes(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        general: usize,
+        steps: &mut usize,
+    ) -> RelationFact {
+        if !self.current(b) || self.refresh_planner_state(b, steps).is_none() {
+            return RelationFact::Unknown;
+        }
+        // KerML Type::specializes delegates a conjugated RECEIVER to its
+        // original type before asking for reflexive allSupertypes membership.
+        // This is not the same operation as normalizing every node in that
+        // closure: an ordinary type specializing a conjugated type still
+        // specializes that intermediate type itself.
+        let mut receiver = specific;
+        let mut active = HashSet::new();
+        for depth in 0..=super::MAX_RESOLUTION_DEPTH {
+            if charge(steps, 1).is_none()
+                || !b
+                    .elements
+                    .get(general)
+                    .is_some_and(|e| conforms(e.ty, "Type"))
+                || !active.insert(receiver)
+            {
+                return RelationFact::Unknown;
+            }
+            match self.owned_conjugation(b, receiver, steps) {
+                Some(Some(original)) => receiver = original,
+                Some(None) => {
+                    return self.walk(b, receiver, general, depth, &mut HashSet::new(), steps);
+                }
+                None => return RelationFact::Unknown,
+            }
+        }
+        RelationFact::Unknown
+    }
+
+    /// Complete local receiver classification. Unrelated specialization
+    /// endpoint failure does not remove ordinary reflexivity, but a missing,
+    /// conflicting or cyclic conjugator cannot bypass receiver normalization.
+    pub(super) fn owned_conjugation(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        if !self.current(b) {
+            return None;
+        }
+        charge(steps, 1)?;
+        if let Some(&known) = self.conjugations.get(&specific) {
+            return Some(known);
+        }
+        if !conforms(b.elements.get(specific)?.ty, "Type") {
+            return None;
+        }
+        let relationships = self.evidence.relationships(b, specific, steps)?;
+        let mut seen = HashSet::new();
+        let mut conjugation = None;
+        for relation in relationships {
+            if !seen.insert(relation) {
+                return None;
+            }
+            if conforms(b.elements.get(relation)?.ty, "Conjugation")
+                && conjugation.replace(relation).is_some()
+            {
+                return None;
+            }
+        }
+        if b.elements[specific]
+            .props
+            .get("isConjugated")
+            .is_some_and(|value| value.as_bool() != Some(conjugation.is_some()))
+        {
+            return None;
+        }
+        let original = if let Some(relation) = conjugation {
+            self.evidence.index(b, steps)?;
+            if self.evidence.incomplete()
+                || self.evidence.carrier(b, relation, steps)? != Some(specific)
+            {
+                return None;
+            }
+            Some(endpoint(
+                b,
+                specific,
+                relation,
+                &["conjugatedType"],
+                &["originalType"],
+                "Type",
+                steps,
+            )?)
+        } else {
+            None
+        };
+        self.conjugations.insert(specific, original);
+        Some(original)
+    }
+
+    /// Feature compatibility includes a further shared-redefinition/access
+    /// clause. Until that clause has complete evidence, failure to specialize
+    /// two Features is unknown, rather than a negative compatibility fact.
+    pub(super) fn compatible(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        general: usize,
+        steps: &mut usize,
+    ) -> RelationFact {
+        if !self.current(b) {
+            return RelationFact::Unknown;
+        }
+        let fact = self.specializes(b, specific, general, steps);
+        if fact == RelationFact::No
+            && b.elements
+                .get(specific)
+                .is_some_and(|e| conforms(e.ty, "Feature"))
+            && b.elements
+                .get(general)
+                .is_some_and(|e| conforms(e.ty, "Feature"))
+        {
+            // The shared-redefinition clause requires both owned-feature
+            // sets to be empty. One reciprocal membership witness refutes it.
+            if self.has_owned_feature(b, specific, steps) == Some(true)
+                || self.has_owned_feature(b, general, steps) == Some(true)
+            {
+                RelationFact::No
+            } else {
+                RelationFact::Unknown
+            }
+        } else {
+            fact
+        }
+    }
+
+    fn has_owned_feature(
+        &mut self,
+        b: &mut Builder,
+        owner: usize,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        if let Some(&found) = self.owned_feature_witness.get(&owner) {
+            return Some(found);
+        }
+        let relations = self.evidence.relationships(b, owner, steps)?;
+        let mut found = false;
+        for relation in relations {
+            let member = b.elements.get(relation)?;
+            if !conforms(member.ty, "FeatureMembership") {
+                continue;
+            }
+            charge(steps, member.children.len())?;
+            let children = member.children.to_vec();
+            for child in children {
+                if conforms(b.elements.get(child)?.ty, "Feature")
+                    && self.evidence.owning_type(b, child, steps) == Some(Some(owner))
+                {
+                    found = true;
+                    break;
+                }
+            }
+            if found {
+                break;
+            }
+        }
+        charge(steps, 0)?;
+        if !found && !semantic_ownership::owned_feature_projection_complete(b, owner) {
+            return None;
+        }
+        self.owned_feature_witness.insert(owner, found);
+        Some(found)
+    }
+
+    /// Select an audited evidence domain before candidate selection. A known
+    /// unsupported family selects the unchanged compatibility provider; broken
+    /// evidence is None and must never trigger that compatibility fallback.
+    pub(super) fn audited_featuring_domain(
+        &mut self,
+        b: &mut Builder,
+        roots: &[usize],
+        steps: &mut usize,
+    ) -> Option<bool> {
+        if !self.current(b) {
+            return None;
+        }
+        fn ordinary(b: &Builder, e: usize) -> Option<bool> {
+            if b.metadata_of.get(&e).is_some_and(|items| !items.is_empty()) {
+                return Some(false);
+            }
+            let e = b.elements.get(e)?;
+            if e.ty != "Feature" {
+                return Some(false);
+            }
+            match e.props.get("isVariable") {
+                None => Some(true),
+                Some(value) => value.as_bool().map(|variable| !variable),
+            }
+        }
+        charge(steps, roots.len())?;
+        for &root in roots {
+            if !ordinary(b, root)? {
+                return Some(false);
+            }
+        }
+        let mut stack = roots.to_vec();
+        let mut seen = HashSet::new();
+        while let Some(feature) = stack.pop() {
+            charge(steps, 1)?;
+            if !seen.insert(feature) {
+                continue;
+            }
+            if !ordinary(b, feature)? {
+                return Some(false);
+            }
+            self.evidence.index(b, steps)?;
+            if let Some(rel) = b.elements[feature].owning_relationship {
+                if !conforms(b.elements.get(rel)?.ty, "FeatureMembership") {
+                    if let Some(owner) = self.evidence.carrier(b, rel, steps)? {
+                        if conforms(b.elements[owner].ty, "Feature") {
+                            return Some(false);
+                        }
+                    }
+                }
+            }
+            let owners = self
+                .evidence
+                .featuring_types(b, feature, &mut HashSet::new(), steps)?;
+            for owner in owners {
+                if conforms(b.elements[owner].ty, "Feature") {
+                    stack.push(owner);
+                } else if !matches!(
+                    b.elements[owner].ty,
+                    "Type" | "Classifier" | "Class" | "Structure" | "DataType"
+                ) {
+                    return Some(false);
+                }
+            }
+            let relationships = self.evidence.relationships(b, feature, steps)?;
+            for relationship in relationships {
+                if conforms(b.elements[relationship].ty, "FeatureChaining") {
+                    stack.push(endpoint(
+                        b,
+                        feature,
+                        relationship,
+                        &["featureChained"],
+                        &["chainingFeature"],
+                        "Feature",
+                        steps,
+                    )?);
+                }
+            }
+        }
+        Some(true)
+    }
+
+    pub(super) fn owning_type(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        if !self.current(b) {
+            return None;
+        }
+        self.evidence.owning_type(b, feature, steps)
+    }
+
+    pub(super) fn featuring_types(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if !self.current(b) {
+            return None;
+        }
+        self.evidence
+            .featuring_types(b, feature, &mut HashSet::new(), steps)
+    }
+
+    /// Applicability and canonical obligations shared by typing and negative
+    /// specialization proofs. These are required witnessed paths, never edges.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn feature_requirements(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+        owned: &[usize],
+        typings: &[usize],
+        original: Option<usize>,
+        owner_types: Option<CompositionOwner>,
+        steps: &mut usize,
+    ) -> Result<(Vec<usize>, Vec<usize>), FeatureRequirementsFailure> {
+        use FeatureRequirementsFailure::{InvalidRelationship, Unsupported};
+        if !self.current(b) || !b.dynamic_evidence_current(feature) {
+            return Err(Unsupported);
+        }
+        self.refresh_planner_state(b, steps).ok_or(Unsupported)?;
+        charge(steps, 1).ok_or(Unsupported)?;
+        let structure = super::structural_index::StoredStructure::for_annotations(b, steps)
+            .ok_or(InvalidRelationship)?;
+        let e = b.elements.get(feature).ok_or(InvalidRelationship)?;
+        let ty = e.ty;
+        if !matches!(
+            ty,
+            "Feature"
+                | "Step"
+                | "Expression"
+                | "ReferenceUsage"
+                | "AttributeUsage"
+                | "OccurrenceUsage"
+                | "ItemUsage"
+                | "PartUsage"
+        ) || original.is_some()
+            || b.metadata_associations_incomplete
+            || structure.annotations_incomplete
+            || structure.metadata_annotation_targets.contains(&feature)
+            || b.metadata_of.get(&feature).is_some_and(|v| !v.is_empty())
+        {
+            return Err(Unsupported);
+        }
+        // These flags activate unaudited conditional specialization families.
+        if e.props
+            .get("isPortion")
+            .is_some_and(|v| v.as_bool() != Some(false))
+        {
+            return Err(Unsupported);
+        }
+        if conforms(ty, "Usage")
+            && (e
+                .props
+                .get("isVariation")
+                .is_some_and(|v| v.as_bool() != Some(false))
+                || e.props.get("portionKind").is_some_and(|v| !v.is_null()))
+        {
+            return Err(Unsupported);
+        }
+        let composite = match e.props.get("isComposite") {
+            None => false,
+            Some(value) => value.as_bool().ok_or(Unsupported)?,
+        };
+        let is_end = match e.props.get("isEnd") {
+            None => false,
+            Some(v) => v.as_bool().ok_or(Unsupported)?,
+        };
+        // Usage redefines isVariable as a derived property. Its Boolean value
+        // changes featuring, not the specialization obligations audited here.
+        if e.props.get("isVariable").is_some_and(|v| {
+            v.as_bool().is_none() || (!conforms(ty, "Usage") && v.as_bool() != Some(false))
+        }) {
+            return Err(Unsupported);
+        }
+        let ordinary_feature =
+            ty == "Feature" && !is_end && e.props.get("direction").is_none_or(|v| v.is_null());
+        let membership = e.owning_relationship.ok_or(Unsupported)?;
+        self.evidence.index(b, steps).ok_or(InvalidRelationship)?;
+        let carrier = self
+            .evidence
+            .carrier(b, membership, steps)
+            .ok_or(InvalidRelationship)?
+            .ok_or(InvalidRelationship)?;
+        let owner_kind = b.elements.get(carrier).ok_or(InvalidRelationship)?.ty;
+        let namespace = matches!(owner_kind, "Namespace" | "Package" | "LibraryPackage");
+        if namespace {
+            if self.evidence.owning_type(b, feature, steps) != Some(None) {
+                return Err(InvalidRelationship);
+            }
+        } else {
+            // Ordinary Usage families and undirected non-end Kernel Features
+            // have audited owner contexts. Exact owner kinds exclude behavior,
+            // result, flow and cross contexts; FeatureMembership excludes variant
+            // antecedents. Usage end order is certified by the shared reducer.
+            if !(conforms(ty, "Usage") || ordinary_feature)
+                || !(b.elements[membership].ty == "FeatureMembership"
+                    || (is_end && b.elements[membership].ty == "EndFeatureMembership"))
+                || !(matches!(
+                    owner_kind,
+                    "Type"
+                        | "Classifier"
+                        | "Class"
+                        | "Structure"
+                        | "DataType"
+                        | "Definition"
+                        | "AttributeDefinition"
+                        | "OccurrenceDefinition"
+                        | "ItemDefinition"
+                        | "PartDefinition"
+                ) || (composite
+                    && conforms(ty, "OccurrenceUsage")
+                    && matches!(
+                        owner_kind,
+                        "Feature" | "OccurrenceUsage" | "ItemUsage" | "PartUsage"
+                    )
+                    && owner_types.is_some()))
+            {
+                return Err(Unsupported);
+            }
+            if self.evidence.owning_type(b, feature, steps) != Some(Some(carrier)) {
+                return Err(InvalidRelationship);
+            }
+        }
+        charge(steps, owned.len()).ok_or(Unsupported)?;
+        let mut has_owned_typing = false;
+        for &relationship in owned {
+            let kind = b.elements.get(relationship).ok_or(InvalidRelationship)?.ty;
+            has_owned_typing |= conforms(kind, "FeatureTyping");
+            if conforms(kind, "FeatureValue")
+                || conforms(kind, "FeatureChaining")
+                || conforms(kind, "CrossSubsetting")
+                || conforms(kind, "FeatureInverting")
+                || matches!(kind, "Unioning" | "Differencing")
+            {
+                return Err(Unsupported);
+            }
+            if kind == "Intersecting" {
+                if !composite || !ordinary_feature {
+                    return Err(Unsupported);
+                }
+                if self.evidence.carrier(b, relationship, steps) != Some(Some(feature)) {
+                    return Err(InvalidRelationship);
+                }
+                // Intersections add no new typing dependency only when every
+                // target is already an exact owned Subsetting target. Never
+                // synthesize missing specializations from an intersection.
+                let target = endpoint(
+                    b,
+                    feature,
+                    relationship,
+                    &["typeIntersected"],
+                    &["intersectingType"],
+                    "Feature",
+                    steps,
+                )
+                .ok_or(InvalidRelationship)?;
+                let mut witnessed = false;
+                for &candidate in owned {
+                    charge(steps, 1).ok_or(Unsupported)?;
+                    if conforms(b.elements[candidate].ty, "Subsetting")
+                        && !conforms(b.elements[candidate].ty, "CrossSubsetting")
+                        && endpoint(
+                            b,
+                            feature,
+                            candidate,
+                            &["specific", "subsettingFeature"],
+                            &["general", "subsettedFeature"],
+                            "Feature",
+                            steps,
+                        ) == Some(target)
+                    {
+                        witnessed = true;
+                    }
+                }
+                if !witnessed {
+                    return Err(Unsupported);
+                }
+            }
+        }
+        // This composition audit covers ordinary Occurrence/Item/Part Usage
+        // families and Kernel Features with explicit owned typing. Inherited-only
+        // Kernel typing and other composite Feature kinds remain qualified.
+        if composite && !conforms(ty, "OccurrenceUsage") && !(ty == "Feature" && has_owned_typing) {
+            return Err(Unsupported);
+        }
+        charge(steps, typings.len()).ok_or(Unsupported)?;
+        let (mut object, mut occurrence, mut data) = (false, false, false);
+        for &target in typings {
+            let target_ty = b.elements.get(target).ok_or(InvalidRelationship)?.ty;
+            if !conforms(target_ty, "Classifier") {
+                return Err(Unsupported);
+            }
+            object |= conforms(target_ty, "Structure");
+            occurrence |= conforms(target_ty, "Class");
+            data |= conforms(target_ty, "DataType");
+        }
+        let roles = [
+            (true, "Base::things"),
+            (conforms(ty, "Step"), "Performances::performances"),
+            (conforms(ty, "Expression"), "Performances::evaluations"),
+            (object, "Objects::objects"),
+            (occurrence, "Occurrences::occurrences"),
+            (data || ty == "AttributeUsage", "Base::dataValues"),
+            (conforms(ty, "OccurrenceUsage"), "Occurrences::occurrences"),
+            (conforms(ty, "ItemUsage"), "Items::items"),
+            (ty == "PartUsage", "Parts::parts"),
+        ];
+        let mut required = Vec::with_capacity(roles.iter().filter(|(needed, _)| *needed).count());
+        for (needed, name) in roles {
+            if needed {
+                required.push(self.required_role(b, name, steps).ok_or(Unsupported)?);
+            }
+        }
+        if composite {
+            for name in composite_roles(
+                ty,
+                owner_kind,
+                object,
+                occurrence,
+                owner_types.unwrap_or_default(),
+            ) {
+                required.push(self.required_role(b, name, steps).ok_or(Unsupported)?);
+            }
+        }
+        if is_end && !namespace {
+            // This is the same complete Membership/positional certificate used
+            // by Type.feature. Its generated targets are required witnesses in
+            // the shared semantic graph, never a second set of implicit edges.
+            let mut sequence = b
+                .checked_type_memberships(carrier, steps)
+                .map_err(|_| Unsupported)?;
+            charge(steps, sequence.owned.len()).ok_or(Unsupported)?;
+            if !sequence.owned.iter().any(|m| {
+                m.member == feature && conforms(b.elements[m.relationship].ty, "FeatureMembership")
+            }) {
+                return Err(InvalidRelationship);
+            }
+            // An ordinary end with an owned crossing Feature activates separate
+            // crossing obligations. Do not certify their absence from a flag.
+            let domains = structure.membership_domains(b, steps).ok_or(Unsupported)?;
+            if !domains.owner_complete(feature) {
+                return Err(InvalidRelationship);
+            }
+            for &relationship in owned {
+                charge(steps, 1).ok_or(Unsupported)?;
+                let kind = b.elements[relationship].ty;
+                if conforms(kind, "OwningMembership") && !conforms(kind, "FeatureMembership") {
+                    let member = super::membership_evidence::member(
+                        b,
+                        &structure,
+                        feature,
+                        relationship,
+                        steps,
+                    )
+                    .ok_or(InvalidRelationship)?;
+                    let kind = b.elements[member].ty;
+                    if conforms(kind, "Feature")
+                        && !conforms(kind, "Multiplicity")
+                        && !conforms(kind, "MetadataFeature")
+                    {
+                        return Err(Unsupported);
+                    }
+                }
+            }
+            if let Some(targets) = sequence.required_positional.remove(&feature) {
+                charge(steps, targets.len()).ok_or(Unsupported)?;
+                required.extend(targets);
+            }
+        }
+        let anything = self
+            .required_role(b, "Base::Anything", steps)
+            .ok_or(Unsupported)?;
+        Ok((required, vec![anything]))
+    }
+
+    // Audited family obligations for complete negative specialization paths.
+    // Verify inherited family requirements, rather than assuming a partial
+    // replacement library supplies its own ancestor heritage correctly. These
+    // targets are obligations to prove through the shared graph, not new edges.
+    fn required_bases(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if matches!(
+            b.elements.get(specific)?.ty,
+            "Feature"
+                | "ReferenceUsage"
+                | "AttributeUsage"
+                | "OccurrenceUsage"
+                | "ItemUsage"
+                | "PartUsage"
+        ) {
+            let owned = self.evidence.relationships(b, specific, steps)?;
+            let mut typings = Vec::new();
+            for &relation in &owned {
+                charge(steps, 1)?;
+                if conforms(b.elements.get(relation)?.ty, "FeatureTyping") {
+                    typings.push(endpoint(
+                        b,
+                        specific,
+                        relation,
+                        &["typedFeature", "specific"],
+                        &["type", "general"],
+                        "Type",
+                        steps,
+                    )?);
+                }
+            }
+            let (mut feature_bases, type_bases) = self
+                .feature_requirements(b, specific, &owned, &typings, None, None, steps)
+                .ok()?;
+            feature_bases.extend(type_bases);
+            return Some(feature_bases);
+        }
+        let element = b.elements.get(specific)?;
+        if conforms(element.ty, "Definition") {
+            for key in ["isVariation", "isIndividual"] {
+                if element
+                    .props
+                    .get(key)
+                    .is_some_and(|v| v.as_bool() != Some(false))
+                {
+                    return None;
+                }
+            }
+        }
+        let names: &[&str] = match element.ty {
+            "Type" | "Classifier" | "Definition" => &["Base::Anything"],
+            "Class" | "OccurrenceDefinition" => &["Occurrences::Occurrence", "Base::Anything"],
+            "ItemDefinition" => &[
+                "Items::Item",
+                "Objects::Object",
+                "Occurrences::Occurrence",
+                "Base::Anything",
+            ],
+            "PartDefinition" => &[
+                "Parts::Part",
+                "Items::Item",
+                "Objects::Object",
+                "Occurrences::Occurrence",
+                "Base::Anything",
+            ],
+            "Structure" => &[
+                "Objects::Object",
+                "Occurrences::Occurrence",
+                "Base::Anything",
+            ],
+            "DataType" | "AttributeDefinition" => &["Base::DataValue", "Base::Anything"],
+            "Behavior" => &[
+                "Performances::Performance",
+                "Occurrences::Occurrence",
+                "Base::Anything",
+            ],
+            "Function" => &[
+                "Performances::Evaluation",
+                "Performances::Performance",
+                "Occurrences::Occurrence",
+                "Base::Anything",
+            ],
+            _ => return None,
+        };
+        names
+            .iter()
+            .map(|name| self.required_role(b, name, steps))
+            .collect()
+    }
+
+    /// Resolve a canonical loaded library role under the same bounded identity
+    /// authority used by required specialization-family certificates.
+    pub(super) fn library_role(
+        &mut self,
+        b: &mut Builder,
+        name: &'static str,
+        steps: &mut usize,
+    ) -> Option<usize> {
+        if !self.current(b) {
+            return None;
+        }
+        self.refresh_planner_state(b, steps)?;
+        self.evidence.index(b, steps)?;
+        if !self.evidence.ids_unique {
+            return None;
+        }
+        self.required_role(b, name, steps)
+    }
+
+    fn required_role(
+        &mut self,
+        b: &mut Builder,
+        name: &'static str,
+        steps: &mut usize,
+    ) -> Option<usize> {
+        charge(steps, 1)?;
+        if self.required_library.is_none() {
+            charge(steps, b.lib_qnames.len())?;
+            let mut ids: HashMap<&'static str, Option<uuid::Uuid>> = HashMap::new();
+            for (id, segments) in b.lib_qnames.iter() {
+                let name = match segments.as_slice() {
+                    [p, t, n]
+                        if p == "Occurrences" && t == "Occurrence" && n == "suboccurrences" =>
+                    {
+                        "Occurrences::Occurrence::suboccurrences"
+                    }
+                    [p, t, n] if p == "Objects" && t == "Object" && n == "subobjects" => {
+                        "Objects::Object::subobjects"
+                    }
+                    [p, t, n] if p == "Items" && t == "Item" && n == "subitems" => {
+                        "Items::Item::subitems"
+                    }
+                    [p, t, n] if p == "Items" && t == "Item" && n == "subparts" => {
+                        "Items::Item::subparts"
+                    }
+                    [p, n] if p == "Parts" && n == "parts" => "Parts::parts",
+                    [p, n] if p == "Items" && n == "items" => "Items::items",
+                    [p, n] if p == "Parts" && n == "Part" => "Parts::Part",
+                    [p, n] if p == "Items" && n == "Item" => "Items::Item",
+                    [p, n] if p == "Links" && n == "SelfLink" => "Links::SelfLink",
+                    [p, n] if p == "Occurrences" && n == "HappensLink" => {
+                        "Occurrences::HappensLink"
+                    }
+                    [p, n] if p == "Actions" && n == "Action" => "Actions::Action",
+                    [p, n] if p == "Base" && n == "Anything" => "Base::Anything",
+                    [p, n] if p == "Base" && n == "things" => "Base::things",
+                    [p, n] if p == "Base" && n == "dataValues" => "Base::dataValues",
+                    [p, n] if p == "Occurrences" && n == "occurrences" => {
+                        "Occurrences::occurrences"
+                    }
+                    [p, n] if p == "Objects" && n == "objects" => "Objects::objects",
+                    [p, n] if p == "Performances" && n == "performances" => {
+                        "Performances::performances"
+                    }
+                    [p, n] if p == "Performances" && n == "evaluations" => {
+                        "Performances::evaluations"
+                    }
+                    [p, n] if p == "Base" && n == "DataValue" => "Base::DataValue",
+                    [p, n] if p == "Occurrences" && n == "Occurrence" => "Occurrences::Occurrence",
+                    [p, n] if p == "Objects" && n == "Object" => "Objects::Object",
+                    [p, n] if p == "Performances" && n == "Performance" => {
+                        "Performances::Performance"
+                    }
+                    [p, n] if p == "Performances" && n == "Evaluation" => {
+                        "Performances::Evaluation"
+                    }
+                    _ => continue,
+                };
+                ids.entry(name)
+                    .and_modify(|known| {
+                        if *known != Some(*id) {
+                            *known = None;
+                        }
+                    })
+                    .or_insert(Some(*id));
+            }
+            let mut resolved = HashMap::new();
+            for (name, id) in ids {
+                let kind = match name {
+                    "Parts::parts" | "Items::Item::subparts" => "PartUsage",
+                    "Items::items" | "Items::Item::subitems" => "ItemUsage",
+                    "Occurrences::Occurrence::suboccurrences" | "Objects::Object::subobjects" => {
+                        "Feature"
+                    }
+                    "Parts::Part" => "PartDefinition",
+                    "Items::Item" => "ItemDefinition",
+                    "Occurrences::Occurrence" => "Class",
+                    "Links::SelfLink" | "Occurrences::HappensLink" => "Association",
+                    "Actions::Action" => "ActionDefinition",
+                    "Base::things"
+                    | "Base::dataValues"
+                    | "Occurrences::occurrences"
+                    | "Objects::objects" => "Feature",
+                    "Performances::performances" => "Step",
+                    "Performances::evaluations" => "Expression",
+                    "Objects::Object" => "Structure",
+                    "Base::DataValue" => "DataType",
+                    "Performances::Performance" => "Behavior",
+                    "Performances::Evaluation" => "Function",
+                    _ => "Classifier",
+                };
+                let target = id
+                    .and_then(|id| b.element_index_of_uuid(id))
+                    .filter(|&e| e < b.lib_boundary && conforms(b.elements[e].ty, kind));
+                resolved.insert(name, target);
+            }
+            self.required_library = Some(resolved);
+        }
+        self.required_library.as_ref()?.get(name).copied().flatten()
+    }
+
+    fn walk(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        general: usize,
+        depth: usize,
+        active: &mut HashSet<usize>,
+        steps: &mut usize,
+    ) -> RelationFact {
+        if charge(steps, 1).is_none()
+            || depth > super::MAX_RESOLUTION_DEPTH
+            || !b
+                .elements
+                .get(specific)
+                .is_some_and(|e| conforms(e.ty, "Type"))
+            || !b
+                .elements
+                .get(general)
+                .is_some_and(|e| conforms(e.ty, "Type"))
+        {
+            return RelationFact::Unknown;
+        }
+        if specific == general {
+            return RelationFact::Yes;
+        }
+        if let Some(&known) = self.known.get(&(specific, general, depth)) {
+            return if known {
+                RelationFact::Yes
+            } else {
+                RelationFact::No
+            };
+        }
+        if !active.insert(specific) {
+            return RelationFact::Unknown;
+        }
+        let fact = match self.direct_bases(b, specific, steps) {
+            None => RelationFact::Unknown,
+            Some(bases) => {
+                let mut complete = bases.complete;
+                let mut positive = false;
+                for target in bases.targets {
+                    match self.walk(b, target, general, depth + 1, active, steps) {
+                        RelationFact::Yes => {
+                            positive = true;
+                            break;
+                        }
+                        RelationFact::Unknown => complete = false,
+                        RelationFact::No => {}
+                    }
+                }
+                if positive {
+                    RelationFact::Yes
+                } else if complete {
+                    RelationFact::No
+                } else {
+                    RelationFact::Unknown
+                }
+            }
+        };
+        active.remove(&specific);
+        if let RelationFact::Yes | RelationFact::No = fact {
+            self.known
+                .insert((specific, general, depth), fact == RelationFact::Yes);
+        }
+        fact
+    }
+
+    /// The direct stored reader shared by exact explicit-only operations and
+    /// qualified specialization evidence. No implied provider is invoked here.
+    fn stored_base_projection(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        exclude_implied: bool,
+        steps: &mut usize,
+    ) -> Option<StoredBases> {
+        if !self.current(b) || !b.dynamic_evidence_current(specific) {
+            return None;
+        }
+        self.refresh_planner_state(b, steps)?;
+        charge(steps, 1)?;
+        if !conforms(b.elements.get(specific)?.ty, "Type") {
+            return None;
+        }
+        if b.id_index.is_none() || b.id_index_built_for != b.elements.len() {
+            charge(steps, b.elements.len())?;
+        }
+        self.evidence.index(b, steps)?;
+        if self.evidence.incomplete()
+            || self.evidence.bad_bases.contains(&specific)
+            || self.evidence.bad_chains.contains(&specific)
+        {
+            return None;
+        }
+        let relationships = self.evidence.relationships(b, specific, steps)?;
+        let mut unique = HashSet::new();
+        if relationships
+            .iter()
+            .any(|&r| !unique.insert(r) || b.elements.get(r).is_none())
+        {
+            return None;
+        }
+        for &relationship in &relationships {
+            if self.evidence.carrier(b, relationship, steps)? != Some(specific) {
+                return None;
+            }
+        }
+        let conjugations: Vec<_> = relationships
+            .iter()
+            .copied()
+            .filter(|&r| conforms(b.elements[r].ty, "Conjugation"))
+            .collect();
+        let mut targets = Vec::new();
+        let mut target_set = HashSet::new();
+        let mut complete = true;
+        let mut duplicate_targets = false;
+        let mut final_chain = None;
+        let mut feature_chain_complete = true;
+        if b.elements[specific]
+            .props
+            .get("isConjugated")
+            .is_some_and(|value| value.as_bool() != Some(!conjugations.is_empty()))
+        {
+            return None;
+        }
+        let conjugated = !conjugations.is_empty();
+        if conjugated {
+            self.owned_conjugation(b, specific, steps)??;
+            // Conjugation replaces ordinary owned specializations, even if
+            // they appear earlier in declaration order.
+            if conjugations.len() != 1 {
+                return None;
+            }
+            let target = endpoint(
+                b,
+                specific,
+                conjugations[0],
+                &["conjugatedType"],
+                &["originalType"],
+                "Type",
+                steps,
+            )?;
+            target_set.insert(target);
+            targets.push(target);
+        } else {
+            for &r in &relationships {
+                if !conforms(b.elements[r].ty, "Specialization") {
+                    continue;
+                }
+                let relation = &b.elements[r];
+                if let (true, Some(value)) = (exclude_implied, relation.props.get("isImplied")) {
+                    match value.as_bool() {
+                        Some(true) => continue,
+                        Some(false) => {}
+                        None => {
+                            complete = false;
+                            continue;
+                        }
+                    }
+                }
+                // Keep independent old result Subsetting witnesses usable, but
+                // never traverse a stale optional result Redefinition row.
+                if !b.result_redefinition_row_current(r) || !b.static_chain_row_current(r) {
+                    complete = false;
+                    continue;
+                }
+                let (source_kind, target_kind) = if conforms(relation.ty, "Subsetting") {
+                    ("Feature", "Feature")
+                } else if conforms(relation.ty, "FeatureTyping") {
+                    ("Feature", "Type")
+                } else if conforms(relation.ty, "Subclassification") {
+                    ("Classifier", "Classifier")
+                } else {
+                    ("Type", "Type")
+                };
+                let target = conforms(b.elements[specific].ty, source_kind)
+                    .then(|| {
+                        endpoint(
+                            b,
+                            specific,
+                            r,
+                            &[
+                                "specific",
+                                "subclassifier",
+                                "typedFeature",
+                                "subsettingFeature",
+                                "redefiningFeature",
+                                "referencingFeature",
+                                "crossingFeature",
+                            ],
+                            &[
+                                "general",
+                                "superclassifier",
+                                "type",
+                                "subsettedFeature",
+                                "redefinedFeature",
+                                "referencedFeature",
+                                "crossedFeature",
+                            ],
+                            target_kind,
+                            steps,
+                        )
+                    })
+                    .flatten();
+                match target {
+                    Some(target) if target_set.insert(target) => targets.push(target),
+                    Some(_) => duplicate_targets = true,
+                    None => complete = false,
+                }
+            }
+        }
+        // Feature::supertypes appends the final chaining feature to the Type
+        // result. Do not let a missing link masquerade as an unchained feature.
+        if conforms(b.elements[specific].ty, "Feature") {
+            let raw = super::structural_index::StoredStructure::for_query(b, steps)?;
+            match checked_feature_target(b, &raw, specific, &relationships, b.elements.len(), steps)
+            {
+                Some(last) => {
+                    if let Some(target) = last.filter(|&target| target != specific) {
+                        final_chain = Some(target);
+                        duplicate_targets |= target_set.contains(&target);
+                    }
+                }
+                None => feature_chain_complete = false,
+            }
+        }
+
+        charge(steps, 0)?;
+        Some(StoredBases {
+            targets,
+            target_set,
+            complete,
+            conjugated,
+            final_chain,
+            duplicate_targets,
+            feature_chain_complete,
+        })
+    }
+
+    /// Checked direct supertypes. The conjugated Type branch ignores the
+    /// argument; ordinary false requires implied-family evidence not provided
+    /// here. Feature still appends its complete, one-hop featureTarget.
+    pub(super) fn checked_supertypes(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        exclude_implied: bool,
+        steps: &mut usize,
+    ) -> Result<Vec<usize>, SupertypesFailure> {
+        // Filtering ordinary Specializations is immaterial for conjugation.
+        // Using the explicit projection avoids interpreting unaudited implied
+        // families even when a nonconjugated false request is rejected below.
+        let mut projection = self
+            .stored_base_projection(b, specific, true, steps)
+            .ok_or(SupertypesFailure::Incomplete)?;
+        if !projection.complete
+            || !projection.feature_chain_complete
+            || projection.duplicate_targets
+        {
+            return Err(SupertypesFailure::Incomplete);
+        }
+        if !exclude_implied && !projection.conjugated {
+            return Err(SupertypesFailure::UnsupportedConfiguration);
+        }
+        if let Some(target) = projection.final_chain {
+            projection.targets.push(target);
+        }
+        charge(steps, projection.targets.len()).ok_or(SupertypesFailure::Incomplete)?;
+        Ok(projection.targets)
+    }
+
+    #[cfg(test)]
+    fn explicit_supertypes(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        self.checked_supertypes(b, specific, true, steps).ok()
+    }
+
+    /// Complete ordered bases from the shared current-row/provider authority.
+    /// A partial positive path is not a certificate of absent additional bases.
+    pub(super) fn complete_direct_bases(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        let bases = self.direct_bases(b, specific, steps)?;
+        bases.complete.then_some(bases.targets)
+    }
+
+    fn direct_bases(
+        &mut self,
+        b: &mut Builder,
+        specific: usize,
+        steps: &mut usize,
+    ) -> Option<Bases> {
+        if !self.current(b) || !b.dynamic_evidence_current(specific) {
+            return None;
+        }
+        self.refresh_planner_state(b, steps)?;
+        charge(steps, 1)?;
+        if let Some(bases) = self.bases.get(&specific) {
+            charge(steps, bases.targets.len())?;
+            return Some(bases.clone());
+        }
+        let projection = self.stored_base_projection(b, specific, false, steps)?;
+        let mut targets = projection.targets;
+        let mut target_set = projection.target_set;
+        let mut complete = projection.complete;
+        let mut required = Vec::new();
+        if !projection.conjugated {
+            // The provider establishes the supported implied/positional base
+            // evidence and preserves caller lookup state. An incomplete
+            // provider does not invalidate an already proven explicit path.
+            let provider = b
+                .elem_scope
+                .get(&specific)
+                .copied()
+                .is_some_and(|scope| self.providers.scope(b, scope, steps));
+            if provider && complete {
+                match b.value_context_bases(specific, steps) {
+                    Some(bases) => {
+                        for target in bases {
+                            charge(steps, 1)?;
+                            if target_set.insert(target) {
+                                targets.push(target);
+                            }
+                        }
+                    }
+                    None => complete = false,
+                }
+            } else {
+                complete = false;
+            }
+            match self.required_bases(b, specific, steps) {
+                Some(targets) => required = targets,
+                None => complete = false,
+            }
+        }
+        if let Some(target) = projection.final_chain {
+            if target_set.insert(target) {
+                targets.push(target);
+            }
+        }
+        complete &= projection.feature_chain_complete;
+        charge(steps, targets.len())?;
+        self.refresh_planner_state(b, steps)?;
+        // Publish only a provisional nonnegative row while verifying required
+        // paths through the same stored/shared graph. Never invent a second
+        // set of implicit edges here.
+        self.bases.insert(
+            specific,
+            Bases {
+                targets: targets.clone(),
+                complete: false,
+            },
+        );
+        if complete {
+            for target in required {
+                if self.walk(b, specific, target, 0, &mut HashSet::new(), steps)
+                    != RelationFact::Yes
+                {
+                    complete = false;
+                    break;
+                }
+            }
+        }
+        if *steps > crate::eval::MAX_STEPS {
+            self.bases.remove(&specific);
+            return None;
+        }
+        let bases = Bases { targets, complete };
+        if complete {
+            self.bases.insert(specific, bases.clone());
+        } else {
+            // Missing cold provider evidence can become available on retry.
+            self.bases.remove(&specific);
+        }
+        Some(bases)
+    }
+}
+
+pub(super) fn endpoint(
+    b: &mut Builder,
+    source: usize,
+    relationship: usize,
+    source_keys: &[&str],
+    target_keys: &[&str],
+    target_kind: &str,
+    steps: &mut usize,
+) -> Option<usize> {
+    endpoint_with_carrier(
+        b,
+        source,
+        Some(source),
+        relationship,
+        source_keys,
+        target_keys,
+        target_kind,
+        steps,
+    )
+}
+
+/// Typed endpoint identity and relationship carrier are distinct for inverse
+/// FeatureTyping/Subsetting. The caller admits carrier cardinality using the
+/// shared structural/semantic ownership view before invoking this validator.
+#[allow(clippy::too_many_arguments)] // Source identity and carrier are independent roles.
+pub(super) fn endpoint_with_carrier(
+    b: &mut Builder,
+    source: usize,
+    carrier: Option<usize>,
+    relationship: usize,
+    source_keys: &[&str],
+    target_keys: &[&str],
+    target_kind: &str,
+    steps: &mut usize,
+) -> Option<usize> {
+    let target = endpoint_id(b, source, carrier, relationship, source_keys, target_keys)?;
+    let target = b.element_index_of_uuid(target)?;
+    checked_endpoint_target(b, source, relationship, target, target_kind, steps)
+}
+
+/// Shared typed alias reader; endpoint identity lookup is supplied by the caller.
+fn endpoint_id(
+    b: &Builder,
+    source: usize,
+    carrier: Option<usize>,
+    relationship: usize,
+    source_keys: &[&str],
+    target_keys: &[&str],
+) -> Option<uuid::Uuid> {
+    let relation = b.elements.get(relationship)?;
+    let source_id = b.elements.get(source)?.id;
+    if relation
+        .props
+        .get("owningRelatedElement")
+        .is_some_and(|value| {
+            value.as_reference() != carrier.and_then(|owner| b.elements.get(owner).map(|e| e.id))
+        })
+    {
+        return None;
+    }
+    for &key in source_keys {
+        if relation
+            .props
+            .get(key)
+            .is_some_and(|v| v.as_reference() != Some(source_id))
+        {
+            return None;
+        }
+    }
+    let mut target = None;
+    for &key in target_keys {
+        if let Some(value) = relation.props.get(key) {
+            let id = value.as_reference()?;
+            if target.is_some_and(|previous| previous != id) {
+                return None;
+            }
+            target = Some(id);
+        }
+    }
+    target
+}
+
+fn checked_endpoint_target(
+    b: &Builder,
+    source: usize,
+    relationship: usize,
+    target: usize,
+    target_kind: &str,
+    steps: &mut usize,
+) -> Option<usize> {
+    if !conforms(b.elements.get(target)?.ty, target_kind) {
+        return None;
+    }
+    validate_relationship_arrays(b, relationship, source, target, steps)?;
+    Some(target)
+}
+
+/// Project the owned TypeFeaturing source without inventing a compact property.
+/// Explicit source identity and the carrier are distinct for standalone rows.
+/// Present aliases must agree; only genuine absence permits carrier fallback.
+pub(super) fn type_featuring_source(
+    b: &mut Builder,
+    relationship: usize,
+    steps: &mut usize,
+) -> Option<uuid::Uuid> {
+    charge(steps, 1)?;
+    if b.positional_planning || b.elements.get(relationship)?.ty != "TypeFeaturing" {
+        return None;
+    }
+    let raw = super::structural_index::StoredStructure::for_query(b, steps)?;
+    let carrier = semantic_ownership::checked_relationship_carrier(b, &raw, relationship, steps)?;
+    let side = |typed: &str, generic: &str, steps: &mut usize| -> Option<Option<uuid::Uuid>> {
+        charge(steps, 2)?;
+        let relation = &b.elements[relationship];
+        let mut value = match relation.props.get(typed) {
+            Some(value) => Some(value.as_reference()?),
+            None => None,
+        };
+        if let Some(array) = relation.props.get(generic) {
+            let array = array.as_array()?;
+            charge(steps, array.len())?;
+            if array.len() != 1 {
+                return None;
+            }
+            let id = array[0].as_reference()?;
+            if value.is_some_and(|value| value != id) {
+                return None;
+            }
+            value = Some(id);
+        }
+        Some(value)
+    };
+    let source = side("featureOfType", "source", steps)?
+        .or_else(|| carrier.map(|owner| b.elements[owner].id))?;
+    charge(steps, 1)?;
+    // Preserve explicit external UUIDs, as ordinary checked owned properties
+    // do. A carrier fallback always names a known local Feature.
+    if let Some(index) = raw.element_for_uuid(b, source) {
+        if !conforms(b.elements[index].ty, "Feature") {
+            return None;
+        }
+    }
+    if let Some(value) = b.elements[relationship].props.get("owningFeatureOfType") {
+        charge(steps, 1)?;
+        let owner = carrier.filter(|&owner| {
+            b.elements[owner].id == source && conforms(b.elements[owner].ty, "Feature")
+        });
+        if match owner {
+            Some(owner) => value.as_reference() != Some(b.elements[owner].id),
+            None => !value.is_null(),
+        } {
+            return None;
+        }
+    }
+    validate_single_relationship_end(b, relationship, "source", source, steps)?;
+    // Reading the source does not require resolving the unrelated target. The
+    // generic ordered endpoints may nevertheless not contradict this source.
+    // Only the first position is read: target multiplicity belongs to its own
+    // checked property, and no tail scan or copy is needed for source identity.
+    if let Some(value) = b.elements[relationship].props.get("relatedElement") {
+        let values = value.as_array()?;
+        charge(steps, 1)?;
+        if values.first().and_then(|value| value.as_reference()) != Some(source) {
+            return None;
+        }
+    }
+    Some(source)
+}
+
+fn validate_single_relationship_end(
+    b: &Builder,
+    relationship: usize,
+    key: &str,
+    expected: uuid::Uuid,
+    steps: &mut usize,
+) -> Option<()> {
+    if let Some(value) = b.elements.get(relationship)?.props.get(key) {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != 1 || values[0].as_reference() != Some(expected) {
+            return None;
+        }
+    }
+    Some(())
+}
+
+/// Derived one-hop bases retained by the common static planner. This is an
+/// input certificate inside that authority, not a separate semantic cache.
+#[derive(Default)]
+pub(super) struct FeatureChainBases {
+    pub(super) targets: HashMap<usize, usize>,
+    pub(super) incomplete: HashSet<usize>,
+}
+
+impl Builder {
+    pub(super) fn checked_chain_bases(
+        &mut self,
+        boundary: usize,
+        mut steps: Option<&mut usize>,
+    ) -> Option<std::sync::Arc<FeatureChainBases>> {
+        fn budget(steps: &mut Option<&mut usize>, amount: usize) -> Option<()> {
+            if let Some(steps) = steps {
+                charge(steps, amount)?;
+            }
+            Some(())
+        }
+        budget(&mut steps, boundary)?;
+        let mut result = FeatureChainBases::default();
+        if !self
+            .elements
+            .iter()
+            .take(boundary)
+            .any(|e| conforms(e.ty, "FeatureChaining"))
+        {
+            return Some(std::sync::Arc::new(result));
+        }
+        let mut local = 0;
+        let raw = super::structural_index::StoredStructure::for_query(
+            self,
+            steps.as_deref_mut().unwrap_or(&mut local),
+        );
+        let Some(raw) = raw else {
+            if steps.is_some() {
+                return None;
+            }
+            // The legacy unbounded planner must not panic when its bounded
+            // identity reader cannot certify an unusually large/malformed graph.
+            // Preserve qualification for every potentially affected Feature.
+            for feature in 0..boundary {
+                if conforms(self.elements[feature].ty, "Feature") {
+                    result.incomplete.insert(feature);
+                }
+            }
+            return Some(std::sync::Arc::new(result));
+        };
+        for feature in 0..boundary {
+            budget(&mut steps, 1)?;
+            if !conforms(self.elements[feature].ty, "Feature") {
+                continue;
+            }
+            let relationships = &self.elements[feature].owned_relationships;
+            budget(&mut steps, relationships.len())?;
+            if raw.incomplete() {
+                result.incomplete.insert(feature);
+                continue;
+            }
+            if !raw.bad_chains.contains(&feature)
+                && !relationships.iter().any(|&r| {
+                    self.elements
+                        .get(r)
+                        .is_none_or(|e| conforms(e.ty, "FeatureChaining"))
+                })
+            {
+                continue;
+            }
+            local = 0;
+            match checked_feature_target(
+                self,
+                &raw,
+                feature,
+                relationships,
+                boundary,
+                steps.as_deref_mut().unwrap_or(&mut local),
+            ) {
+                Some(Some(target)) if target != feature => {
+                    result.targets.insert(feature, target);
+                }
+                Some(_) => {}
+                None => {
+                    result.incomplete.insert(feature);
+                }
+            }
+            budget(&mut steps, 0)?;
+        }
+        Some(std::sync::Arc::new(result))
+    }
+}
+
+/// Checked one-hop Feature::featureTarget input. The caller supplies its complete
+/// stored or semantic owned-relationship projection. Every chaining endpoint is
+/// validated even though only the last contributes a base. No recursive flattening
+/// or fabricated Specialization relationship is performed here.
+pub(super) fn checked_feature_target(
+    b: &Builder,
+    raw: &super::structural_index::StoredStructure,
+    feature: usize,
+    relationships: &[usize],
+    endpoint_boundary: usize,
+    steps: &mut usize,
+) -> Option<Option<usize>> {
+    charge(steps, 1)?;
+    if !raw.ids_unique
+        || !raw.is_current(b)
+        || raw.bad_chains.contains(&feature)
+        || !conforms(b.elements.get(feature)?.ty, "Feature")
+    {
+        return None;
+    }
+    charge(steps, relationships.len())?;
+    let mut seen = HashSet::new();
+    let mut last = None;
+    for &relationship in relationships {
+        if !seen.insert(relationship) {
+            return None;
+        }
+        let relation = b.elements.get(relationship)?;
+        if !conforms(relation.ty, "FeatureChaining") {
+            continue;
+        }
+        if relationship >= endpoint_boundary
+            || semantic_ownership::checked_relationship_carrier(b, raw, relationship, steps)?
+                != Some(feature)
+        {
+            return None;
+        }
+        let id = endpoint_id(
+            b,
+            feature,
+            Some(feature),
+            relationship,
+            &["featureChained"],
+            &["chainingFeature"],
+        )?;
+        let target = raw.element_for_uuid(b, id)?;
+        let target = checked_endpoint_target(b, feature, relationship, target, "Feature", steps)?;
+        if target >= endpoint_boundary {
+            return None;
+        }
+        last = Some(target);
+    }
+    Some(last)
+}
+
+/// Redundant generic Relationship ends must agree with the typed endpoints.
+/// The actual owning element is deliberately separate from `source`: a valid
+/// standalone TypeFeaturing can be carried by a package while featuring a
+/// Feature declared elsewhere. relatedElement is a non-unique Sequence.
+pub(super) fn validate_relationship_arrays(
+    b: &Builder,
+    relationship: usize,
+    source: usize,
+    target: usize,
+    steps: &mut usize,
+) -> Option<()> {
+    charge(steps, 1)?;
+    let relation = b.elements.get(relationship)?;
+    let source = b.elements.get(source)?.id;
+    let target = b.elements.get(target)?.id;
+    for (key, expected) in [("source", source), ("target", target)] {
+        validate_single_relationship_end(b, relationship, key, expected, steps)?;
+    }
+    if let Some(value) = relation.props.get("relatedElement") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != 2
+            || values[0].as_reference() != Some(source)
+            || values[1].as_reference() != Some(target)
+        {
+            return None;
+        }
+    }
+    charge(steps, relation.children.len())?;
+    let mut owned = HashSet::new();
+    for &child in &relation.children {
+        if !owned.insert(child) {
+            return None;
+        }
+        let child = b.elements.get(child)?;
+        if child.owning_relationship != Some(relationship)
+            || (child.id != source && child.id != target)
+        {
+            return None;
+        }
+    }
+    if let Some(value) = relation.props.get("ownedRelatedElement") {
+        let values = value.as_array()?;
+        charge(steps, values.len())?;
+        if values.len() != relation.children.len()
+            || values
+                .iter()
+                .zip(relation.children.iter())
+                .any(|(value, &child)| value.as_reference() != Some(b.elements[child].id))
+        {
+            return None;
+        }
+    }
+    Some(())
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn held_positive_refuses_replaced_retained_plan_with_identical_boolean_state() {
+        let mut model = crate::model::Model::new();
+        model.add_library_source(
+            "roles.kerml",
+            "standard library package Occurrences {class Occurrence;}",
+        );
+        model.add_source("name-generation.kerml", "class C;");
+        let mut r = crate::json::ResolvedModel::build(&model);
+        let c = r.resolve_qualified("C").unwrap().0;
+        let occurrence = r.resolve_qualified("Occurrences::Occurrence").unwrap().0;
+        let mut proof = TypeRelations::default();
+        assert_eq!(
+            proof.specializes(&mut r.b, c, occurrence, &mut 0),
+            RelationFact::Yes
+        );
+        let state = proof.planner_state;
+        let retained = proof.retained_plan.clone().unwrap();
+        let rows = r.b.elements.len();
+        r.set_library_names(&HashMap::from([(
+            uuid::Uuid::new_v4().to_string(),
+            vec!["Occurrences".into(), "Occurrence".into()],
+        )]));
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert_eq!(rows, r.b.elements.len());
+        assert_eq!(
+            state,
+            Some((r.b.semantic_ready, r.b.positional_redefinitions.is_some()))
+        );
+        assert!(!std::sync::Arc::ptr_eq(
+            &retained,
+            r.b.supported_implied.as_ref().unwrap()
+        ));
+        let mut steps = crate::eval::MAX_STEPS;
+        assert_eq!(
+            proof.specializes(&mut r.b, c, occurrence, &mut steps),
+            RelationFact::Unknown
+        );
+        assert!(
+            std::sync::Arc::ptr_eq(&retained, proof.retained_plan.as_ref().unwrap()),
+            "refused invalidation must not refresh its authority"
+        );
+        assert_eq!(
+            proof.specializes(&mut r.b, c, occurrence, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, c, occurrence, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+
+    #[test]
+    fn held_relation_query_rechecks_after_positional_preparation() {
+        let mut model = crate::model::Model::new();
+        model.add_library_source(
+            "planner-library.kerml",
+            "standard library package Occurrences {class Occurrence;}",
+        );
+        model.add_source("planner-state.kerml", "class C;");
+        let mut r = crate::json::ResolvedModel::build(&model);
+        let p = r.resolve_qualified("Occurrences::Occurrence").unwrap().0;
+        let q = r.resolve_qualified("C").unwrap().0;
+        r.b.positional_redefinitions = None;
+        r.b.semantic_ready = false;
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.specializes(&mut r.b, q, p, &mut 0), RelationFact::Yes);
+        assert!(!proof.known.is_empty());
+        r.b.semantic_ready = true;
+        assert!(r.b.ensure_positional_redefinitions_with_budget(&mut 0));
+        assert!(proof.refresh_planner_state(&mut r.b, &mut 0).is_some());
+        assert!(
+            proof.known.is_empty(),
+            "the old positive requires fresh evidence"
+        );
+        assert_eq!(proof.specializes(&mut r.b, q, p, &mut 0), RelationFact::Yes);
+    }
+
+    #[test]
+    fn a_decisive_negative_refutes_universal_compatibility_in_either_order() {
+        use RelationFact::*;
+        assert_eq!(RelationFact::all([]), Yes);
+        assert_eq!(RelationFact::all([Yes, Yes]), Yes);
+        assert_eq!(RelationFact::all([Yes, Unknown]), Unknown);
+        assert_eq!(RelationFact::all([Unknown, No]), No);
+        assert_eq!(RelationFact::all([No, Unknown]), No);
+        assert_eq!(RelationFact::all([Yes, Unknown, No, Yes]), No);
+    }
+
+    use super::*;
+    use crate::{
+        json::{ResolvedModel, id_ref},
+        model::Model,
+    };
+
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_library_source("bases.kerml", "standard library package Base {classifier Anything; datatype DataValue specializes Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Objects {struct Object specializes Occurrences::Occurrence;}");
+        let unit = model.add_source("relations.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn conjugation_precedence_and_chain_target_use_stored_identities() {
+        let mut r = fixture(
+            "class A; class B; class C conjugates A; class D conjugates C; class E specializes C; class T { feature b; } feature a : T; feature chain chains a.b;",
+        );
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let d = r.resolve_qualified("D").unwrap().0;
+        let e = r.resolve_qualified("E").unwrap().0;
+        let chain = r.resolve_qualified("chain").unwrap().0;
+        let end = r.resolve_qualified("T::b").unwrap().0;
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.specializes(&mut r.b, c, a, &mut 0), RelationFact::Yes);
+        assert_eq!(proof.specializes(&mut r.b, c, b, &mut 0), RelationFact::No);
+        assert_eq!(proof.specializes(&mut r.b, c, c, &mut 0), RelationFact::No);
+        assert_eq!(proof.specializes(&mut r.b, d, c, &mut 0), RelationFact::No);
+        assert_eq!(proof.specializes(&mut r.b, d, a, &mut 0), RelationFact::Yes);
+        assert_eq!(proof.specializes(&mut r.b, e, c, &mut 0), RelationFact::Yes);
+        assert_eq!(proof.specializes(&mut r.b, e, a, &mut 0), RelationFact::Yes);
+        // Reusing closure facts for E must not restore C receiver reflexivity.
+        assert_eq!(proof.specializes(&mut r.b, c, c, &mut 0), RelationFact::No);
+        assert_eq!(proof.specializes(&mut r.b, d, c, &mut 0), RelationFact::No);
+        assert_eq!(
+            proof.specializes(&mut r.b, chain, end, &mut 0),
+            RelationFact::Yes
+        );
+        // Manufacture mixed stored evidence without relying on invalid syntax:
+        // conjugation must still take precedence over the extra specialization.
+        let extra = r.b.new_relationship("Specialization", c, "extra");
+        let b_id = r.b.elem_id(b);
+        r.b.set(extra, "general", id_ref(b_id));
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.specializes(&mut r.b, c, b, &mut 0), RelationFact::No);
+        assert_eq!(proof.specializes(&mut r.b, c, a, &mut 0), RelationFact::Yes);
+    }
+
+    #[test]
+    fn missing_conflicting_and_cyclic_evidence_never_proves_absence() {
+        let mut r = fixture(
+            "class A; class B; class C specializes A, Missing; class Cycle specializes Cycle; class Good specializes A;",
+        );
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let cycle = r.resolve_qualified("Cycle").unwrap().0;
+        let good = r.resolve_qualified("Good").unwrap().0;
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.specializes(&mut r.b, c, a, &mut 0), RelationFact::Yes);
+        assert_eq!(
+            proof.specializes(&mut r.b, c, b, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            proof.specializes(&mut r.b, cycle, b, &mut 0),
+            RelationFact::Unknown
+        );
+        let relation = r.b.elements[good]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "Specialization"))
+            .unwrap();
+        let b_id = r.b.elem_id(b);
+        r.b.set(relation, "general", id_ref(b_id));
+        let mut proof = TypeRelations::default();
+        assert_eq!(
+            proof.specializes(&mut r.b, good, a, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            proof.specializes(&mut r.b, good, b, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+
+    #[test]
+    fn conjugator_failure_precedes_reflexivity_but_unrelated_base_failure_does_not() {
+        let mut r = fixture(
+            "class MissingOriginal conjugates Missing; class Loop conjugates Loop; class Ordinary specializes Missing;",
+        );
+        for name in ["MissingOriginal", "Loop"] {
+            let element = r.resolve_qualified(name).unwrap().0;
+            assert_eq!(
+                TypeRelations::default().specializes(&mut r.b, element, element, &mut 0),
+                RelationFact::Unknown
+            );
+        }
+        let ordinary = r.resolve_qualified("Ordinary").unwrap().0;
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, ordinary, ordinary, &mut 0),
+            RelationFact::Yes
+        );
+    }
+
+    #[test]
+    fn budget_exhaustion_does_not_poison_a_later_query() {
+        let mut r = fixture("class A; class B specializes A;");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let mut proof = TypeRelations::default();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            proof.specializes(&mut r.b, b, a, &mut exhausted),
+            RelationFact::Unknown
+        );
+        assert_eq!(proof.specializes(&mut r.b, b, a, &mut 0), RelationFact::Yes);
+        exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            proof.specializes(&mut r.b, b, a, &mut exhausted),
+            RelationFact::Unknown
+        );
+    }
+}
+
+/// Query-local semantic witnesses over a shared immutable stored graph index.
+#[derive(Default)]
+struct FeaturingEvidence {
+    structure: std::sync::Arc<super::structural_index::StoredStructure>,
+    owners: HashMap<usize, Option<Option<usize>>>,
+    featuring: HashMap<usize, Vec<usize>>,
+}
+impl std::ops::Deref for FeaturingEvidence {
+    type Target = super::structural_index::StoredStructure;
+    fn deref(&self) -> &Self::Target {
+        &self.structure
+    }
+}
+impl FeaturingEvidence {
+    fn carrier(&self, b: &Builder, relation: usize, steps: &mut usize) -> Option<Option<usize>> {
+        semantic_ownership::checked_relationship_carrier(b, &self.structure, relation, steps)
+    }
+    fn relationships(&self, b: &Builder, owner: usize, steps: &mut usize) -> Option<Vec<usize>> {
+        let rows = semantic_ownership::owned_relationships(b, owner)?;
+        charge(steps, rows.len())?;
+        Some(rows.iter().collect())
+    }
+    fn index(&mut self, b: &mut Builder, steps: &mut usize) -> Option<()> {
+        if self.structure.is_current(b) {
+            charge(steps, 1)?;
+            return Some(());
+        }
+        self.structure = super::structural_index::StoredStructure::get(b, steps)?;
+        self.owners.clear();
+        self.featuring.clear();
+        Some(())
+    }
+
+    fn owning_type(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        self.index(b, steps)?;
+        if self.incomplete() {
+            return None;
+        }
+        if let Some(&owner) = self.owners.get(&feature) {
+            return owner;
+        }
+        let result = self.inspect_owner(b, feature, steps);
+        if *steps <= crate::eval::MAX_STEPS {
+            self.owners.insert(feature, result);
+        }
+        result
+    }
+
+    fn inspect_owner(
+        &self,
+        b: &Builder,
+        feature: usize,
+        steps: &mut usize,
+    ) -> Option<Option<usize>> {
+        charge(steps, 1)?;
+        let e = b.elements.get(feature)?;
+        if !conforms(e.ty, "Feature") {
+            return None;
+        }
+        let rel = match e.owning_relationship {
+            Some(rel) => rel,
+            None => return Some(None),
+        };
+        let membership = b.elements.get(rel)?;
+        if !conforms(membership.ty, "OwningMembership") {
+            return None;
+        }
+        let owner = self.carrier(b, rel, steps)??;
+        if *membership.children != [feature] {
+            return None;
+        }
+        validate_relationship_arrays(b, rel, owner, feature, steps)?;
+        for key in ["memberElement", "ownedMemberElement", "ownedMemberFeature"] {
+            if membership
+                .props
+                .get(key)
+                .is_some_and(|value| value.as_reference() != Some(e.id))
+            {
+                return None;
+            }
+        }
+        for key in ["membershipOwningNamespace", "owningType"] {
+            if membership
+                .props
+                .get(key)
+                .is_some_and(|value| value.as_reference() != Some(b.elements[owner].id))
+            {
+                return None;
+            }
+        }
+        if conforms(membership.ty, "FeatureMembership") {
+            conforms(b.elements[owner].ty, "Type").then_some(Some(owner))
+        } else {
+            Some(None)
+        }
+    }
+
+    fn featuring_types(
+        &mut self,
+        b: &mut Builder,
+        feature: usize,
+        active: &mut HashSet<usize>,
+        steps: &mut usize,
+    ) -> Option<Vec<usize>> {
+        if !b.local_featuring_evidence_current(feature) {
+            return None;
+        }
+        self.index(b, steps)?;
+        if self.incomplete()
+            || self.bad_chains.contains(&feature)
+            || active.len() > super::MAX_RESOLUTION_DEPTH
+        {
+            return None;
+        }
+        charge(steps, 1)?;
+        if let Some(known) = self.featuring.get(&feature) {
+            charge(steps, known.len())?;
+            return Some(known.clone());
+        }
+        if !active.insert(feature) {
+            return None;
+        }
+        let result = (|| {
+            let mut out: Vec<_> = self.owning_type(b, feature, steps)?.into_iter().collect();
+            let mut seen: HashSet<_> = out.iter().copied().collect();
+            let owned = self.relationships(b, feature, steps)?;
+            let inverse_count = self.type_featurings.get(&feature).map_or(0, Vec::len);
+            charge(steps, inverse_count)?;
+            let mut featurings = self
+                .type_featurings
+                .get(&feature)
+                .cloned()
+                .unwrap_or_default();
+            let mut featuring_relations: HashSet<_> = featurings.iter().copied().collect();
+            for &rel in &owned {
+                if conforms(b.elements.get(rel)?.ty, "TypeFeaturing")
+                    && featuring_relations.insert(rel)
+                {
+                    featurings.push(rel);
+                }
+            }
+            charge(steps, featurings.len().saturating_sub(inverse_count))?;
+            for rel in featurings {
+                self.carrier(b, rel, steps)?;
+                let relation = &b.elements[rel];
+                if let Some(source) = relation.props.get("featureOfType") {
+                    if source.as_reference() != Some(b.elements[feature].id) {
+                        return None;
+                    }
+                } else if self.carrier(b, rel, steps)? != Some(feature) {
+                    return None;
+                }
+                let id = relation.props.get("featuringType")?.as_reference()?;
+                let target = b.element_index_of_uuid(id)?;
+                if !conforms(b.elements[target].ty, "Type") {
+                    return None;
+                }
+                validate_relationship_arrays(b, rel, feature, target, steps)?;
+                if seen.insert(target) {
+                    out.push(target);
+                }
+            }
+            let mut first = None;
+            for rel in owned {
+                if !conforms(b.elements.get(rel)?.ty, "FeatureChaining") {
+                    continue;
+                }
+                if self.carrier(b, rel, steps)? != Some(feature) {
+                    return None;
+                }
+                let target = endpoint(
+                    b,
+                    feature,
+                    rel,
+                    &["featureChained"],
+                    &["chainingFeature"],
+                    "Feature",
+                    steps,
+                )?;
+                first.get_or_insert(target);
+            }
+            if let Some(first) = first {
+                for target in self.featuring_types(b, first, active, steps)? {
+                    if seen.insert(target) {
+                        out.push(target);
+                    }
+                }
+            }
+            Some(out)
+        })();
+        active.remove(&feature);
+        if let Some(ref out) = result {
+            self.featuring.insert(feature, out.clone());
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod featuring_evidence_tests {
+    use super::*;
+    use crate::{
+        json::{ResolvedModel, id_ref},
+        model::Model,
+    };
+
+    fn model(source: &str) -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_library_source("bases.kerml","standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}");
+        let parsed = model.add_source("evidence.kerml", source);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn inverse_featuring_and_reciprocal_membership_are_observed() {
+        let mut r = model("class B; class A {feature x;} featuring A::x by B;");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.featuring_types(&mut r.b, x, &mut 0), Some(vec![a, b]));
+        let membership = r.b.elements[x].owning_relationship.unwrap();
+        let wrong = r.b.elem_id(b);
+        r.b.set(membership, "memberElement", id_ref(wrong));
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, x, &mut 0),
+            None
+        );
+    }
+
+    #[test]
+    fn out_of_range_owning_relationship_refuses_domain_without_panicking() {
+        let mut r = model("class A {feature x;}");
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        r.b.elements[x].owning_relationship = Some(r.b.elements.len());
+        assert_eq!(
+            TypeRelations::default().audited_featuring_domain(&mut r.b, &[x], &mut 0),
+            None
+        );
+    }
+
+    #[test]
+    fn contradictory_stored_carrier_cannot_supply_ownership_witness() {
+        let mut r = model("class A {feature container {feature x;}} class B;");
+        let owner = r.resolve_qualified("A::container").unwrap().0;
+        let x = r.resolve_qualified("A::container::x").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let membership = r.b.elements[x].owning_relationship.unwrap();
+        let wrong = r.b.elem_id(b);
+        r.b.set(membership, "owningRelatedElement", id_ref(wrong));
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.featuring_types(&mut r.b, x, &mut 0), None);
+        assert_ne!(proof.has_owned_feature(&mut r.b, owner, &mut 0), Some(true));
+    }
+
+    #[test]
+    fn contradictory_generic_specialization_and_conjugation_arrays_are_unknown() {
+        for declaration in ["class C specializes A;", "class C conjugates A;"] {
+            for key in ["source", "target", "relatedElement", "ownedRelatedElement"] {
+                let mut r = model(&format!("class A; class B; {declaration}"));
+                let a = r.resolve_qualified("A").unwrap().0;
+                let b = r.resolve_qualified("B").unwrap().0;
+                let c = r.resolve_qualified("C").unwrap().0;
+                let relation = r.b.elements[c]
+                    .owned_relationships
+                    .iter()
+                    .copied()
+                    .find(|&r0| {
+                        conforms(r.b.elements[r0].ty, "Specialization")
+                            || conforms(r.b.elements[r0].ty, "Conjugation")
+                    })
+                    .unwrap();
+                let wrong = r.b.elements[b].id;
+                r.b.elements[relation]
+                    .props
+                    .insert(key, serde_json::json!([{"@id":wrong.to_string()}]));
+                assert_eq!(
+                    TypeRelations::default().specializes(&mut r.b, c, a, &mut 0),
+                    RelationFact::Unknown,
+                    "{declaration} {key}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn standalone_featuring_generic_source_is_feature_not_actual_carrier() {
+        let mut r = model("class B; class A {feature x;} featuring A::x by B;");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let relation =
+            r.b.elements
+                .iter()
+                .position(|e| conforms(e.ty, "TypeFeaturing"))
+                .unwrap();
+        let x_id = r.b.elements[x].id;
+        let b_id = r.b.elements[b].id;
+        r.b.elements[relation]
+            .props
+            .insert("source", serde_json::json!([{"@id":x_id.to_string()}]));
+        r.b.elements[relation]
+            .props
+            .insert("target", serde_json::json!([{"@id":b_id.to_string()}]));
+        r.b.elements[relation].props.insert(
+            "relatedElement",
+            serde_json::json!([{"@id":x_id.to_string()},{"@id":b_id.to_string()}]),
+        );
+        r.b.elements[relation]
+            .props
+            .insert("ownedRelatedElement", serde_json::json!([]));
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, x, &mut 0),
+            Some(vec![a, b])
+        );
+        let wrong = r.b.elements[a].id;
+        r.b.elements[relation]
+            .props
+            .insert("target", serde_json::json!([{"@id":wrong.to_string()}]));
+        assert_eq!(
+            TypeRelations::default().featuring_types(&mut r.b, x, &mut 0),
+            None
+        );
+    }
+
+    #[test]
+    fn authored_implied_flags_do_not_bypass_endpoint_checks() {
+        let mut r = model("class A; class B; class C specializes A;");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let relation = r.b.elements[c]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&rel| conforms(r.b.elements[rel].ty, "Specialization"))
+            .unwrap();
+        let wrong = r.b.elements[b].id;
+        r.b.elements[relation]
+            .props
+            .insert("isImplied", serde_json::json!(true));
+        r.b.elements[relation]
+            .props
+            .insert("target", serde_json::json!([{"@id":wrong.to_string()}]));
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, c, a, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+
+    #[test]
+    fn duplicate_owned_related_children_are_not_a_unique_ownership_set() {
+        let mut r = model("class A; class C specializes A;");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let c = r.resolve_qualified("C").unwrap().0;
+        let relation = r.b.elements[c]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&r0| conforms(r.b.elements[r0].ty, "Specialization"))
+            .unwrap();
+        r.b.elements[relation].children = vec![a, a].into();
+        r.b.elements[a].owning_relationship = Some(relation);
+        let id = r.b.elements[a].id;
+        r.b.elements[relation].props.insert(
+            "ownedRelatedElement",
+            serde_json::json!([{"@id":id.to_string()},{"@id":id.to_string()}]),
+        );
+        assert_eq!(
+            validate_relationship_arrays(&r.b, relation, c, a, &mut 0),
+            None
+        );
+    }
+
+    #[test]
+    fn contradictory_generic_membership_array_cannot_supply_owning_type() {
+        let mut r = model("class A {feature x;} class B;");
+        let x = r.resolve_qualified("A::x").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let membership = r.b.elements[x].owning_relationship.unwrap();
+        let wrong = r.b.elements[b].id;
+        r.b.elements[membership]
+            .props
+            .insert("target", serde_json::json!([{"@id":wrong.to_string()}]));
+        assert_eq!(
+            TypeRelations::default().owning_type(&mut r.b, x, &mut 0),
+            None
+        );
+    }
+
+    #[test]
+    fn unaudited_named_expressions_never_supply_negative_specialization_facts() {
+        let mut r = model("expr expression; bool boolean; class Other;");
+        let other = r.resolve_qualified("Other").unwrap().0;
+        for name in ["expression", "boolean"] {
+            let expression = r.resolve_qualified(name).unwrap().0;
+            assert_eq!(
+                TypeRelations::default().specializes(&mut r.b, expression, other, &mut 0),
+                RelationFact::Unknown
+            );
+        }
+    }
+
+    #[test]
+    fn missing_required_library_identity_prevents_negative_type_fact() {
+        let mut model = Model::new();
+        model.add_source("missing.kerml", "class A; class B;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, a, b, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn owned_feature_budget_retry_does_not_cache_a_false_witness() {
+        let mut r = model("class A {feature x;}");
+        let a = r.resolve_qualified("A").unwrap().0;
+        let mut proof = TypeRelations::default();
+        let mut exhausted = crate::eval::MAX_STEPS - 5;
+        assert_eq!(proof.has_owned_feature(&mut r.b, a, &mut exhausted), None);
+        assert_eq!(proof.has_owned_feature(&mut r.b, a, &mut 0), Some(true));
+    }
+
+    #[test]
+    fn required_names_without_a_shared_ancestor_path_are_incomplete() {
+        let mut model = Model::new();
+        model.add_library_source(
+            "partial.kerml",
+            "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence;}",
+        );
+        model.add_source("uses.kerml", "class A; class B;");
+        let mut r = ResolvedModel::build(&model);
+        let a = r.resolve_qualified("A").unwrap().0;
+        let b = r.resolve_qualified("B").unwrap().0;
+        let occurrence = r.resolve_qualified("Occurrences::Occurrence").unwrap().0;
+        let anything = r.resolve_qualified("Base::Anything").unwrap().0;
+        assert_eq!(
+            TypeRelations::default().required_bases(&mut r.b, a, &mut 0),
+            Some(vec![occurrence, anything])
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, a, b, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+}
+#[cfg(test)]
+mod owned_result_projection_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+
+    fn fixture() -> (ResolvedModel, usize, usize) {
+        let mut model = Model::new();
+        model.add_source("results.kerml", "feature n=1; feature read=n;");
+        assert!(!model.has_errors());
+        let mut resolved = ResolvedModel::build(&model);
+        let target = resolved.resolve_qualified("n").unwrap().0;
+        let read = resolved.resolve_qualified("read").unwrap().0;
+        let value = resolved.b.elements[read]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&r| conforms(resolved.b.elements[r].ty, "FeatureValue"))
+            .unwrap();
+        let expression = resolved.b.elements[value].children[0];
+        (resolved, expression, target)
+    }
+
+    #[test]
+    fn generated_return_proves_local_ownership_and_subsetting_without_certifying_empty_family() {
+        let (mut r, expression, target) = fixture();
+        assert_eq!(
+            TypeRelations::default().has_owned_feature(&mut r.b, expression, &mut 0),
+            None
+        );
+        r.ensure_implied();
+        let result =
+            r.b.semantic_ownership
+                .as_ref()
+                .unwrap()
+                .result(expression)
+                .unwrap();
+        let mut proof = TypeRelations::default();
+        assert_eq!(
+            proof.owning_type(&mut r.b, result.feature, &mut 0),
+            Some(Some(expression))
+        );
+        assert_eq!(
+            proof.has_owned_feature(&mut r.b, expression, &mut 0),
+            Some(true)
+        );
+        assert_eq!(
+            proof.specializes(&mut r.b, result.feature, target, &mut 0),
+            RelationFact::Yes
+        );
+    }
+
+    #[test]
+    fn generated_membership_does_not_hide_corrupt_owner_alias_or_child_backlink() {
+        for child_backlink in [false, true] {
+            let (mut r, expression, target) = fixture();
+            r.ensure_implied();
+            let result =
+                r.b.semantic_ownership
+                    .as_ref()
+                    .unwrap()
+                    .result(expression)
+                    .unwrap();
+            if child_backlink {
+                r.b.elements[result.membership].owning_relationship = Some(result.membership);
+            } else {
+                let wrong = r.b.elements[target].id;
+                r.b.elements[result.membership].props.insert(
+                    "owningRelatedElement",
+                    serde_json::json!({"@id":wrong.to_string()}),
+                );
+            }
+            assert_eq!(
+                TypeRelations::default().owning_type(&mut r.b, result.feature, &mut 0),
+                None
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod annotation_completeness_tests {
+    use super::*;
+    use crate::{json::ResolvedModel, model::Model};
+    const LIBRARY: &str = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Metaobjects {metaclass SemanticMetadata {feature baseType;}}";
+    fn fixture(about: bool, explicit: bool) -> ResolvedModel {
+        let mut model = Model::new();
+        let p = model.add_library_source("annotation-bases.kerml", LIBRARY);
+        assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+        let class = if explicit {
+            "class C specializes A;"
+        } else {
+            "class C;"
+        };
+        let suffix = if about {
+            format!("{class} @Tagged about C;")
+        } else {
+            format!("#Tagged {class}")
+        };
+        let src = format!(
+            "metaclass U; class A; metaclass Tagged :> Metaobjects::SemanticMetadata {{:>> baseType=A meta U;}} {suffix}"
+        );
+        let p = model.add_source("annotations.kerml", &src);
+        assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let semantic = r
+            .resolve_qualified("Metaobjects::SemanticMetadata")
+            .unwrap();
+        assert_eq!(
+            crate::json::library_element_name_map(&model).get(&r.element_id(semantic).to_string()),
+            Some(&vec![
+                "Metaobjects".to_owned(),
+                "SemanticMetadata".to_owned()
+            ])
+        );
+        r
+    }
+    #[test]
+    fn standalone_metadata_annotation_cannot_supply_negative_specialization_evidence() {
+        for about in [false, true] {
+            for explicit in [false, true] {
+                let mut r = fixture(about, explicit);
+                let c = r.resolve_qualified("C").unwrap().0;
+                let a = r.resolve_qualified("A").unwrap().0;
+                // Both annotation spellings now share positive association
+                // storage. The checked specialization provider still does not
+                // certify the full semantic-metadata evaluator.
+                assert_eq!(r.b.metadata_of.get(&c).map(Vec::len), Some(1));
+                let mut proof = TypeRelations::default();
+                assert_eq!(
+                    proof.specializes(&mut r.b, c, a, &mut 0),
+                    if explicit {
+                        RelationFact::Yes
+                    } else {
+                        RelationFact::Unknown
+                    }
+                );
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "function_specialization_readiness_tests.rs"]
+mod function_specialization_readiness_tests;
+
+#[cfg(test)]
+#[path = "supertypes_checked_tests.rs"]
+mod supertypes_checked_tests;
+#[cfg(test)]
+mod ordinary_owned_feature_tests {
+    use super::{RelationFact, TypeRelations};
+    use crate::{
+        json::ResolvedModel,
+        model::{GraphFormat, Model},
+    };
+    fn fixture(format: GraphFormat, source: &str) -> ResolvedModel {
+        let mut model = Model::with_graph_format(format);
+        model.add_library_source("feature-roles.kerml", "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Links {assoc SelfLink specializes Base::Anything;}");
+        let unit = model.add_source("owned-features.kerml", source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&model)
+    }
+    #[test]
+    fn ordinary_owned_feature_specialization_has_complete_ancestry() {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut r = fixture(
+                format,
+                "class Parent {feature slot;} class Child specializes Parent {feature slot redefines Parent::slot;}",
+            );
+            let slot = r.resolve_qualified("Child::slot").unwrap().0;
+            let inherited = r.resolve_qualified("Parent::slot").unwrap().0;
+            let unrelated = r.resolve_qualified("Links::SelfLink").unwrap().0;
+            let mut proof = TypeRelations::default();
+            assert_eq!(
+                proof.specializes(&mut r.b, slot, inherited, &mut 0),
+                RelationFact::Yes
+            );
+            assert_eq!(
+                proof.specializes(&mut r.b, slot, unrelated, &mut 0),
+                RelationFact::No
+            );
+            assert!(
+                proof
+                    .complete_direct_bases(&mut r.b, slot, &mut 0)
+                    .is_some()
+            );
+            r.b.set(slot, "direction", serde_json::json!("in"));
+            assert_eq!(
+                proof.specializes(&mut r.b, slot, unrelated, &mut 0),
+                RelationFact::Unknown
+            );
+            r.b.set(slot, "direction", serde_json::Value::Null);
+            // Repairing a row does not relabel old evidence as current. A
+            // separate query must establish the repaired domain again.
+            assert_eq!(
+                proof.specializes(&mut r.b, slot, unrelated, &mut 0),
+                RelationFact::Unknown
+            );
+            assert_eq!(
+                TypeRelations::default().specializes(&mut r.b, slot, unrelated, &mut 0),
+                RelationFact::No
+            );
+        }
+    }
+    #[test]
+    fn ordinary_owned_feature_keeps_contextual_families_and_malformed_ownership_qualified() {
+        for mutation in 0..7 {
+            let mut r = fixture(GraphFormat::CanonicalV3, "class Parent {feature slot;}");
+            let parent = r.resolve_qualified("Parent").unwrap().0;
+            let slot = r.resolve_qualified("Parent::slot").unwrap().0;
+            let unrelated = r.resolve_qualified("Links::SelfLink").unwrap().0;
+            let membership = r.b.elements[slot].owning_relationship.unwrap();
+            match mutation {
+                0 => r.b.set(slot, "isEnd", serde_json::json!(true)),
+                1 => r.b.set(slot, "isComposite", serde_json::json!(true)),
+                2 => r.b.set(slot, "isVariable", serde_json::json!(true)),
+                3 => r.b.set(slot, "direction", serde_json::json!(false)),
+                4 => r.b.elements[membership].ty = "EndFeatureMembership",
+                5 => r.b.elements[parent].ty = "Function",
+                _ => r.b.elements[parent]
+                    .owned_relationships
+                    .make_mut()
+                    .retain(|&m| m != membership),
+            }
+            assert_eq!(
+                TypeRelations::default().specializes(&mut r.b, slot, unrelated, &mut 0),
+                RelationFact::Unknown,
+                "mutation {mutation}"
+            );
+        }
+        let mut r = fixture(GraphFormat::CanonicalV3, "class Parent {feature slot=4;}");
+        let slot = r.resolve_qualified("Parent::slot").unwrap().0;
+        let unrelated = r.resolve_qualified("Links::SelfLink").unwrap().0;
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, slot, unrelated, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+}
+
+#[cfg(test)]
+mod usage_requirement_tests {
+    use super::{RelationFact, TypeRelations};
+    use crate::{json::ResolvedModel, model::Model};
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; assoc HappensLink specializes Base::Anything;} standard library package Links {assoc SelfLink specializes Base::Anything;}";
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        assert!(
+            m.add_library_source("roles.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            m.add_library_source(
+                "roles.sysml",
+                "standard library package Actions {action def Action :> Occurrences::Occurrence;}"
+            )
+            .diagnostics
+            .is_empty()
+        );
+        assert!(m.add_source("source.sysml", source).diagnostics.is_empty());
+        ResolvedModel::build(&m)
+    }
+    fn relation(r: &mut ResolvedModel, source: &str, target: &str) -> RelationFact {
+        let a = r.resolve_qualified(source).unwrap().0;
+        let z = r.resolve_qualified(target).unwrap().0;
+        TypeRelations::default().specializes(&mut r.b, a, z, &mut 0)
+    }
+    #[test]
+    fn actual_reference_usage_has_complete_negative_exclusion_paths() {
+        let mut r = fixture("part def P :> Occurrences::Occurrence { ref x :> Base::things; }");
+        let x = r.resolve_qualified("P::x").unwrap();
+        assert_eq!(r.element_type(x), "ReferenceUsage");
+        assert_eq!(
+            relation(&mut r, "P", "Occurrences::Occurrence"),
+            RelationFact::Yes
+        );
+        for target in [
+            "Links::SelfLink",
+            "Occurrences::HappensLink",
+            "Actions::Action",
+        ] {
+            assert_eq!(
+                relation(&mut r, "P::x", target),
+                RelationFact::No,
+                "{target}"
+            );
+        }
+    }
+    #[test]
+    fn generic_feature_ancestry_closes_plain_reference_but_not_end_context() {
+        for source in [
+            "part def P { ref x; }",
+            "part def P { end x :> Base::things; }",
+        ] {
+            let mut r = fixture(source);
+            assert_eq!(
+                relation(&mut r, "P::x", "Links::SelfLink"),
+                if source.contains("ref x") {
+                    RelationFact::No
+                } else {
+                    RelationFact::Unknown
+                },
+                "{source}"
+            );
+        }
+    }
+    #[test]
+    fn plain_reference_still_requires_the_loaded_generic_feature_role() {
+        let mut r = fixture("part def P { ref x; }");
+        assert_eq!(
+            relation(&mut r, "P::x", "Links::SelfLink"),
+            RelationFact::No
+        );
+        let role =
+            r.b.lib_qnames
+                .iter()
+                .position(|(_, name)| name.as_slice() == ["Base", "things"])
+                .unwrap();
+        r.b.lib_qnames[role].1[1] = "renamedThings".into();
+        r.b.supported_implied = None;
+        assert_eq!(
+            relation(&mut r, "P::x", "Links::SelfLink"),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn positive_exclusion_survives_unsupported_owned_family() {
+        let mut r = fixture("part def P { ref x : Links::SelfLink; }");
+        assert_eq!(
+            relation(&mut r, "P::x", "Links::SelfLink"),
+            RelationFact::Yes
+        );
+        assert_eq!(
+            relation(&mut r, "P::x", "Occurrences::HappensLink"),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn malformed_flags_and_missing_required_role_refuse_absence() {
+        for key in ["isPortion", "isEnd", "isComposite", "isVariable"] {
+            let mut r = fixture("part def P { ref x :> Base::things; }");
+            let x = r.resolve_qualified("P::x").unwrap().0;
+            r.b.set(x, key, serde_json::json!("malformed"));
+            assert_eq!(
+                relation(&mut r, "P::x", "Links::SelfLink"),
+                RelationFact::Unknown,
+                "{key}"
+            );
+        }
+        let mut r = fixture("part def P { ref x :> Base::things; }");
+        let role =
+            r.b.lib_qnames
+                .iter()
+                .position(|(_, name)| name.as_slice() == ["Base", "things"])
+                .unwrap();
+        r.b.lib_qnames[role].1[1] = "renamedThings".into();
+        assert_eq!(
+            relation(&mut r, "P::x", "Links::SelfLink"),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn exhausted_proof_retries_and_changed_rows_revoke_negative() {
+        let mut r = fixture("part def P { ref x :> Base::things; }");
+        let x = r.resolve_qualified("P::x").unwrap().0;
+        let z = r.resolve_qualified("Links::SelfLink").unwrap().0;
+        let mut proof = TypeRelations::default();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            proof.specializes(&mut r.b, x, z, &mut exhausted),
+            RelationFact::Unknown
+        );
+        assert_eq!(proof.specializes(&mut r.b, x, z, &mut 0), RelationFact::No);
+        r.set_library_names(&std::collections::HashMap::from([(
+            uuid::Uuid::new_v4().to_string(),
+            vec!["Unrelated".into(), "Role".into()],
+        )]));
+        assert_eq!(
+            proof.specializes(&mut r.b, x, z, &mut 0),
+            RelationFact::Unknown
+        );
+        let mut proof = TypeRelations::default();
+        assert_eq!(proof.specializes(&mut r.b, x, z, &mut 0), RelationFact::No);
+        r.b.set(x, "isEnd", serde_json::json!(true));
+        assert_eq!(
+            proof.specializes(&mut r.b, x, z, &mut 0),
+            RelationFact::Unknown
+        );
+        assert_eq!(
+            TypeRelations::default().specializes(&mut r.b, x, z, &mut 0),
+            RelationFact::Unknown
+        );
+    }
+    #[test]
+    fn real_library_reference_usage_exclusions_replay() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        let mut library = Model::new();
+        library.load_library_dir(&path).unwrap();
+        library.record_library_cache();
+        ResolvedModel::build(&library);
+        let cache =
+            LibraryCache::from_bytes(&library.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = library.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(113).unwrap(), 113).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.load_library_dir(&path).unwrap();
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(
+                m.add_source("source.sysml", "part def P { ref x :> Base::things; }")
+                    .diagnostics
+                    .is_empty()
+            );
+            let mut r = ResolvedModel::build(&m);
+            let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+            if let Some(expected) = &expected {
+                assert_eq!(&before, expected);
+            } else {
+                expected = Some(before.clone());
+            }
+            assert_eq!(
+                relation(&mut r, "P", "Occurrences::Occurrence"),
+                RelationFact::Yes
+            );
+            for target in [
+                "Links::SelfLink",
+                "Occurrences::HappensLink",
+                "Actions::Action",
+            ] {
+                assert_eq!(
+                    relation(&mut r, "P::x", target),
+                    RelationFact::No,
+                    "mode {mode}: {target}"
+                );
+            }
+            assert_eq!(
+                before,
+                r.user_elements()
+                    .map(|e| r.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/typeops.rs b/crates/sysmlv2-model/src/json/typeops.rs
index d274d0f..9ea20d2 100644
--- a/crates/sysmlv2-model/src/json/typeops.rs
+++ b/crates/sysmlv2-model/src/json/typeops.rs
@@ -6,15 +6,58 @@
 //! `derived.rs`.
 
 use super::derived::Reference;
-use super::{ElementRef, ResolvedModel};
+use super::type_relations::{RelationFact, TypeRelations};
+use super::{ElementRef, LookupResult, ResolvedModel, split_qualified};
 use std::collections::HashSet;
+use sysmlv2_syntax::{
+    ast::{Name, QualifiedName},
+    span::Span,
+};
 
-/// The library packages whose functions the KerML concrete syntax names
-/// as model-level evaluable (clause 7.4.10). The clause lists a subset of
-/// each package's functions; every function of the three packages counts
-/// here, an over-approximation recorded in the API reference.
-const EVALUABLE_FUNCTION_PACKAGES: &[&str] =
-    &["BaseFunctions", "DataFunctions", "ControlFunctions"];
+/// KerML 1.0, §§8.2.5.8.1–8.2.5.8.2, Tables 5 and 7. These are
+/// designated function identities, not all functions in their packages.
+fn evaluable_function_name(package: &str, name: &str) -> bool {
+    match package {
+        "BaseFunctions" => matches!(
+            name,
+            "istype"
+                | "hastype"
+                | "@"
+                | "@@"
+                | "as"
+                | "meta"
+                | "=="
+                | "!="
+                | "==="
+                | "!=="
+                | "#"
+                | ","
+        ),
+        "DataFunctions" => matches!(
+            name,
+            "xor"
+                | "not"
+                | "|"
+                | "&"
+                | "<"
+                | ">"
+                | "<="
+                | ">="
+                | "+"
+                | "-"
+                | "*"
+                | "/"
+                | "%"
+                | "^"
+                | ".."
+        ),
+        "ControlFunctions" => matches!(
+            name,
+            "??" | "if" | "or" | "and" | "implies" | "." | "collect" | "select"
+        ),
+        _ => false,
+    }
+}
 
 impl ResolvedModel {
     // ---- type operations ----
@@ -108,13 +151,26 @@ impl ResolvedModel {
     /// `closure(featuringType)` over a set of features and types: every
     /// type featuring them directly or through the owning types of those
     /// types' own features — the owning-type chain, in discovery order.
-    fn featuring_closure(&mut self, roots: &[ElementRef]) -> Vec<ElementRef> {
+    fn featuring_closure(
+        &mut self,
+        roots: &[ElementRef],
+        mut relations: Option<&mut TypeRelations>,
+        steps: &mut usize,
+    ) -> Option<Vec<ElementRef>> {
         let mut out: Vec<ElementRef> = Vec::new();
+        let mut output_seen = HashSet::new();
         let mut frontier: Vec<ElementRef> = roots.to_vec();
         let mut seen: HashSet<usize> = roots.iter().map(|r| r.0).collect();
         while let Some(x) = frontier.pop() {
             let next: Vec<ElementRef> = if self.is_kind(x, "Feature") {
-                self.d_featuring_types(x)
+                match relations.as_deref_mut() {
+                    Some(proof) => proof
+                        .featuring_types(&mut self.b, x.0, steps)?
+                        .into_iter()
+                        .map(ElementRef)
+                        .collect(),
+                    None => self.d_featuring_types(x),
+                }
             } else {
                 // A Type that is not a Feature is featured by nothing.
                 Vec::new()
@@ -126,22 +182,18 @@ impl ResolvedModel {
                 if seen.insert(t.0) {
                     frontier.push(t);
                 }
-                if !out.contains(&t) {
+                if output_seen.insert(t) {
                     out.push(t);
                 }
             }
         }
-        out
+        Some(out)
     }
 
-    /// Whether `t` specializes `general`, through the explicit
-    /// specializations of the model (`t` itself counts). Three clauses of
-    /// the normative `supertypes`/`specializes` are omitted, inert in
-    /// this lowering's featuring types: a Feature's `featureTarget` as a
-    /// supertype (a chain feature is never a featuring type here), a
-    /// conjugated type's `conjugator.originalType`, and
-    /// `Feature::isCompatibleWith`'s shared-redefinition clause.
-    pub(super) fn specializes(&mut self, t: ElementRef, general: ElementRef) -> bool {
+    // Retained compatibility provider for domains whose snapshot/derived
+    // featuring is not yet audited. Domain selection happens before the
+    // stronger provider runs; a failed proof never falls back here.
+    fn compatibility_specializes(&mut self, t: ElementRef, general: ElementRef) -> bool {
         let mut seen: HashSet<usize> = HashSet::new();
         let mut stack = vec![t];
         while let Some(x) = stack.pop() {
@@ -161,18 +213,17 @@ impl ResolvedModel {
         false
     }
 
-    /// `Feature::isFeaturedWithin(type)` for a non-null type: every
-    /// featuring type of `f` is one `t` specializes; or `f` is variable and
-    /// `t` specializes its owning type; or `f` is a chain whose first link
-    /// is variable and `t` specializes that link's owning type.
-    fn is_featured_within(&mut self, f: ElementRef, t: ElementRef) -> bool {
+    fn compatibility_is_featured_within(&mut self, f: ElementRef, t: ElementRef) -> bool {
         let featuring = self.d_featuring_types(f);
-        if featuring.iter().all(|&ft| self.specializes(t, ft)) {
+        if featuring
+            .iter()
+            .all(|&ft| self.compatibility_specializes(t, ft))
+        {
             return true;
         }
         if self.prop_bool(f.0, "isVariable") {
             if let Some(o) = self.d_owning_type(f) {
-                if self.specializes(t, o) {
+                if self.compatibility_specializes(t, o) {
                     return true;
                 }
             }
@@ -180,7 +231,7 @@ impl ResolvedModel {
         if let Some(Reference::Element(first)) = self.d_chaining_features(f).into_iter().next() {
             if self.prop_bool(first.0, "isVariable") {
                 if let Some(o) = self.d_owning_type(first) {
-                    if self.specializes(t, o) {
+                    if self.compatibility_specializes(t, o) {
                         return true;
                     }
                 }
@@ -189,11 +240,65 @@ impl ResolvedModel {
         false
     }
 
+    /// `Feature::isFeaturedWithin(type)` for a non-null type: every
+    /// featuring type of `f` is one `t` specializes; or `f` is variable and
+    /// `t` specializes its owning type; or `f` is a chain whose first link
+    /// is variable and `t` specializes that link's owning type.
+    fn is_featured_within(
+        &mut self,
+        f: ElementRef,
+        t: ElementRef,
+        relations: Option<&mut TypeRelations>,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        let relations = match relations {
+            Some(proof) => proof,
+            None => return Some(self.compatibility_is_featured_within(f, t)),
+        };
+        let featuring = relations.featuring_types(&mut self.b, f.0, steps)?;
+        let compatibility = RelationFact::all(
+            featuring
+                .into_iter()
+                .map(|ft| relations.compatible(&mut self.b, t.0, ft, steps)),
+        );
+        if compatibility == RelationFact::Yes {
+            return Some(true);
+        }
+        let mut unknown = compatibility == RelationFact::Unknown;
+        let mut alternatives = Vec::new();
+        if self.prop_bool(f.0, "isVariable") {
+            match relations.owning_type(&mut self.b, f.0, steps) {
+                Some(Some(owner)) => alternatives.push(ElementRef(owner)),
+                Some(None) => {}
+                None => unknown = true,
+            }
+        }
+        if let Some(Reference::Element(first)) = self.d_chaining_features(f).into_iter().next() {
+            if self.prop_bool(first.0, "isVariable") {
+                match relations.owning_type(&mut self.b, first.0, steps) {
+                    Some(Some(owner)) => alternatives.push(ElementRef(owner)),
+                    Some(None) => {}
+                    None => unknown = true,
+                }
+            }
+        }
+        for owner in alternatives {
+            match relations.specializes(&mut self.b, t.0, owner.0, steps) {
+                RelationFact::Yes => return Some(true),
+                RelationFact::No => {}
+                RelationFact::Unknown => unknown = true,
+            }
+        }
+        if unknown { None } else { Some(false) }
+    }
+
     /// `Connector::defaultFeaturingType`: of the types featuring the related
     /// features directly or indirectly, those every related feature is
     /// featured within; of those, the innermost — one no other of them is
     /// featured within — first. Null when a related feature is outside the
-    /// model (its featuring is not visible) or there are none.
+    /// model (its featuring is not visible), owned evidence is incomplete,
+    /// a proof budget is exhausted, or there are no candidates. The strict
+    /// reader retains its Approximate refusal; null is not an absence proof.
     pub(super) fn d_default_featuring_type(&mut self, e: ElementRef) -> Option<ElementRef> {
         let related: Vec<ElementRef> = self
             .d_related_features(e)
@@ -203,14 +308,23 @@ impl ResolvedModel {
         if related.is_empty() {
             return None;
         }
-        let candidates = self.featuring_closure(&related);
+        let mut proof = TypeRelations::default();
+        let mut steps = 0;
+        let roots: Vec<_> = related.iter().map(|e| e.0).collect();
+        let audited = proof.audited_featuring_domain(&mut self.b, &roots, &mut steps)?;
+        let mut relations = audited.then_some(proof);
+        let candidates = self.featuring_closure(&related, relations.as_mut(), &mut steps)?;
         let mut common: Vec<ElementRef> = Vec::new();
         for t in candidates {
             let mut all = true;
             for &f in &related {
-                if !self.is_featured_within(f, t) {
-                    all = false;
-                    break;
+                match self.is_featured_within(f, t, relations.as_mut(), &mut steps) {
+                    Some(true) => {}
+                    Some(false) => {
+                        all = false;
+                        break;
+                    }
+                    None => return None,
                 }
             }
             if all {
@@ -222,7 +336,11 @@ impl ResolvedModel {
         for &t1 in &common {
             let mut outer = false;
             for &t2 in &common {
-                if t2 != t1 && self.featuring_closure(&[t2]).contains(&t1) {
+                if t2 != t1
+                    && self
+                        .featuring_closure(&[t2], relations.as_mut(), &mut steps)?
+                        .contains(&t1)
+                {
                     outer = true;
                     break;
                 }
@@ -360,7 +478,7 @@ impl ResolvedModel {
             }
         };
         if let Some(Reference::Element(anything_self)) = anything_self {
-            if self.specializes(referent, anything_self) {
+            if self.compatibility_specializes(referent, anything_self) {
                 return true;
             }
         }
@@ -392,26 +510,136 @@ impl ResolvedModel {
         }
     }
 
-    /// `Function::isModelLevelEvaluable` for the function an invocation
-    /// instantiates: a function of the Kernel Functions Library's
-    /// `BaseFunctions`, `DataFunctions` or `ControlFunctions` — an element
-    /// of a loaded library, or an external id the library name table names
-    /// in one of them.
+    /// Only the designated Kernel Functions Library identities are
+    /// model-level evaluable. A spelling selects a candidate; the library
+    /// binding must resolve back to the same element or external identity.
     pub(super) fn function_is_model_level_evaluable(&mut self, f: &Reference) -> bool {
-        match f {
-            Reference::Element(f) => {
-                self.is_library_element(*f)
-                    && self.element_qualified_name(*f).is_some_and(|qn| {
-                        qn.split("::")
-                            .next()
-                            .is_some_and(|p| EVALUABLE_FUNCTION_PACKAGES.contains(&p))
-                    })
+        let (package, name) = match f {
+            Reference::Element(e) => {
+                if !self.is_library_element(*e) || !self.is_kind(*e, "Function") {
+                    return false;
+                }
+                let Some(qn) = self.element_qualified_name(*e) else {
+                    return false;
+                };
+                let segments = split_qualified(&qn);
+                let [package, name] = segments.as_slice() else {
+                    return false;
+                };
+                (package.clone(), name.clone())
+            }
+            Reference::External(id) => {
+                let (Some(package), Some(name)) =
+                    (self.external_package.get(id), self.external_names.get(id))
+                else {
+                    return false;
+                };
+                (package.clone(), name.clone())
+            }
+            Reference::Unresolved(_) => return false,
+        };
+        if !evaluable_function_name(&package, &name) {
+            return false;
+        }
+        self.designated_function_binding(&package, &name).as_ref() == Some(f)
+    }
+
+    /// Resolve one designated function without allowing an ambiguous loaded
+    /// name to fall back to an external name-table identity. General name
+    /// lookup retains its compatibility behavior; this is an admission proof.
+    fn designated_function_binding(&mut self, package: &str, name: &str) -> Option<Reference> {
+        match self.b.designated_function_lookup(package, name) {
+            LookupResult::Found(index, _, _) => {
+                let e = ElementRef(index);
+                (self.is_library_element(e) && self.is_kind(e, "Function"))
+                    .then_some(Reference::Element(e))
+            }
+            LookupResult::Ambiguous => None,
+            LookupResult::Missing => {
+                let name = format!("{package}::{name}");
+                if self.external_ambiguous_names.contains(&name) {
+                    return None;
+                }
+                let id = *self.external_by_name.get(&name)?;
+                self.ensure_by_id();
+                // An external table cannot relabel an in-model element. The
+                // loaded-identity branch must establish its actual binding.
+                (!self.by_id.contains_key(&id)).then_some(Reference::External(id))
+            }
+        }
+    }
+}
+
+impl super::Builder {
+    pub(super) fn designated_function_lookup(&mut self, package: &str, name: &str) -> LookupResult {
+        let qn = QualifiedName {
+            is_global: false,
+            segments: [package, name]
+                .into_iter()
+                .map(|value| Name {
+                    value: value.to_string(),
+                    span: Span::default(),
+                })
+                .collect(),
+            span: Span::default(),
+        };
+        self.resolve_unrestricted(0, &qn)
+    }
+}
+
+#[cfg(test)]
+mod evaluable_function_tests {
+    use super::*;
+    use crate::model::Model;
+    use std::collections::HashMap;
+    use uuid::Uuid;
+
+    #[test]
+    fn all_designated_external_identities_and_exclusions() {
+        // Independently transcribed normative Table 5 / Table 7 identities.
+        let rows = [
+            (
+                "BaseFunctions",
+                "istype hastype @ @@ as meta == != === !== # ,",
+                true,
+            ),
+            (
+                "DataFunctions",
+                "xor not | & < > <= >= + - * / % ^ ..",
+                true,
+            ),
+            (
+                "ControlFunctions",
+                "?? if or and implies . collect select",
+                true,
+            ),
+            ("BaseFunctions", "all [ custom", false),
+            ("DataFunctions", "~ custom", false),
+            ("ControlFunctions", "custom", false),
+        ];
+        let mut names = HashMap::new();
+        let mut expected = Vec::new();
+        for (package, functions, eligible) in rows {
+            for name in functions.split_whitespace() {
+                let id = Uuid::from_u128(expected.len() as u128 + 1);
+                names.insert(id.to_string(), vec![package.to_string(), name.to_string()]);
+                expected.push((id, eligible));
+            }
+        }
+        assert_eq!(
+            expected.iter().filter(|(_, eligible)| *eligible).count(),
+            35
+        );
+        let mut r = ResolvedModel::build(&Model::new());
+        r.set_library_names(&names);
+        for _ in 0..2 {
+            for &(id, eligible) in &expected {
+                assert_eq!(
+                    r.function_is_model_level_evaluable(&Reference::External(id)),
+                    eligible,
+                    "{id}"
+                );
             }
-            Reference::External(id) => self
-                .external_package
-                .get(id)
-                .is_some_and(|p| EVALUABLE_FUNCTION_PACKAGES.contains(&p.as_str())),
-            Reference::Unresolved(_) => false,
         }
     }
 }
diff --git a/crates/sysmlv2-model/src/json/usage_variability.rs b/crates/sysmlv2-model/src/json/usage_variability.rs
new file mode 100644
index 0000000..2817e13
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/usage_variability.rs
@@ -0,0 +1,708 @@
+//! Bounded Usage variability over the shared specialization and ownership proof.
+//! No stored derived bit or independent semantic graph supplies the answer.
+use super::{
+    Builder, ElementRef, ResolvedModel,
+    structural_index::StoredStructure,
+    type_relations::{RelationFact, TypeRelations},
+};
+use crate::metaclass::conforms;
+
+/// Why Usage::mayTimeVary cannot be certified. Errors never mean false.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum UsageVariabilityIssue {
+    WorkLimit,
+    InvalidElement,
+    InvalidOwnership,
+    InvalidBoolean(&'static str),
+    UnsupportedMetadata,
+    UnsupportedConfiguration,
+    MissingCanonicalRole(&'static str),
+    IncompleteSpecialization,
+}
+
+/// A complete Usage variability value or an explicit qualification.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct UsageVariabilityReport {
+    pub value: Result<bool, UsageVariabilityIssue>,
+    /// Bounded logical work, including cold shared topology construction.
+    pub steps: usize,
+}
+fn charge(steps: &mut usize, amount: usize) -> Result<(), UsageVariabilityIssue> {
+    *steps = steps.saturating_add(amount);
+    if *steps > crate::eval::MAX_STEPS {
+        Err(UsageVariabilityIssue::WorkLimit)
+    } else {
+        Ok(())
+    }
+}
+
+impl ResolvedModel {
+    /// Read SysML Usage::mayTimeVary from complete identity evidence.
+    ///
+    /// Ordinary reference, attribute, occurrence, item and part Usages with
+    /// witnessed required paths are supported. End Usages also require the
+    /// complete shared ordered Membership/redefinition certificate. Independent
+    /// exclusions or a proven null owning type can establish false in other
+    /// contexts. Unsupported contextual families remain errors when relevant.
+    /// This does not map textual end defaults or change owned isConstant.
+    pub fn usage_variability_report(&mut self, usage: ElementRef) -> UsageVariabilityReport {
+        self.usage_variability_report_with_budget(usage, 0)
+    }
+
+    pub(in crate::json) fn usage_variability_report_with_budget(
+        &mut self,
+        usage: ElementRef,
+        initial_steps: usize,
+    ) -> UsageVariabilityReport {
+        let mut steps = initial_steps;
+        let value = read(&mut self.b, usage.0, &mut steps);
+        UsageVariabilityReport {
+            value: if steps > crate::eval::MAX_STEPS {
+                Err(UsageVariabilityIssue::WorkLimit)
+            } else {
+                value
+            },
+            steps,
+        }
+    }
+}
+
+fn boolean(b: &Builder, usage: usize, key: &'static str) -> Result<bool, UsageVariabilityIssue> {
+    match b.elements[usage].props.get(key) {
+        None => Ok(false),
+        Some(value) => value
+            .as_bool()
+            .ok_or(UsageVariabilityIssue::InvalidBoolean(key)),
+    }
+}
+
+fn specializes_role(
+    b: &mut Builder,
+    proof: &mut TypeRelations,
+    source: usize,
+    role: &'static str,
+    steps: &mut usize,
+) -> Result<RelationFact, UsageVariabilityIssue> {
+    let target = proof
+        .library_role(b, role, steps)
+        .ok_or(UsageVariabilityIssue::MissingCanonicalRole(role))?;
+    let fact = proof.specializes(b, source, target, steps);
+    charge(steps, 0)?;
+    Ok(fact)
+}
+
+fn read(b: &mut Builder, usage: usize, steps: &mut usize) -> Result<bool, UsageVariabilityIssue> {
+    use UsageVariabilityIssue::*;
+    charge(steps, 1)?;
+    let row = b
+        .elements
+        .get(usage)
+        .filter(|row| conforms(row.ty, "Usage"))
+        .ok_or(InvalidElement)?;
+    // Only this exact effective declaration is implemented, including through
+    // its inherited spelling. Future redefinitions need their own capability.
+    if crate::semantic_catalog::property(row.ty, "mayTimeVary")
+        .and_then(|(_, effective)| effective)
+        .is_none_or(|p| p.id != "Systems-DefinitionAndUsage-Usage-mayTimeVary")
+    {
+        return Err(UnsupportedConfiguration);
+    }
+    if b.positional_planning || !b.dynamic_evidence_current(usage) {
+        return Err(UnsupportedConfiguration);
+    }
+    // Validate retained inputs before any decisive Boolean short circuit.
+    // Derived aliases are shape-checked but never accepted as computed values.
+    charge(steps, 5)?;
+    let portion = boolean(b, usage, "isPortion")?;
+    let composite = boolean(b, usage, "isComposite")?;
+    for key in ["isEnd", "isVariable", "mayTimeVary"] {
+        boolean(b, usage, key)?;
+    }
+    let structure = StoredStructure::for_annotations(b, steps).ok_or(InvalidOwnership)?;
+    if !structure.ids_unique {
+        return Err(InvalidElement);
+    }
+    if b.metadata_associations_incomplete
+        || structure.annotations_incomplete
+        || structure.metadata_annotation_targets.contains(&usage)
+        || b.metadata_of.get(&usage).is_some_and(|v| !v.is_empty())
+    {
+        return Err(UnsupportedMetadata);
+    }
+    // Stored ownership must be reciprocal even for the null owningType case.
+    // Orphan rows without a checked membership are outside this first domain.
+    let membership = b.elements[usage]
+        .owning_relationship
+        .ok_or(InvalidOwnership)?;
+    let carrier =
+        super::semantic_ownership::checked_relationship_carrier(b, &structure, membership, steps)
+            .flatten()
+            .ok_or(InvalidOwnership)?;
+    if super::membership_evidence::member(b, &structure, carrier, membership, steps) != Some(usage)
+    {
+        return Err(InvalidOwnership);
+    }
+    let mut proof = TypeRelations::default();
+    let owner = proof.owning_type(b, usage, steps).ok_or(InvalidOwnership)?;
+    if let Some(stored) = b.elements[usage].props.get("owningType") {
+        let valid = match owner {
+            Some(owner) => stored.as_reference() == Some(b.elements[owner].id),
+            None => stored.is_null(),
+        };
+        if !valid {
+            return Err(InvalidOwnership);
+        }
+    }
+    if portion || owner.is_none() {
+        return Ok(false);
+    }
+    let owner = owner.expect("non-null owning type");
+    let occurrence = specializes_role(b, &mut proof, owner, "Occurrences::Occurrence", steps);
+    if occurrence == Ok(RelationFact::No) {
+        return Ok(false);
+    }
+    charge(steps, 0)?;
+    // A positive exclusion can decide false independently of a missing role or
+    // incomplete path elsewhere. Failure to find an exclusion never means No.
+    let mut complete = occurrence == Ok(RelationFact::Yes);
+    let mut issue = occurrence.err();
+    for role in [
+        "Links::SelfLink",
+        "Occurrences::HappensLink",
+        "Actions::Action",
+    ] {
+        if role == "Actions::Action" && !composite {
+            continue;
+        }
+        match specializes_role(b, &mut proof, usage, role, steps) {
+            Ok(RelationFact::Yes) => return Ok(false),
+            Ok(RelationFact::No) => {}
+            Ok(RelationFact::Unknown) => complete = false,
+            Err(error) => {
+                complete = false;
+                issue.get_or_insert(error);
+            }
+        }
+        charge(steps, 0)?;
+    }
+    if complete {
+        Ok(true)
+    } else {
+        Err(issue.unwrap_or(IncompleteSpecialization))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        json::{ClosurePolicy, DerivedValue, PropertyError},
+        model::Model,
+    };
+    use serde_json::{Value, json};
+    use std::collections::HashMap;
+    const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; assoc HappensLink specializes Base::Anything;} standard library package Links {assoc SelfLink specializes Base::Anything;}";
+    fn fixture(source: &str) -> ResolvedModel {
+        let mut m = Model::new();
+        assert!(
+            m.add_library_source("roles.kerml", LIB)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            m.add_library_source(
+                "roles.sysml",
+                "standard library package Actions { action def Action :> Occurrences::Occurrence; }"
+            )
+            .diagnostics
+            .is_empty()
+        );
+        assert!(m.add_source("source.sysml", source).diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&m);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        r
+    }
+    fn report(r: &mut ResolvedModel, name: &str) -> Result<bool, UsageVariabilityIssue> {
+        let e = r.resolve_qualified(name).unwrap();
+        r.usage_variability_report(e).value
+    }
+    fn remove_role(r: &mut ResolvedModel, role: &str) {
+        r.b.lib_qnames =
+            r.b.lib_qnames
+                .iter()
+                .filter(|(_, name)| name.join("::") != role)
+                .cloned()
+                .collect();
+        r.b.supported_implied = None;
+    }
+    fn complete_end_model(format: crate::model::GraphFormat, source: &str) -> Model {
+        let mut model = Model::with_graph_format(format);
+        for (path, text) in [
+            (
+                "ends.kerml",
+                "standard library package Base { classifier Anything; feature things : Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences : Occurrence subsets Base::things; assoc HappensLink specializes Base::Anything; } standard library package Objects { struct Object specializes Occurrences::Occurrence; feature objects : Object subsets Occurrences::occurrences; } standard library package Links { assoc SelfLink specializes Base::Anything; }",
+            ),
+            (
+                "ends.sysml",
+                "standard library package Items { item def Item :> Objects::Object; abstract ref item items : Item :> Objects::objects; } standard library package Parts { part def Part :> Items::Item; abstract ref part parts : Part :> Items::items; }",
+            ),
+        ] {
+            let unit = model.add_library_source(path, text);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        }
+        if !source.is_empty() {
+            let unit = model.add_source("source.sysml", source);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        }
+        model
+    }
+    #[test]
+    fn ordinary_ends_use_complete_shared_order_and_redefinitions() {
+        use crate::model::GraphFormat;
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let model = complete_end_model(
+                format,
+                "part def A { end ref alpha :> Base::things; end ref beta :> Base::things; } part def B :> A; part def C :> B { end ref x :> Base::things; end ref y :> Base::things; } part def D { end item typed : Items::Item; }",
+            );
+            let mut r = ResolvedModel::build(&model);
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            for name in ["A::alpha", "A::beta", "C::x", "C::y", "D::typed"] {
+                let end = r.resolve_qualified(name).unwrap();
+                assert_eq!(
+                    r.usage_variability_report(end).value,
+                    Ok(true),
+                    "{format:?} {name}"
+                );
+                assert_eq!(r.property(end, "mayTimeVary"), Ok(json!(true)));
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(r.property(end, "isConstant"), Ok(json!(true)));
+                    assert_eq!(
+                        r.end_constancy_report(end).variable_end_is_constant,
+                        Ok(true)
+                    );
+                }
+            }
+            let c = r.resolve_qualified("C").unwrap();
+            let x = r.resolve_qualified("C::x").unwrap();
+            let y = r.resolve_qualified("C::y").unwrap();
+            assert_eq!(
+                r.type_feature_report(c).projections.unwrap().end_features,
+                [x, y]
+            );
+            let first = r.resolve_qualified("A::alpha").unwrap();
+            r.b.set(first.0, "isEnd", json!("invalid"));
+            assert!(r.usage_variability_report(x).value.is_err());
+        }
+    }
+
+    #[test]
+    fn end_completeness_refuses_inverse_ownership_and_unproved_individual_families() {
+        use crate::model::GraphFormat;
+        for mutation in 0..3 {
+            let model = complete_end_model(
+                GraphFormat::CanonicalV3,
+                "part def P { end ref x :> Base::things; }",
+            );
+            let mut r = ResolvedModel::build(&model);
+            let x = r.resolve_qualified("P::x").unwrap();
+            let p = r.resolve_qualified("P").unwrap();
+            assert_eq!(r.usage_variability_report(x).value, Ok(true));
+            match mutation {
+                0 => r.b.elements[p.0].owned_relationships = Vec::new().into(),
+                1 => r.b.set(p.0, "isIndividual", json!(true)),
+                _ => remove_role(&mut r, "Parts::Part"),
+            }
+            assert!(
+                r.usage_variability_report(x).value.is_err(),
+                "mutation{mutation}"
+            );
+            assert!(r.property(x, "isConstant").is_err(), "mutation{mutation}");
+        }
+    }
+
+    #[test]
+    fn canonical_positive_end_completion_replays_and_preserves_imported_flags() {
+        use crate::{libcache::LibraryCache, model::GraphFormat, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let mut library = complete_end_model(GraphFormat::CanonicalV3, "");
+        library.record_library_cache();
+        ResolvedModel::build(&library);
+        let cache =
+            LibraryCache::from_bytes(&library.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = library.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(191).unwrap(), 191).unwrap());
+        for mode in 0..4 {
+            let mut m = if mode < 2 {
+                complete_end_model(GraphFormat::CanonicalV3, "")
+            } else {
+                Model::with_graph_format(GraphFormat::CanonicalV3)
+            };
+            match mode {
+                1 => m.set_library_cache(cache.clone()),
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {}
+            }
+            assert!(
+                m.add_source(
+                    "positive.sysml",
+                    "part def P { end ref x :> Base::things; }"
+                )
+                .diagnostics
+                .is_empty()
+            );
+            let mut r = ResolvedModel::build(&m);
+            let x = r.resolve_qualified("P::x").unwrap();
+            let before = r.element_properties(x);
+            assert_eq!(r.usage_variability_report(x).value, Ok(true), "mode{mode}");
+            assert_eq!(r.property(x, "isConstant"), Ok(json!(true)));
+            assert_eq!(r.element_properties(x), before);
+            assert!(matches!(
+                r.usage_variability_report_with_budget(x, crate::eval::MAX_STEPS)
+                    .value,
+                Err(UsageVariabilityIssue::WorkLimit)
+            ));
+            assert_eq!(r.usage_variability_report(x).value, Ok(true));
+            for mut doc in [
+                super::super::model_to_compact_json(&m),
+                crate::full::model_to_full_json(&m),
+            ] {
+                let row = doc
+                    .as_array_mut()
+                    .unwrap()
+                    .iter_mut()
+                    .find(|row| row["declaredName"] == "x")
+                    .unwrap();
+                assert_eq!(row["isConstant"], true, "mode{mode}");
+                row["isConstant"] = json!(false);
+                let (_, mut imported, _, _) = crate::loader::load_document_with_format(
+                    &doc,
+                    &HashMap::new(),
+                    GraphFormat::CanonicalV3,
+                )
+                .unwrap();
+                let x = imported.resolve_qualified("P::x").unwrap();
+                assert!(!imported.canonical_text_end(x));
+                assert_eq!(imported.property(x, "isConstant"), Ok(json!(false)));
+            }
+        }
+    }
+
+    #[test]
+    fn ordinary_reference_is_positive_and_checked_aliases_share_declaration_dispatch() {
+        let mut r = fixture("part def P :> Occurrences::Occurrence { ref x :> Base::things; }");
+        let x = r.resolve_qualified("P::x").unwrap();
+        let original = r.element_properties(x);
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        for name in ["mayTimeVary", "isVariable"] {
+            assert_eq!(r.property(x, name), Ok(json!(true)));
+            assert_eq!(r.derived_exact(x, name), Ok(DerivedValue::Bool(true)));
+        }
+        assert_eq!(r.element_properties(x), original);
+        let xid = r.element_id(x);
+        let issues = r.to_full_json_strict().unwrap_err().issues;
+        assert!(
+            !issues.iter().any(|i| i.element_id == xid
+                && matches!(i.property.as_str(), "mayTimeVary" | "isVariable"))
+        );
+        // Retained derived aliases are never treated as computed answers.
+        r.b.set(x.0, "mayTimeVary", json!(false));
+        r.b.set(x.0, "isVariable", json!(false));
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        remove_role(&mut r, "Actions::Action");
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        r.set_closure_policy(ClosurePolicy::Passthrough);
+        assert_eq!(
+            r.property(x, "mayTimeVary"),
+            Err(PropertyError::Approximate)
+        );
+    }
+    #[test]
+    fn null_owner_and_each_positive_exclusion_decide_false_independently() {
+        let mut m = Model::new();
+        m.add_source("root.sysml", "ref x;");
+        let mut r = ResolvedModel::build(&m);
+        assert_eq!(report(&mut r, "x"), Ok(false));
+        let mut r = fixture("part def P { ref x :> Base::things; }");
+        let x = r.resolve_qualified("P::x").unwrap();
+        r.b.set(x.0, "isPortion", json!(true));
+        r.b.lib_qnames = Default::default();
+        r.b.supported_implied = None;
+        assert_eq!(r.usage_variability_report(x).value, Ok(false));
+        for role in [
+            "Links::SelfLink",
+            "Occurrences::HappensLink",
+            "Actions::Action",
+        ] {
+            let mut r = fixture(&format!("part def P {{ ref x : {role}; }}"));
+            let x = r.resolve_qualified("P::x").unwrap();
+            if role == "Actions::Action" {
+                r.b.set(x.0, "isComposite", json!(true));
+            }
+            remove_role(&mut r, "Occurrences::Occurrence");
+            assert_eq!(r.usage_variability_report(x).value, Ok(false), "{role}");
+        }
+    }
+    #[test]
+    fn malformed_inputs_precede_false_short_circuits_and_exhaustion_precedes_all_results() {
+        for key in [
+            "isPortion",
+            "isComposite",
+            "isEnd",
+            "isVariable",
+            "mayTimeVary",
+        ] {
+            for bad in [
+                Value::Null,
+                json!("true"),
+                json!([]),
+                json!({"@id":uuid::Uuid::nil()}),
+            ] {
+                let mut r = fixture("ref x;");
+                let x = r.resolve_qualified("x").unwrap();
+                r.b.set(x.0, key, bad);
+                assert_eq!(
+                    r.usage_variability_report(x).value,
+                    Err(UsageVariabilityIssue::InvalidBoolean(key))
+                );
+                assert_eq!(
+                    r.usage_variability_report_with_budget(x, crate::eval::MAX_STEPS)
+                        .value,
+                    Err(UsageVariabilityIssue::WorkLimit)
+                );
+            }
+        }
+        let mut r = fixture("part def P :> Occurrences::Occurrence {ref x :> Base::things;}");
+        let x = r.resolve_qualified("P::x").unwrap();
+        r.by_id.clear();
+        r.by_id_built_for = usize::MAX;
+        assert_eq!(
+            r.usage_variability_report_with_budget(x, crate::eval::MAX_STEPS - 2)
+                .value,
+            Err(UsageVariabilityIssue::WorkLimit)
+        );
+        assert!(r.by_id.is_empty());
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        assert!(r.by_id.is_empty());
+    }
+    #[test]
+    fn missing_wrong_kind_duplicate_and_external_roles_never_certify_absence() {
+        for mode in 0..4 {
+            let mut r = fixture("part def P :> Occurrences::Occurrence {ref x :> Base::things;}");
+            let target = r.resolve_qualified("Links::SelfLink").unwrap();
+            match mode {
+                0 => remove_role(&mut r, "Links::SelfLink"),
+                1 => r.b.elements[target.0].ty = "Class",
+                2 => r.b.lib_qnames.push((
+                    uuid::Uuid::new_v4(),
+                    vec!["Links".into(), "SelfLink".into()],
+                )),
+                _ => {
+                    remove_role(&mut r, "Links::SelfLink");
+                    r.set_library_names(&HashMap::from([(
+                        uuid::Uuid::new_v4().to_string(),
+                        vec!["Links".into(), "SelfLink".into()],
+                    )]));
+                }
+            }
+            assert_eq!(
+                report(&mut r, "P::x"),
+                Err(UsageVariabilityIssue::MissingCanonicalRole(
+                    "Links::SelfLink"
+                )),
+                "mode {mode}"
+            );
+        }
+    }
+    #[test]
+    fn end_missing_family_metadata_and_bad_ownership_remain_qualified() {
+        for source in [
+            "part def P { ref x; }",
+            "part def P { end x :> Base::things; }",
+        ] {
+            let mut r = fixture(source);
+            assert_eq!(
+                report(&mut r, "P::x"),
+                Err(UsageVariabilityIssue::IncompleteSpecialization)
+            );
+        }
+        let mut r = fixture("ref x;");
+        let x = r.resolve_qualified("x").unwrap();
+        r.b.metadata_associations_incomplete = true;
+        assert_eq!(
+            r.usage_variability_report(x).value,
+            Err(UsageVariabilityIssue::UnsupportedMetadata)
+        );
+        r.b.metadata_associations_incomplete = false;
+        let membership = r.b.elements[x.0].owning_relationship.unwrap();
+        r.b.elements[membership].children = Vec::new().into();
+        assert_eq!(
+            r.usage_variability_report(x).value,
+            Err(UsageVariabilityIssue::InvalidOwnership)
+        );
+        let mut r = fixture("ref x; ref duplicate;");
+        let x = r.resolve_qualified("x").unwrap();
+        let other = r.resolve_qualified("duplicate").unwrap();
+        r.b.elements[other.0].id = r.b.elements[x.0].id;
+        assert_eq!(
+            r.usage_variability_report(x).value,
+            Err(UsageVariabilityIssue::InvalidElement)
+        );
+    }
+    #[test]
+    fn contradictory_membership_aliases_refuse_before_any_boolean_result() {
+        for source in [
+            "ref x; ref other;",
+            "part def P :> Occurrences::Occurrence {ref x :> Base::things; ref other;}",
+        ] {
+            for key in [
+                "owningRelationship",
+                "owningMembership",
+                "owningFeatureMembership",
+            ] {
+                let mut r = fixture(source);
+                let nested = source.starts_with("part");
+                if key == "owningFeatureMembership" && !nested {
+                    continue;
+                }
+                let x = r
+                    .resolve_qualified(if nested { "P::x" } else { "x" })
+                    .unwrap();
+                let other = r
+                    .resolve_qualified(if nested { "P::other" } else { "other" })
+                    .unwrap();
+                assert_eq!(r.usage_variability_report(x).value, Ok(nested));
+                let wrong = r.b.elements[other.0].owning_relationship.unwrap();
+                let wrong = r.b.elements[wrong].id;
+                r.b.set(x.0, key, json!({"@id":wrong}));
+                assert_eq!(
+                    r.usage_variability_report(x).value,
+                    Err(UsageVariabilityIssue::InvalidOwnership),
+                    "{key}: {source}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn row_identity_names_and_reference_changes_cannot_reuse_old_answers() {
+        let mut r = fixture("part def P :> Occurrences::Occurrence {ref x :> Base::things;}");
+        let x = r.resolve_qualified("P::x").unwrap();
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        r.override_ids(&HashMap::from([(r.element_id(x), uuid::Uuid::new_v4())]));
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        r.b.set(x.0, "isComposite", json!(true));
+        assert!(r.usage_variability_report(x).value.is_err());
+        r.b.set(x.0, "isComposite", json!(false));
+        assert_eq!(r.usage_variability_report(x).value, Ok(true));
+        r.b.positional_planning = true;
+        assert_eq!(
+            r.usage_variability_report(x).value,
+            Err(UsageVariabilityIssue::UnsupportedConfiguration)
+        );
+        r.b.positional_planning = false;
+        let subset = r.b.elements[x.0]
+            .owned_relationships
+            .iter()
+            .copied()
+            .find(|&e| conforms(r.b.elements[e].ty, "Subsetting"))
+            .unwrap();
+        r.b.set(subset, "subsettedFeature", json!({"@ref":"Missing"}));
+        assert!(r.usage_variability_report(x).value.is_err());
+    }
+    #[test]
+    fn real_library_true_false_and_refusal_replay_without_changing_source_ids() {
+        use crate::{libcache::LibraryCache, prepared::PreparedLibrary};
+        use std::sync::Arc;
+        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec-refs/SysML-v2-Release/sysml.library");
+        for format in [
+            crate::model::GraphFormat::LegacyV2,
+            crate::model::GraphFormat::CanonicalV3,
+        ] {
+            let mut library = Model::with_graph_format(format);
+            library.load_library_dir(&path).unwrap();
+            library.record_library_cache();
+            ResolvedModel::build(&library);
+            let cache = LibraryCache::from_bytes(
+                &library.take_recorded_library_cache().unwrap().to_bytes(),
+            )
+            .unwrap();
+            let prepared = library.prepare_library().unwrap();
+            let decoded = Arc::new(
+                PreparedLibrary::from_bytes(&prepared.to_bytes(115).unwrap(), 115).unwrap(),
+            );
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut m = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                    _ => {
+                        m.load_library_dir(&path).unwrap();
+                        if mode == 1 {
+                            m.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                assert!(m.add_source("usage.sysml","ref top; part def P {ref x :> Base::things; ref defaultRef; ref selfLink : Links::SelfLink; end item e;} occurrence def Q {end ref z :> Base::things;} part def MissingType {end item unresolved : Missing;}").diagnostics.is_empty());
+                let mut r = ResolvedModel::build(&m);
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+                if let Some(expected) = &expected {
+                    assert_eq!(&ids, expected);
+                } else {
+                    expected = Some(ids.clone());
+                }
+                for (name, value) in [
+                    ("top", false),
+                    ("P::x", true),
+                    ("P::defaultRef", true),
+                    ("P::selfLink", false),
+                    ("P::e", true),
+                    ("Q::z", true),
+                ] {
+                    let e = r.resolve_qualified(name).unwrap();
+                    assert_eq!(
+                        r.usage_variability_report(e).value,
+                        Ok(value),
+                        "mode {mode}: {name}"
+                    );
+                    for property in ["mayTimeVary", "isVariable"] {
+                        assert_eq!(r.property(e, property), Ok(json!(value)));
+                    }
+                }
+                let end = r.resolve_qualified("P::e").unwrap();
+                let unresolved = r.resolve_qualified("MissingType::unresolved").unwrap();
+                assert!(r.usage_variability_report(unresolved).value.is_err());
+                if format == crate::model::GraphFormat::LegacyV2 {
+                    assert_eq!(
+                        r.property(end, "isConstant"),
+                        Err(PropertyError::NotComputed)
+                    );
+                } else {
+                    assert_eq!(r.property(end, "isConstant"), Ok(json!(true)));
+                    assert!(r.property(unresolved, "isConstant").is_err());
+                    let proven = r.resolve_qualified("Q::z").unwrap();
+                    assert_eq!(r.property(proven, "isConstant"), Ok(json!(true)));
+                }
+                assert_eq!(
+                    ids,
+                    r.user_elements()
+                        .map(|e| r.element_id(e))
+                        .collect::<Vec<_>>()
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/json/value_context.rs b/crates/sysmlv2-model/src/json/value_context.rs
new file mode 100644
index 0000000..e9dd194
--- /dev/null
+++ b/crates/sysmlv2-model/src/json/value_context.rs
@@ -0,0 +1,381 @@
+//! Bounded, identity-based receiver selection for authored value expressions.
+use super::{
+    Builder, ElementRef, ResolvedModel, ScopeRef, provider_completeness::ProviderCompleteness,
+};
+use crate::metaclass::conforms;
+use std::collections::{HashMap, HashSet};
+
+/// Proven evaluation context for a stored value expression.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ValueScopeDecision {
+    /// The caller has no applicable featuring receiver; use declaration scope.
+    Lexical(ScopeRef),
+    /// A complete, identity-based proof admits this featuring scope.
+    Receiver(ScopeRef),
+    /// Missing/ambiguous evidence or a resource limit prevents safe selection.
+    Unsupported,
+}
+
+fn charge(steps: &mut usize, count: usize) -> Option<()> {
+    *steps = steps.saturating_add(count);
+    (*steps <= crate::eval::MAX_STEPS).then_some(())
+}
+
+/// Proof cache for one evaluation/query over one unchanged resolved model.
+/// Do not reuse this cache for another model or after declaration/identity
+/// mutation. IDs and relationships may change between queries; no facts here
+/// are serialized.
+#[derive(Default)]
+pub struct ValueScopeResolver {
+    providers: ProviderCompleteness,
+    // Depth is part of the key: a shallow proof cannot bypass a later depth cap.
+    reaches: HashMap<(usize, usize, usize), bool>,
+}
+
+impl ValueScopeResolver {
+    /// Select a scope using query-local proofs. Do not retain this resolver
+    /// across mutations of model declarations or identity bindings.
+    pub fn select(
+        &mut self,
+        model: &mut ResolvedModel,
+        element: ElementRef,
+        receiver: Option<ScopeRef>,
+        steps: &mut usize,
+    ) -> ValueScopeDecision {
+        self.select_builder(
+            &mut model.b,
+            element.0,
+            receiver.map(|scope| scope.0),
+            steps,
+        )
+    }
+
+    pub(crate) fn select_builder(
+        &mut self,
+        b: &mut Builder,
+        element: usize,
+        receiver: Option<usize>,
+        steps: &mut usize,
+    ) -> ValueScopeDecision {
+        self.select_inner(b, element, receiver, steps)
+            .unwrap_or(ValueScopeDecision::Unsupported)
+    }
+
+    fn select_inner(
+        &mut self,
+        b: &mut Builder,
+        element: usize,
+        receiver: Option<usize>,
+        steps: &mut usize,
+    ) -> Option<ValueScopeDecision> {
+        charge(steps, 1)?;
+        b.elements.get(element)?;
+        let lexical = b.values.get(&element)?.0;
+        b.scopes.get(lexical)?;
+        let Some(receiver) = receiver else {
+            return Some(ValueScopeDecision::Lexical(ScopeRef(lexical)));
+        };
+        b.scopes.get(receiver)?;
+        if receiver == lexical {
+            return Some(ValueScopeDecision::Receiver(ScopeRef(lexical)));
+        }
+        let Some(owner) = b.owner_elem(element) else {
+            return Some(ValueScopeDecision::Lexical(ScopeRef(lexical)));
+        };
+        if !conforms(b.elements.get(owner)?.ty, "Type") {
+            return Some(ValueScopeDecision::Lexical(ScopeRef(lexical)));
+        }
+
+        // Lambda/local scopes and nested declarations are not automatically the
+        // featuring receiver. Prefer the nearest enclosing Type proven related
+        // to the value's actual owner. An unrelated Type does not end the walk:
+        // Child::Nested can read Base::v through its enclosing Child receiver.
+        let mut candidate_scope = Some(receiver);
+        let mut seen_scopes = HashSet::new();
+        for _ in 0..=super::MAX_RESOLUTION_DEPTH {
+            let Some(scope) = candidate_scope else {
+                return Some(ValueScopeDecision::Lexical(ScopeRef(lexical)));
+            };
+            charge(steps, 1)?;
+            if !seen_scopes.insert(scope) {
+                return None;
+            }
+            let context = b.scopes.get(scope)?;
+            let candidate = context.owner;
+            candidate_scope = context.parent;
+            if let Some(candidate) = candidate {
+                if conforms(b.elements.get(candidate)?.ty, "Type") {
+                    if candidate == owner {
+                        return Some(ValueScopeDecision::Receiver(ScopeRef(scope)));
+                    }
+                    if !self.providers.scope(b, scope, steps) {
+                        return None;
+                    }
+                    if self.semantically_reaches(
+                        b,
+                        candidate,
+                        owner,
+                        0,
+                        &mut HashSet::new(),
+                        steps,
+                    )? {
+                        return Some(ValueScopeDecision::Receiver(ScopeRef(scope)));
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    /// Complete closure of the implemented semantic bases, using stored UUID
+    /// endpoints and the shared implied plan. Lookup-only name bases are not
+    /// specialization evidence.
+    /// Complete the closure after a match: another branch may be unresolved or
+    /// cyclic, invalidating any claim that the receiver context is supported.
+    fn semantically_reaches(
+        &mut self,
+        b: &mut Builder,
+        current: usize,
+        target: usize,
+        depth: usize,
+        active: &mut HashSet<usize>,
+        steps: &mut usize,
+    ) -> Option<bool> {
+        charge(steps, 1)?;
+        if depth > super::MAX_RESOLUTION_DEPTH {
+            return None;
+        }
+        let key = (current, target, depth);
+        if let Some(&found) = self.reaches.get(&key) {
+            return Some(found);
+        }
+        if !conforms(b.elements.get(current)?.ty, "Type") || !active.insert(current) {
+            return None;
+        }
+        let result = (|| {
+            // Conjugation replaces ordinary supertypes. The legacy lookup
+            // context can still include both on a malformed mixed declaration,
+            // so it cannot safely supply inherited expression dependencies.
+            let relationships = &b.elements[current].owned_relationships;
+            charge(steps, relationships.len())?;
+            let conjugated = relationships
+                .iter()
+                .any(|&r| conforms(b.elements[r].ty, "Conjugation"));
+            if conjugated
+                && relationships
+                    .iter()
+                    .any(|&r| conforms(b.elements[r].ty, "Specialization"))
+            {
+                return None;
+            }
+            let scope = *b.elem_scope.get(&current)?;
+            if !self.providers.scope(b, scope, steps) {
+                return None;
+            }
+            let mut found = current == target;
+            for parent in b.value_context_bases(current, steps)? {
+                found |= self.semantically_reaches(b, parent, target, depth + 1, active, steps)?;
+            }
+            Some(found)
+        })();
+        active.remove(&current);
+        if let Some(found) = result {
+            self.reaches.insert(key, found);
+        }
+        result
+    }
+}
+
+impl ResolvedModel {
+    /// Select the evaluation scope for an authored feature value. Qualified,
+    /// aliased and ID-bound reads use the same already-resolved element identity.
+    /// Nested lexical scopes may use a proven enclosing receiver. An incomplete
+    /// proof must be propagated as unsupported rather than silently defaulted.
+    pub fn value_scope_decision_with_steps(
+        &mut self,
+        element: ElementRef,
+        receiver: Option<ScopeRef>,
+        steps: &mut usize,
+    ) -> ValueScopeDecision {
+        ValueScopeResolver::default().select_builder(
+            &mut self.b,
+            element.0,
+            receiver.map(|scope| scope.0),
+            steps,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Model;
+
+    fn resolved() -> ResolvedModel {
+        let mut m = Model::new();
+        let unit = m.add_source(
+            "contexts.kerml",
+            "package P {
+                class Base { feature p = 1; feature v = p; }
+                class Child specializes Base { feature redefines p = 2; class Nested; }
+                class Other { feature p = 3; alias v for Base::v; }
+                class Broken specializes Base, missing;
+                class CycleA specializes Base, CycleB;
+                class CycleB specializes CycleA;
+                feature instanceFeature : Child;
+                feature constantValue = 8;
+            }",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&m)
+    }
+
+    #[test]
+    fn own_inherited_typed_nested_and_unrelated_scopes_are_distinct() {
+        let mut r = resolved();
+        let value = r.resolve_qualified("P::Base::v").unwrap();
+        let lexical = r.value_expr(value).unwrap().0;
+        let mut proof = ValueScopeResolver::default();
+        let mut steps = 0;
+        for (name, selected) in [
+            ("P::Base", Some("P::Base")),
+            ("P::Child", Some("P::Child")),
+            ("P::instanceFeature", Some("P::instanceFeature")),
+            ("P::Child::Nested", Some("P::Child")),
+            ("P::Other", None),
+        ] {
+            let element = r.resolve_qualified(name).unwrap();
+            let scope = r.element_scope(element).unwrap();
+            let expected = selected.map_or(ValueScopeDecision::Lexical(lexical), |name| {
+                let owner = r.resolve_qualified(name).unwrap();
+                ValueScopeDecision::Receiver(r.element_scope(owner).unwrap())
+            });
+            assert_eq!(
+                proof.select_builder(&mut r.b, value.0, Some(scope.0), &mut steps),
+                expected
+            );
+        }
+        assert_eq!(
+            proof.select_builder(&mut r.b, value.0, None, &mut steps),
+            ValueScopeDecision::Lexical(lexical)
+        );
+    }
+
+    #[test]
+    fn package_values_and_imported_aliases_do_not_gain_unrelated_receivers() {
+        let mut r = resolved();
+        let base_value = r.resolve_qualified("P::Base::v").unwrap();
+        let alias = r.resolve_qualified("P::Other::v").unwrap();
+        assert_eq!(alias, base_value);
+        let other = r.resolve_qualified("P::Other").unwrap();
+        let other_scope = r.element_scope(other).unwrap();
+        for value in [base_value, r.resolve_qualified("P::constantValue").unwrap()] {
+            let lexical = r.value_expr(value).unwrap().0;
+            assert_eq!(
+                r.value_scope_decision_with_steps(value, Some(other_scope), &mut 0),
+                ValueScopeDecision::Lexical(lexical)
+            );
+        }
+    }
+
+    #[test]
+    fn missing_or_cyclic_contexts_never_become_lexical_fallback() {
+        let mut r = resolved();
+        let value = r.resolve_qualified("P::Base::v").unwrap();
+        for name in ["P::Broken", "P::CycleA"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            let scope = r.element_scope(owner).unwrap();
+            assert_eq!(
+                r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+                ValueScopeDecision::Unsupported
+            );
+        }
+        let owner = r.resolve_qualified("P::Child").unwrap();
+        let scope = r.element_scope(owner).unwrap();
+        let mut exhausted = crate::eval::MAX_STEPS;
+        assert_eq!(
+            r.value_scope_decision_with_steps(value, Some(scope), &mut exhausted),
+            ValueScopeDecision::Unsupported
+        );
+        assert_eq!(
+            r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+            ValueScopeDecision::Receiver(scope)
+        );
+    }
+
+    #[test]
+    fn conjugation_admits_a_receiver_but_mixed_specialization_does_not() {
+        let mut model = Model::new();
+        let unit = model.add_source(
+            "conjugated-context.kerml",
+            "classifier Base { feature p = 1; feature v = p; }
+             classifier Other { feature p = 9; }
+             classifier Context conjugates Base { feature ownLiteral = 8; }
+             classifier Donor specializes Other;",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let value = r.resolve_qualified("Base::v").unwrap();
+        let base = r.resolve_qualified("Base").unwrap();
+        let context = r.resolve_qualified("Context").unwrap();
+        let own_literal = r.resolve_qualified("Context::ownLiteral").unwrap();
+        let scope = r.element_scope(context).unwrap();
+        for _ in 0..2 {
+            assert_eq!(
+                r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+                ValueScopeDecision::Receiver(scope)
+            );
+        }
+
+        // Form a graph forbidden by the specific-not-conjugated constraint.
+        // Type::supertypes still selects only the conjugated Base, while the
+        // legacy lookup can retain an ordinary specialization provider too.
+        let donor = r.resolve_qualified("Donor").unwrap();
+        let relationship = *r.b.elements[donor.0]
+            .owned_relationships
+            .iter()
+            .find(|&&rel| conforms(r.b.elements[rel].ty, "Specialization"))
+            .unwrap();
+        r.b.elements[context.0]
+            .owned_relationships
+            .push(relationship);
+        assert_eq!(
+            r.b.value_context_bases(context.0, &mut 0),
+            Some(vec![base.0])
+        );
+        for _ in 0..2 {
+            // Each query gets a new proof cache after the graph mutation.
+            assert_eq!(
+                r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+                ValueScopeDecision::Unsupported
+            );
+            assert_eq!(
+                r.value_scope_decision_with_steps(own_literal, Some(scope), &mut 0),
+                ValueScopeDecision::Receiver(scope)
+            );
+            assert_eq!(r.evaluate(own_literal), Ok(crate::eval::Value::Integer(8)));
+        }
+    }
+
+    #[test]
+    fn receiver_proof_uses_stored_identity_after_id_remapping() {
+        let mut r = resolved();
+        let value = r.resolve_qualified("P::Base::v").unwrap();
+        let base = r.resolve_qualified("P::Base").unwrap();
+        let child = r.resolve_qualified("P::Child").unwrap();
+        let scope = r.element_scope(child).unwrap();
+        assert_eq!(
+            r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+            ValueScopeDecision::Receiver(scope)
+        );
+        r.override_ids(&HashMap::from([(
+            r.element_id(base),
+            "99999999-9999-4999-8999-999999999999".parse().unwrap(),
+        )]));
+        // Never reuse an evaluation-local proof across this mutation.
+        assert_eq!(
+            r.value_scope_decision_with_steps(value, Some(scope), &mut 0),
+            ValueScopeDecision::Receiver(scope)
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/layered.rs b/crates/sysmlv2-model/src/layered.rs
index 6056588..2868587 100644
--- a/crates/sysmlv2-model/src/layered.rs
+++ b/crates/sysmlv2-model/src/layered.rs
@@ -7,10 +7,68 @@
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::{
     collections::HashMap,
+    hash::BuildHasherDefault,
     ops::{Index, IndexMut},
     sync::Arc,
 };
 
+/// A hasher for the keys the tables are indexed by — row indices, scope
+/// indices, identities: a multiply-rotate fold of the key's words, cheap
+/// where the standard hasher's keyed rounds cost a resolution pass a few
+/// percent. Iteration order of a table hashed this way is as unspecified
+/// as it was with the standard hasher, so nothing may read one.
+#[derive(Clone, Copy, Default)]
+pub(crate) struct IdHasher(u64);
+
+impl IdHasher {
+    #[inline]
+    fn add(&mut self, word: u64) {
+        self.0 = (self.0.rotate_left(5) ^ word).wrapping_mul(0x517c_c1b7_2722_0a95);
+    }
+}
+
+impl std::hash::Hasher for IdHasher {
+    #[inline]
+    fn finish(&self) -> u64 {
+        // The low bits of a short key's last product depend on few of
+        // its bytes; fold the high half in for the bucket index.
+        self.0 ^ (self.0 >> 32)
+    }
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        for chunk in bytes.chunks(8) {
+            let mut word = [0u8; 8];
+            word[..chunk.len()].copy_from_slice(chunk);
+            self.add(u64::from_le_bytes(word));
+        }
+    }
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.add(u64::from(i));
+    }
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.add(u64::from(i));
+    }
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.add(u64::from(i));
+    }
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.add(i);
+    }
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.add(i as u64);
+    }
+}
+
+/// A hash map over the tables' keys (see [`IdHasher`]).
+pub(crate) type IdMap<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
+/// A hash set over the tables' keys (see [`IdHasher`]).
+pub(crate) type IdSet<K> = std::collections::HashSet<K, BuildHasherDefault<IdHasher>>;
+
 #[cfg(test)]
 thread_local! {
     static COPIED_ROWS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
@@ -32,7 +90,19 @@ fn note_copied(rows: usize) {
 #[cfg(not(test))]
 fn note_copied(_rows: usize) {}
 
+/// Opaque content revision, allocated only when a reader observes a snapshot.
+/// Mutable access clears the table's token, even if its length stays unchanged.
+/// Pointer identity is safe because observers retain a strong reference.
+#[derive(Clone, Default)]
+pub(crate) struct Revision(Arc<()>);
+impl Revision {
+    pub(crate) fn same_as(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
+    }
+}
+
 pub(crate) struct LayeredVec<T> {
+    revision: Option<Revision>,
     base: Arc<Vec<T>>,
     changed: Vec<Option<Box<T>>>,
     tail: Vec<T>,
@@ -41,6 +111,7 @@ impl<T: Clone> Clone for LayeredVec<T> {
     fn clone(&self) -> Self {
         note_copied(self.changed.iter().flatten().count() + self.tail.len());
         Self {
+            revision: self.revision.clone(),
             base: Arc::clone(&self.base),
             changed: self.changed.clone(),
             tail: self.tail.clone(),
@@ -50,6 +121,7 @@ impl<T: Clone> Clone for LayeredVec<T> {
 impl<T> Default for LayeredVec<T> {
     fn default() -> Self {
         Self {
+            revision: None,
             base: Arc::new(Vec::new()),
             changed: Vec::new(),
             tail: Vec::new(),
@@ -57,16 +129,59 @@ impl<T> Default for LayeredVec<T> {
     }
 }
 impl<T> LayeredVec<T> {
+    pub(crate) fn revision(&self) -> Option<&Revision> {
+        self.revision.as_ref()
+    }
+    pub(crate) fn observe_revision(&mut self) -> Revision {
+        self.revision.get_or_insert_with(Revision::default).clone()
+    }
+    /// Install a fully staged append and the exact revision reserved by its
+    /// semantic snapshot. No caller code runs between validation and append.
+    pub(crate) fn append_staged(&mut self, rows: Vec<T>, expected: &Revision, next: Revision) {
+        assert!(self.revision().is_some_and(|now| now.same_as(expected)));
+        if rows.is_empty() {
+            assert!(next.same_as(expected));
+            return;
+        }
+        assert!(!next.same_as(expected));
+        self.tail.extend(rows);
+        self.revision = Some(next);
+    }
     pub fn len(&self) -> usize {
         self.base.len() + self.tail.len()
     }
+    /// The frozen rows this table shares with the table it was cloned from.
+    pub(crate) fn base_arc(&self) -> &Arc<Vec<T>> {
+        &self.base
+    }
+    pub(crate) fn base_len(&self) -> usize {
+        self.base.len()
+    }
+    /// Whether no frozen row has been written since the freeze: a scan of
+    /// the frozen rows then still describes them.
+    pub(crate) fn base_untouched(&self) -> bool {
+        self.changed.is_empty()
+    }
     pub fn get(&self, i: usize) -> Option<&T> {
         (i < self.len()).then(|| &self[i])
     }
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
+    /// Restrict removal to the mutable suffix; prepared/library rows remain.
+    pub fn can_truncate_tail(&self, n: usize) -> bool {
+        self.base.len() <= n && n <= self.len()
+    }
+    pub fn truncate_tail(&mut self, n: usize) {
+        assert!(self.can_truncate_tail(n));
+        if n == self.len() {
+            return;
+        }
+        self.revision = None;
+        self.tail.truncate(n - self.base.len());
+    }
     pub fn push(&mut self, value: T) {
+        self.revision = None;
         self.tail.push(value)
     }
     pub fn iter(&self) -> impl DoubleEndedIterator<Item = &T> {
@@ -121,6 +236,7 @@ impl<T> Index<usize> for LayeredVec<T> {
 }
 impl<T: Clone> IndexMut<usize> for LayeredVec<T> {
     fn index_mut(&mut self, i: usize) -> &mut T {
+        self.revision = None;
         if i < self.base.len() {
             if self.changed.is_empty() {
                 self.changed.resize_with(self.base.len(), || None);
@@ -145,6 +261,9 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for LayeredVec<T> {
 impl<T: Clone> LayeredVec<T> {
     pub fn resize(&mut self, n: usize, value: T) {
         assert!(n >= self.len());
+        if n != self.len() {
+            self.revision = None;
+        }
         self.tail.resize(n - self.base.len(), value);
     }
 }
@@ -158,8 +277,8 @@ impl<T> LayeredVec<T> {
 
 /// Lookup table with an immutable library base and a private model table.
 pub(crate) struct LayeredMap<K, V> {
-    base: Arc<HashMap<K, V>>,
-    local: HashMap<K, V>,
+    base: Arc<IdMap<K, V>>,
+    local: IdMap<K, V>,
 }
 impl<K: Clone, V: Clone> Clone for LayeredMap<K, V> {
     fn clone(&self) -> Self {
@@ -173,8 +292,8 @@ impl<K: Clone, V: Clone> Clone for LayeredMap<K, V> {
 impl<K, V> Default for LayeredMap<K, V> {
     fn default() -> Self {
         Self {
-            base: Arc::new(HashMap::new()),
-            local: HashMap::new(),
+            base: Arc::new(IdMap::default()),
+            local: IdMap::default(),
         }
     }
 }
@@ -229,13 +348,17 @@ impl<'de, K: Deserialize<'de> + Eq + std::hash::Hash, V: Deserialize<'de>> Deser
 {
     fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
         Ok(Self {
-            local: HashMap::deserialize(d)?,
+            local: IdMap::deserialize(d)?,
             ..Self::default()
         })
     }
 }
 
 impl<K: Eq + std::hash::Hash, V> LayeredMap<K, V> {
+    /// The frozen table, while no local row overlays it.
+    pub(crate) fn frozen_arc(&self) -> Option<&Arc<IdMap<K, V>>> {
+        self.local.is_empty().then_some(&self.base)
+    }
     pub fn contains_key(&self, k: &K) -> bool {
         self.local.contains_key(k) || self.base.contains_key(k)
     }
@@ -248,6 +371,20 @@ impl<K: Eq + std::hash::Hash, V> LayeredMap<K, V> {
     pub fn keys(&self) -> impl Iterator<Item = &K> {
         self.iter().map(|(k, _)| k)
     }
+    /// Whether both tables hold the same value for every key `admit`
+    /// accepts. Tables sharing one base differ only in their private rows.
+    pub fn agrees_on(&self, other: &Self, admit: impl Fn(&K) -> bool) -> bool
+    where
+        V: PartialEq,
+    {
+        let keys: Box<dyn Iterator<Item = &K>> = if Arc::ptr_eq(&self.base, &other.base) {
+            Box::new(self.local.keys().chain(other.local.keys()))
+        } else {
+            Box::new(self.keys().chain(other.keys()))
+        };
+        keys.filter(|k| admit(k))
+            .all(|k| self.get(k) == other.get(k))
+    }
 }
 impl<K: Eq + std::hash::Hash + Clone, V: Clone> LayeredMap<K, V> {
     pub fn entry(&mut self, k: K) -> std::collections::hash_map::Entry<'_, K, V> {
@@ -288,6 +425,7 @@ impl<T> FromIterator<T> for LayeredVec<T> {
 }
 impl<T> Extend<T> for LayeredVec<T> {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        self.revision = None;
         self.tail.extend(iter);
     }
 }
@@ -296,6 +434,47 @@ impl<T> Extend<T> for LayeredVec<T> {
 mod overlay_tests {
     use super::*;
     #[test]
+    fn deserialization_preserves_rows_without_reusing_snapshot_revision() {
+        let mut rows: LayeredVec<_> = vec![1, 2].into();
+        let observed = rows.observe_revision();
+        let bytes = serde_json::to_vec(&rows).unwrap();
+        let mut decoded: LayeredVec<i32> = serde_json::from_slice(&bytes).unwrap();
+        assert_eq!(
+            rows.iter().copied().collect::<Vec<_>>(),
+            decoded.iter().copied().collect::<Vec<_>>()
+        );
+        assert!(decoded.revision().is_none());
+        assert!(!observed.same_as(&decoded.observe_revision()));
+    }
+
+    #[test]
+    fn revisions_follow_rows_across_clone_freeze_and_same_length_edits() {
+        let mut rows: LayeredVec<_> = vec![1, 2].into();
+        assert!(rows.revision().is_none());
+        let original = rows.observe_revision();
+        rows.freeze();
+        assert!(original.same_as(rows.revision().unwrap()));
+        let mut copy = rows.clone();
+        assert!(original.same_as(copy.revision().unwrap()));
+        copy[0] = 3;
+        assert!(copy.revision().is_none());
+        assert!(original.same_as(rows.revision().unwrap()));
+        let edited = copy.observe_revision();
+        assert!(!original.same_as(&edited));
+        copy.freeze();
+        assert!(edited.same_as(copy.revision().unwrap()));
+        copy.push(4);
+        assert!(copy.revision().is_none());
+        let pushed = copy.observe_revision();
+        copy.extend([5]);
+        assert!(copy.revision().is_none());
+        assert!(!pushed.same_as(&copy.observe_revision()));
+        copy.resize(5, 6);
+        assert!(copy.revision().is_none());
+        let mut replaced: LayeredVec<_> = vec![1, 2].into();
+        assert!(!original.same_as(&replaced.observe_revision()));
+    }
+    #[test]
     fn overrides_append_and_refreeze_do_not_change_shared_bases() {
         let mut a: LayeredVec<_> = vec![1, 2].into();
         a.freeze();
@@ -352,3 +531,22 @@ mod overlay_tests {
         );
     }
 }
+
+#[cfg(test)]
+mod staged_revision_tests {
+    use super::*;
+    #[test]
+    fn append_installs_exact_token_and_other_mutations_invalidate_it() {
+        let mut rows: LayeredVec<_> = vec![1].into();
+        let old = rows.observe_revision();
+        let next = Revision::default();
+        rows.append_staged(vec![2], &old, next.clone());
+        assert!(!rows.revision().unwrap().same_as(&old));
+        assert!(rows.observe_revision().same_as(&next));
+        rows[0] = 3;
+        assert!(rows.revision().is_none());
+        let same = rows.observe_revision();
+        rows.append_staged(Vec::new(), &same, same.clone());
+        assert!(rows.observe_revision().same_as(&same));
+    }
+}
diff --git a/crates/sysmlv2-model/src/lib.rs b/crates/sysmlv2-model/src/lib.rs
index b52c829..07ba220 100644
--- a/crates/sysmlv2-model/src/lib.rs
+++ b/crates/sysmlv2-model/src/lib.rs
@@ -19,6 +19,8 @@ pub mod libcache;
 pub mod lift;
 pub mod loader;
 mod metaclass;
+pub mod metamodel;
+mod operation_catalog;
 
 /// The canonical (`'static`) spelling of an abstract-syntax metaclass
 /// name, `None` for a name the metamodel does not declare.
@@ -27,12 +29,13 @@ pub fn metaclass_name(name: &str) -> Option<&'static str> {
 }
 #[cfg(test)]
 mod metaclass_tests;
+pub mod migration;
 pub mod model;
 pub mod prepared;
 pub mod quantity;
 pub mod rational;
-pub mod render;
 mod schema_props;
+mod semantic_catalog;
 pub mod structure;
 
 mod semantic_memo;
diff --git a/crates/sysmlv2-model/src/libcache.rs b/crates/sysmlv2-model/src/libcache.rs
index 740ecef..f6611a0 100644
--- a/crates/sysmlv2-model/src/libcache.rs
+++ b/crates/sysmlv2-model/src/libcache.rs
@@ -41,7 +41,9 @@ use uuid::Uuid;
 // changes; bump the MAGIC digit only for serialized-layout changes.
 // v6: outcomes may carry the root names their resolution missed, so a
 // replay can re-resolve exactly the entries a model's root additions reach.
-const MAGIC: &[u8; 8] = b"SYSML6LC";
+// v7: include the authored graph format so resolution recordings cannot cross it.
+// v8: whether the outcomes are the library's own fixed point.
+const MAGIC: &[u8; 8] = b"SYSML8LC";
 
 /// Toolkit build identity stamped into every serialized cache: the crate
 /// version plus a fingerprint of the semantics-bearing crate sources
@@ -67,6 +69,12 @@ const _: () = assert!(
 /// unresolved long tail is re-reported identically without re-searching).
 #[derive(Clone)]
 pub struct LibraryCache {
+    pub(crate) graph_format: crate::model::GraphFormat,
+    /// Whether the outcomes are the library's own fixed point: recorded
+    /// from the library alone, by a resolution whose passes agreed. An
+    /// oscillating library keeps its first pass's outcomes instead, which a
+    /// replay may not treat as final.
+    pub(crate) fixed_point: bool,
     pub(crate) outcomes: Vec<Option<Uuid>>,
     /// Per outcome, the root-namespace names its resolution looked up and
     /// missed. A model that introduces one of them resolves that entry
@@ -134,6 +142,13 @@ impl LibraryCache {
         write_atomically(path, &self.to_bytes())
     }
 
+    /// The graph format the outcomes were recorded for; a build of another
+    /// format cannot replay them.
+    #[must_use]
+    pub fn graph_format(&self) -> crate::model::GraphFormat {
+        self.graph_format
+    }
+
     /// The serialized form `save` writes — for hosts that carry the
     /// sealed snapshot without a filesystem (WASM: fetch the bytes,
     /// [`Self::from_bytes`] them). Versioned, fingerprinted, and
@@ -144,6 +159,8 @@ impl LibraryCache {
         buf.extend_from_slice(MAGIC);
         buf.push(TOOLKIT_BUILD.len() as u8);
         buf.extend_from_slice(TOOLKIT_BUILD.as_bytes());
+        buf.push(self.graph_format.version());
+        buf.push(u8::from(self.fixed_point));
         buf.extend_from_slice(&self.fingerprint.to_le_bytes());
         buf.extend_from_slice(&(self.outcomes.len() as u64).to_le_bytes());
         for (i, o) in self.outcomes.iter().enumerate() {
@@ -217,7 +234,18 @@ impl LibraryCache {
         if rest.len() < vlen || &rest[..vlen] != TOOLKIT_BUILD.as_bytes() {
             return None;
         }
-        let rest = &rest[vlen..];
+        let (format, rest) = rest[vlen..].split_first()?;
+        let graph_format = match format {
+            2 => crate::model::GraphFormat::LegacyV2,
+            3 => crate::model::GraphFormat::CanonicalV3,
+            _ => return None,
+        };
+        let (fixed_point, rest) = rest.split_first()?;
+        let fixed_point = match fixed_point {
+            0 => false,
+            1 => true,
+            _ => return None,
+        };
         if rest.len() < 16 {
             return None;
         }
@@ -323,6 +351,8 @@ impl LibraryCache {
             return None;
         }
         Some(LibraryCache {
+            graph_format,
+            fixed_point,
             outcomes,
             outcome_misses,
             fingerprint,
@@ -357,6 +387,22 @@ pub fn hash_library_dir(dir: &Path) -> io::Result<u64> {
     Ok(h.finish())
 }
 
+/// Content key of in-memory library units, `(name, text)` in load order:
+/// what a prepared snapshot of a source bundle is keyed by, so a bundle
+/// whose units changed (or were reordered) misses. Mixes the released
+/// version like [`hash_library_dir`].
+pub fn hash_units<'a>(units: impl IntoIterator<Item = (&'a str, &'a str)>) -> u64 {
+    let mut h = Fnv::new();
+    h.update(env!("CARGO_PKG_VERSION").as_bytes());
+    for (name, text) in units {
+        h.update(name.as_bytes());
+        h.update(&[0]);
+        h.update(text.as_bytes());
+        h.update(&[0]);
+    }
+    h.finish()
+}
+
 /// Default cache file path for a library keyed by `key`:
 /// `$SYSMLV2_CACHE_DIR`, else `$XDG_CACHE_HOME/sysmlv2`, else
 /// `$HOME/.cache/sysmlv2`. `None` when no base directory can be determined.
diff --git a/crates/sysmlv2-model/src/lift.rs b/crates/sysmlv2-model/src/lift.rs
index 578e5bb..9b83463 100644
--- a/crates/sysmlv2-model/src/lift.rs
+++ b/crates/sysmlv2-model/src/lift.rs
@@ -89,7 +89,9 @@ pub fn from_compact_json(value: &Value) -> Result<Lifted, LiftError> {
 /// multi-document list, so cross-document references print as
 /// `$::`-rooted qualified names instead of unresolvable ids (the same
 /// mechanism [`crate::json::library_name_map`] provides for standard-
-/// library ids).
+/// library ids). These replay locators retain historical anonymous reference
+/// labels; they are not normative semantic names. For those, use
+/// [`crate::json::ResolvedModel::element_effective_name`].
 pub fn document_name_map(value: &Value) -> std::collections::HashMap<String, Vec<String>> {
     let mut out = std::collections::HashMap::new();
     let Some(elements) = value.as_array() else {
@@ -100,8 +102,8 @@ pub fn document_name_map(value: &Value) -> std::collections::HashMap<String, Vec
         .enumerate()
         .filter_map(|(i, e)| e.get("@id").and_then(|v| v.as_str()).map(|id| (id, i)))
         .collect();
-    // Anonymous features are findable by their *effective* name (KerML
-    // 8.2.3.5 — redefinition / reference-subsetting derived): a
+    // Anonymous features remain findable by their existing syntax locator
+    // (including historical reference-subsetting labels): a
     // whole-list Lifter supplies it exactly as an in-document lift
     // would, so a cross-document reference to an anonymous redefining
     // feature (a chain landing on `attribute :>> x = …;` in another
@@ -202,7 +204,8 @@ pub fn document_name_map(value: &Value) -> std::collections::HashMap<String, Vec
 /// imports reference memberships directly, and a cross-document one
 /// must still print its member's name. This map adds each membership
 /// id → its member's path (`memberElement` where the payload carries
-/// it, else the owned member itself). Use it as `extra_names` when
+/// it, else the owned member itself), or the declaring namespace's path
+/// plus the alias name for named non-owning Memberships. Use it as `extra_names` when
 /// lifting; keep [`document_name_map`] where entries must be
 /// *elements* (id-identity comparisons).
 pub fn document_reference_name_map(
@@ -212,6 +215,14 @@ pub fn document_reference_name_map(
     let Some(elements) = value.as_array() else {
         return out;
     };
+    let roots: HashSet<&str> = elements
+        .iter()
+        .filter(|e| {
+            e.get("@type").and_then(Value::as_str) == Some("Namespace")
+                && e.get("owningRelationship").is_none_or(Value::is_null)
+        })
+        .filter_map(|e| e.get("@id").and_then(Value::as_str))
+        .collect();
     for e in elements {
         let t = e.get("@type").and_then(|v| v.as_str()).unwrap_or("");
         let Some(id) = e.get("@id").and_then(|v| v.as_str()) else {
@@ -220,6 +231,25 @@ pub fn document_reference_name_map(
         if !t.ends_with("Membership") || out.contains_key(id) {
             continue;
         }
+        if t == "Membership" {
+            if let Some(name) = e
+                .get("memberName")
+                .and_then(Value::as_str)
+                .or_else(|| e.get("memberShortName").and_then(Value::as_str))
+            {
+                if let Some(owner) = e.get("owningRelatedElement").and_then(ref_id) {
+                    let path = out
+                        .get(owner)
+                        .cloned()
+                        .or_else(|| roots.contains(owner).then(Vec::new));
+                    if let Some(mut path) = path {
+                        path.push(name.to_owned());
+                        out.insert(id.to_owned(), path);
+                        continue;
+                    }
+                }
+            }
+        }
         let member = e
             .get("memberElement")
             .and_then(|m| m.get("@id"))
@@ -385,6 +415,76 @@ pub fn from_compact_json_on_this_stack(
     lift_document(value, extra_names)
 }
 
+/// Collect omission roots while reading a row. Every row contributes seeds,
+/// even when duplicate IDs later replace it in the compatibility identity map.
+fn collect_omission_seeds<'a>(element: El<'a>, pending: &mut Vec<&'a str>) {
+    if element.get("isImplied").and_then(Value::as_bool) == Some(true) {
+        if let Some(id) = element.get("@id").and_then(Value::as_str) {
+            pending.push(id);
+        }
+    }
+    if element.get("language").and_then(Value::as_str) == Some(crate::full::UNRESOLVED_REP_LANGUAGE)
+    {
+        if let Some(id) = element.get("@id").and_then(Value::as_str) {
+            pending.push(id);
+        }
+        if let Some(id) = element
+            .get("owningRelationship")
+            .and_then(|relationship| relationship.get("@id"))
+            .and_then(Value::as_str)
+        {
+            pending.push(id);
+        }
+    }
+}
+
+/// Follow composition edges only; semantic references never propagate omission.
+/// The already validated lifter index and the loader wrapper share this walk.
+fn omission_closure<'a>(
+    mut pending: Vec<&'a str>,
+    by_id: &HashMap<&'a str, El<'a>>,
+) -> HashSet<&'a str> {
+    let mut omitted = HashSet::new();
+    while let Some(id) = pending.pop() {
+        if !omitted.insert(id) {
+            continue;
+        }
+        let Some(element) = by_id.get(id) else {
+            continue;
+        };
+        for key in ["ownedRelationship", "ownedRelatedElement"] {
+            if let Some(children) = element.get(key).and_then(Value::as_array) {
+                pending.extend(children.iter().filter_map(|child| child["@id"].as_str()));
+            }
+        }
+    }
+    omitted
+}
+
+/// Rows omitted when reconstructing source syntax, including the complete
+/// composition subtree of implied relationships and reference recovery notes.
+/// Semantic cross-references never propagate omission.
+pub(crate) fn omitted_element_ids(document: &Value) -> HashSet<&str> {
+    let Some(elements) = document.as_array() else {
+        return HashSet::new();
+    };
+    let mut pending = Vec::new();
+    for element in elements.iter().filter_map(Value::as_object) {
+        collect_omission_seeds(element, &mut pending);
+    }
+    if pending.is_empty() {
+        return HashSet::new();
+    }
+    let by_id = elements
+        .iter()
+        .filter_map(|element| {
+            let element = element.as_object()?;
+            Some((element.get("@id")?.as_str()?, element))
+        })
+        .collect();
+    omission_closure(pending, &by_id)
+}
+
 fn lift_document(
     value: &Value,
     extra_names: &HashMap<String, Vec<String>>,
@@ -394,6 +494,7 @@ fn lift_document(
     };
     let mut by_id: HashMap<&str, El> = HashMap::new();
     let mut order: Vec<&str> = Vec::new();
+    let mut omission_seeds = Vec::new();
     for item in items {
         let Value::Object(el) = item else {
             return Err(LiftError::NotAnElement);
@@ -401,9 +502,11 @@ fn lift_document(
         let Some(id) = el.get("@id").and_then(|v| v.as_str()) else {
             return Err(LiftError::ElementWithoutId);
         };
+        collect_omission_seeds(el, &mut omission_seeds);
         by_id.insert(id, el);
         order.push(id);
     }
+    let omitted = omission_closure(omission_seeds, &by_id);
     // Unresolved-reference recovery annotations: dangling id → spelling.
     let mut unresolved_names = HashMap::new();
     for el in by_id.values() {
@@ -435,7 +538,7 @@ fn lift_document(
         depth: 0,
         incomplete: false,
     };
-    lifter.dialect = lifter.detect_dialect();
+    lifter.dialect = lifter.detect_dialect(&omitted);
     lifter.compute_qnames(&order);
 
     // Roots: elements with no *in-document* owner — not owned by a
@@ -455,6 +558,9 @@ fn lift_document(
     };
     let mut members = Vec::new();
     for id in &order {
+        if omitted.contains(id) {
+            continue;
+        }
         let el = lifter.by_id[id];
         let unowned = !in_doc(&lifter, el, "owningRelationship")
             && !in_doc(&lifter, el, "owningRelatedElement");
@@ -844,11 +950,44 @@ impl<'a> Lifter<'a> {
         self.depth -= 1;
     }
 
-    fn detect_dialect(&self) -> Dialect {
-        for el in self.by_id.values() {
+    fn detect_dialect(&self, omitted: &HashSet<&str>) -> Dialect {
+        for (id, el) in &self.by_id {
+            if omitted.contains(id) {
+                continue;
+            }
             if KERML_MARKERS.contains(&ty(el)) {
                 return Dialect::Kerml;
             }
+            // Ordinary namespace-owned Feature declarations are KerML. Do not
+            // let parameter/result or chained Features generated inside SysML
+            // expressions choose the dialect.
+            if ty(el) == "Feature" {
+                let membership = el
+                    .get("owningRelationship")
+                    .and_then(ref_id)
+                    .and_then(|id| self.by_id.get(id).copied());
+                if let Some(membership) =
+                    membership.filter(|m| matches!(ty(m), "OwningMembership" | "FeatureMembership"))
+                {
+                    let owns = membership
+                        .get("ownedRelatedElement")
+                        .and_then(Value::as_array)
+                        .is_some_and(|children| {
+                            children.len() == 1 && children.first().and_then(ref_id) == Some(*id)
+                        });
+                    if owns
+                        && self.owner_of(el).is_some_and(|owner| {
+                            matches!(ty(owner), "Namespace" | "Package")
+                                && self
+                                    .owned_rels(owner)
+                                    .iter()
+                                    .any(|r| std::ptr::eq(*r, membership))
+                        })
+                    {
+                        return Dialect::Kerml;
+                    }
+                }
+            }
         }
         Dialect::Sysml
     }
@@ -886,18 +1025,8 @@ impl<'a> Lifter<'a> {
     /// referenced or redefined feature (KerML 8.2.3.5 / SysML reference
     /// forms), mirroring the emitter's scope registration.
     ///
-    /// One naming rule, four representations — an element is named by
-    /// its declaration, else by its *naming feature*: the first feature
-    /// it redefines, else the one it references, else the last link of
-    /// its chain, each followed transitively. The implementations are
-    /// this one (over payload JSON), `json::Builder::graph_effective_name`
-    /// (over the lowered element graph, where `Builder::effective_name`
-    /// is the declaration-only half), `full::effective_name_of` (over the
-    /// full form's element maps, which also derives the positional
-    /// implied names), and the fixpoint inside `ids::walk` (over a
-    /// compact payload, for id segments). They agree by construction and
-    /// by the differential test in the round-trip gate; a change to one
-    /// belongs in all of them.
+    /// This syntax locator preserves labels accepted by the resolver, including
+    /// historical anonymous reference labels. It is not semantic name selection.
     fn effective_name(&self, el: El<'a>, depth: usize) -> Option<String> {
         // A binary connector-family end is findable only as `source`/
         // `target` (its implied redefinition of the BinaryConnection ends —
@@ -912,7 +1041,20 @@ impl<'a> Lifter<'a> {
         if depth > 8 {
             return None;
         }
-        for rel in self.owned_rels(el) {
+        let membership = el
+            .get("owningRelationship")
+            .and_then(ref_id)
+            .and_then(|id| self.by_id.get(id))
+            .map(|r| ty(r));
+        let reference_chain =
+            crate::json::naming::reference_names_feature_target(ty(el), membership);
+        let rels = self.owned_rels(el);
+        let named_reference = crate::json::naming::reference_names_feature(ty(el), membership)
+            && rels.iter().any(|r| ty(r) == "ReferenceSubsetting");
+        for rel in rels {
+            if named_reference && ty(rel) != "ReferenceSubsetting" {
+                continue;
+            }
             let key = match ty(rel) {
                 "ReferenceSubsetting" => "referencedFeature",
                 "Redefinition" => "redefinedFeature",
@@ -922,17 +1064,22 @@ impl<'a> Lifter<'a> {
             if let Some(s) = v.get("@ref").and_then(|x| x.as_str()) {
                 return match target_from_ref_string(s) {
                     TargetRef::Name(qn) => qn.segments.last().map(|n| n.value.clone()),
-                    TargetRef::Chain(links) => links
-                        .last()
-                        .and_then(|l| l.segments.last())
-                        .map(|n| n.value.clone()),
+                    TargetRef::Chain(links) if reference_chain && key == "referencedFeature" => {
+                        links
+                            .last()
+                            .and_then(|l| l.segments.last())
+                            .map(|n| n.value.clone())
+                    }
+                    TargetRef::Chain(_) => None,
                 };
             }
             if let Some(id) = ref_id(v) {
                 if let Some(&target) = self.by_id.get(id) {
-                    // A chained target (owned chain Feature) takes its name
-                    // from the last link, mirroring the emitter.
-                    if let Some(last) = self.last_chaining_target(target) {
+                    // Only specialized reference forms name through a chain.
+                    if let Some(last) = self
+                        .last_chaining_target(target)
+                        .filter(|_| reference_chain && key == "referencedFeature")
+                    {
                         return match last {
                             ChainLink::Ref(name) => Some(name),
                             ChainLink::Id(link_id) => match self.by_id.get(link_id) {
@@ -1104,6 +1251,27 @@ impl<'a> Lifter<'a> {
         Some(kid)
     }
 
+    /// The canonical constructor stores its argument carriers on its result.
+    /// Keep the selector on the constructor while presenting arguments in their
+    /// authored order to both the iterative traversal and expression assembler.
+    fn invocation_relationships(&self, el: El<'a>) -> Vec<El<'a>> {
+        let relationships = self.owned_rels(el);
+        if ty(el) != "ConstructorExpression" {
+            return relationships;
+        }
+        let mut result = Vec::new();
+        for relationship in relationships {
+            if ty(relationship) == "ReturnParameterMembership" {
+                if let Some(feature) = self.first_related(relationship) {
+                    result.extend(self.owned_rels(feature));
+                }
+            } else {
+                result.push(relationship);
+            }
+        }
+        result
+    }
+
     /// Lift a reference property (`{"@id"}` or `{"@ref"}`) into a target.
     fn target(&mut self, holder: El<'a>, key: &str) -> Option<TargetRef> {
         let v = holder.get(key)?;
@@ -1122,12 +1290,32 @@ impl<'a> Lifter<'a> {
             }
         }
         // `importedMembership` is Membership-typed: an in-document
-        // membership names its member element (an alias membership's
-        // `memberElement` carries the canonical target). Library
+        // owning membership names its member element; a named alias names
+        // the Membership in its declaring namespace. Library
         // memberships are not in the document and name themselves through
         // the library name map below.
         if key == "importedMembership" {
             if let Some(&mel) = self.by_id.get(id) {
+                if ty(mel) == "Membership" {
+                    if let Some(alias) =
+                        sval(mel, "memberName").or_else(|| sval(mel, "memberShortName"))
+                    {
+                        if let Some(owner) = mel.get("owningRelatedElement").and_then(ref_id) {
+                            let path = self.qnames.get(owner).cloned().flatten().or_else(|| {
+                                self.by_id
+                                    .get(owner)
+                                    .filter(|e| ty(e) == "Namespace" && self.owner_of(e).is_none())
+                                    .map(|_| Vec::new())
+                            });
+                            if let Some(mut path) = path {
+                                path.push(alias.to_owned());
+                                return Some(TargetRef::Name(qn_global(&path)));
+                            }
+                        }
+                        // Anonymous ancestry can still admit a relative name.
+                        return Some(TargetRef::Name(qn_from_segments(&[alias.to_owned()])));
+                    }
+                }
                 if ty(mel).ends_with("Membership") {
                     if let Some(s) = mel
                         .get("memberElement")
@@ -2109,7 +2297,9 @@ impl<'a> Lifter<'a> {
             // usages isComposite is the derived-by-rule default (the `ref`
             // reconstruction below explains any non-default value).
             is_composite: bval(el, "isComposite") && self.dialect == Dialect::Kerml,
-            is_portion: bval(el, "isPortion"),
+            // `portion` is a KerML keyword. SysML uses `portionKind`;
+            // the document loader retains the original owned Boolean separately.
+            is_portion: bval(el, "isPortion") && self.dialect == Dialect::Kerml,
             // `var` is a KerML feature prefix with no SysML spelling —
             // dropped for `*Usage` metaclasses (some producers mark
             // plain attribute usages `isVariable: true`; printing `var`
@@ -3164,6 +3354,28 @@ impl<'a> Lifter<'a> {
     /// Children in precisely the order the expression assembler consumes
     /// them. Parameter wrappers and type-reference parameters add no AST
     /// depth. An expression body goes through the bounded member lifter.
+    // Full interchange also carries the derived memberElement alias. An owned
+    // expression is syntax to lift, not a name reference to that alias target.
+    fn owned_expression_reference(&self, rel: El<'a>) -> Option<El<'a>> {
+        if ty(rel) != "FeatureMembership" {
+            return None;
+        }
+        let children = rel.get("ownedRelatedElement")?.as_array()?;
+        if children.len() != 1 {
+            return None;
+        }
+        let inner = self.by_id.get(ref_id(&children[0])?).copied()?;
+        if !crate::metaclass::conforms(ty(inner), "Expression")
+            || inner.get("owningRelationship").and_then(ref_id) != Some(id_of(rel))
+            || rel
+                .get("memberElement")
+                .is_some_and(|alias| !alias.is_null() && ref_id(alias) != Some(id_of(inner)))
+        {
+            return None;
+        }
+        Some(inner)
+    }
+
     fn expression_children(&mut self, el: El<'a>) -> Vec<El<'a>> {
         match ty(el) {
             "FeatureReferenceExpression" => {
@@ -3171,6 +3383,9 @@ impl<'a> Lifter<'a> {
                     if ty(rel) == "ReturnParameterMembership" {
                         continue;
                     }
+                    if let Some(inner) = self.owned_expression_reference(rel) {
+                        return vec![inner];
+                    }
                     if self.target(rel, "memberElement").is_some() {
                         break;
                     }
@@ -3185,13 +3400,18 @@ impl<'a> Lifter<'a> {
             | "CollectExpression"
             | "SelectExpression"
             | "InvocationExpression"
-            | "ConstructorExpression"
             | "OperatorExpression" => self
                 .owned_rels(el)
                 .into_iter()
                 .filter(|rel| ty(rel) == "ParameterMembership")
                 .filter_map(|rel| self.param_expr_el(rel))
                 .collect(),
+            "ConstructorExpression" => self
+                .invocation_relationships(el)
+                .into_iter()
+                .filter(|rel| ty(rel) == "ParameterMembership")
+                .filter_map(|rel| self.param_expr_el(rel))
+                .collect(),
             _ => Vec::new(),
         }
     }
@@ -3258,6 +3478,9 @@ impl<'a> Lifter<'a> {
                     if ty(rel) == "ReturnParameterMembership" {
                         continue;
                     }
+                    if self.owned_expression_reference(rel).is_some() {
+                        return children.next().flatten();
+                    }
                     if let Some(target) = self.target(rel, "memberElement") {
                         return Some(target_to_expr(target));
                     }
@@ -3321,7 +3544,7 @@ impl<'a> Lifter<'a> {
                 let mut fn_ty = None;
                 let mut fnref = None;
                 let mut args = Vec::new();
-                for rel in self.owned_rels(el) {
+                for rel in self.invocation_relationships(el) {
                     match ty(rel) {
                         // A chained callee (`a.b(x)`) rides an
                         // OwningMembership owning the chain feature.
@@ -3881,3 +4104,113 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod omitted_dialect_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn implied_subtrees_do_not_select_a_dialect_or_become_roots() {
+        // Both a root implied marker and a marker below an implied carrier
+        // with an absent owner are omitted. Child flags are not required.
+        for document in [
+            json!([{"@id":"binding","@type":"BindingConnector","isImplied":true}]),
+            json!([
+                {"@id":"membership","@type":"OwningMembership","isImplied":true,
+                 "owningRelatedElement":{"@id":"outside"},
+                 "ownedRelatedElement":[{"@id":"child"}]},
+                {"@id":"child","@type":"Class","declaredName":"Generated",
+                 "owningRelationship":{"@id":"membership"}}
+            ]),
+        ] {
+            let lifted = from_compact_json(&document).unwrap();
+            assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+            assert_eq!(lifted.unit.dialect, Dialect::Sysml);
+            assert!(lifted.unit.members.is_empty());
+        }
+    }
+
+    #[test]
+    fn authored_markers_and_cross_reference_targets_remain_source() {
+        let document = json!([
+            {"@id":"implied","@type":"Subsetting","isImplied":true,
+             "target":[{"@id":"authored"}],"subsettedFeature":{"@id":"authored"}},
+            {"@id":"authored","@type":"Class","declaredName":"Authored",
+             "owningRelationship":{"@id":"outside"}}
+        ]);
+        assert_eq!(omitted_element_ids(&document), HashSet::from(["implied"]));
+        let lifted = from_compact_json(&document).unwrap();
+        assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+        assert_eq!(lifted.unit.dialect, Dialect::Kerml);
+        assert_eq!(lifted.unit.members.len(), 1);
+        assert!(sysmlv2_syntax::print::print_source(&lifted.unit).contains("class Authored"));
+        let authored_binding = json!([{"@id":"binding","@type":"BindingConnector"}]);
+        assert_eq!(
+            from_compact_json(&authored_binding).unwrap().unit.dialect,
+            Dialect::Kerml
+        );
+    }
+
+    #[test]
+    fn duplicate_ids_keep_all_omission_seeds_but_follow_the_last_row() {
+        for (document, expected) in [
+            (
+                json!([
+                    {"@id":"duplicate","@type":"OwningMembership","isImplied":true,
+                     "ownedRelatedElement":[{"@id":"earlier-child"}]},
+                    {"@id":"duplicate","@type":"OwningMembership","isImplied":false,
+                     "ownedRelatedElement":[{"@id":"later-child"}]},
+                    {"@id":"earlier-child","@type":"Package","declaredName":"Kept"},
+                    {"@id":"later-child","@type":"Class","declaredName":"Omitted"}
+                ]),
+                HashSet::from(["duplicate", "later-child"]),
+            ),
+            (
+                json!([
+                    {"@id":"duplicate","@type":"TextualRepresentation",
+                     "language":crate::full::UNRESOLVED_REP_LANGUAGE,
+                     "owningRelationship":{"@id":"recovery-carrier"},
+                     "ownedRelatedElement":[{"@id":"earlier-child"}]},
+                    {"@id":"duplicate","@type":"TextualRepresentation","language":"text",
+                     "ownedRelatedElement":[{"@id":"later-child"}]},
+                    {"@id":"recovery-carrier","@type":"OwningMembership",
+                     "ownedRelatedElement":[{"@id":"duplicate"}]},
+                    {"@id":"earlier-child","@type":"Package","declaredName":"Kept"},
+                    {"@id":"later-child","@type":"Class","declaredName":"Omitted"}
+                ]),
+                HashSet::from(["duplicate", "recovery-carrier", "later-child"]),
+            ),
+        ] {
+            // Seeds retain provenance from every row, but composition follows
+            // the same last-wins identity projection used by the lifter.
+            assert_eq!(omitted_element_ids(&document), expected);
+            let lifted = from_compact_json(&document).unwrap();
+            assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+            assert_eq!(lifted.unit.dialect, Dialect::Sysml);
+            assert_eq!(lifted.unit.members.len(), 1);
+            let source = sysmlv2_syntax::print::print_source(&lifted.unit);
+            assert!(source.contains("package Kept"), "{source}");
+            assert!(!source.contains("Omitted"), "{source}");
+        }
+    }
+
+    #[test]
+    fn omitted_composition_cycles_terminate_and_recovery_carriers_stay_omitted() {
+        let document = json!([
+            {"@id":"a","@type":"OwningMembership","isImplied":true,
+             "ownedRelatedElement":[{"@id":"b"}]},
+            {"@id":"b","@type":"Class","ownedRelationship":[{"@id":"a"}]},
+            {"@id":"note","@type":"TextualRepresentation",
+             "language":crate::full::UNRESOLVED_REP_LANGUAGE,
+             "owningRelationship":{"@id":"annotation"}},
+            {"@id":"annotation","@type":"OwningMembership",
+             "ownedRelatedElement":[{"@id":"note"}],"memberElement":{"@id":"kept"}},
+            {"@id":"kept","@type":"Package","declaredName":"Kept"}
+        ]);
+        assert_eq!(
+            omitted_element_ids(&document),
+            HashSet::from(["a", "b", "note", "annotation"])
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/loader.rs b/crates/sysmlv2-model/src/loader.rs
index 4c7468d..a27c0fc 100644
--- a/crates/sysmlv2-model/src/loader.rs
+++ b/crates/sysmlv2-model/src/loader.rs
@@ -19,6 +19,78 @@ use uuid::Uuid;
 /// element's metaclass).
 pub type ExplicitIds = HashMap<Uuid, (Uuid, &'static str)>;
 
+/// Identity references recovered from an interchange payload, keyed by
+/// reference-holder id and property name (with `#index` for arrays).
+/// Binding prunes this map to the references that the lift spelled as IDs.
+pub type IdReferenceBindings = HashMap<(Uuid, String), Uuid>;
+
+/// Record payload reference identities before textual lifting can confuse
+/// an anonymous target's UUID with another element's declared name.
+pub fn id_reference_bindings(document: &Value) -> IdReferenceBindings {
+    let Some(elements) = document.as_array() else {
+        return HashMap::new();
+    };
+    let by_id: HashMap<_, _> = elements
+        .iter()
+        .filter_map(|e| Some((e.get("@id")?.as_str()?, e)))
+        .collect();
+    let mut out = HashMap::new();
+    for element in elements {
+        let Some(owner) = element
+            .get("@id")
+            .and_then(Value::as_str)
+            .and_then(|id| Uuid::parse_str(id).ok())
+        else {
+            continue;
+        };
+        let Some(props) = element.as_object() else {
+            continue;
+        };
+        for (key, value) in props {
+            if crate::model::is_payload_usage_flag(element["@type"].as_str().unwrap_or(""), key) {
+                continue;
+            }
+            let mut record = |slot: String, value: &Value| {
+                let Some(mut target) = value.get("@id").and_then(Value::as_str) else {
+                    return;
+                };
+                // The lift spells membership imports through the member,
+                // and normal resolution restores the membership target.
+                if key == "importedMembership" {
+                    if let Some(member) = by_id.get(target) {
+                        if let Some(id) = member
+                            .get("memberElement")
+                            .and_then(|v| v.get("@id"))
+                            .and_then(Value::as_str)
+                            .or_else(|| {
+                                member
+                                    .get("ownedRelatedElement")
+                                    .and_then(Value::as_array)
+                                    .and_then(|v| v.first())
+                                    .and_then(|v| v.get("@id"))
+                                    .and_then(Value::as_str)
+                            })
+                        {
+                            target = id;
+                        }
+                    }
+                }
+                if let Ok(target) = Uuid::parse_str(target) {
+                    out.insert((owner, slot), target);
+                }
+            };
+            if let Some(items) = value.as_array() {
+                for (index, item) in items.iter().enumerate() {
+                    record(format!("{key}#{index}"), item);
+                }
+            } else {
+                record(key.clone(), value);
+            }
+        }
+    }
+    out
+}
+
 /// The explicit-id map of a loaded document: `(derived id → given id)`
 /// for every element of `document` whose structural counterpart in the
 /// rebuilt `model` derives a different id, plus the number of document
@@ -33,11 +105,102 @@ pub fn explicit_id_map(
     external: &dyn Fn(&str) -> Option<String>,
     warnings: &mut Vec<String>,
 ) -> (ExplicitIds, usize) {
-    use crate::ids::segment_paths;
     let emitted = model_to_compact_json(model);
-    let (doc_paths, model_paths) = match (
-        segment_paths(document, external),
-        segment_paths(&emitted, external),
+    let (mut pairs, unmatched) = paired_id_map(document, &emitted, external, warnings);
+    pairs.retain(|derived, (given, _)| derived != given);
+    (pairs, unmatched)
+}
+
+fn paired_id_map(
+    document: &Value,
+    emitted: &Value,
+    external: &dyn Fn(&str) -> Option<String>,
+    warnings: &mut Vec<String>,
+) -> (ExplicitIds, usize) {
+    use crate::ids::segment_paths;
+    let omitted = crate::lift::omitted_element_ids(document);
+    // Recovery annotations preserve the original unresolved spelling. Use
+    // the identity walk's spelling convention so full and compact input have
+    // the same structural paths, including quoted and UUID-shaped names.
+    let recovered: HashMap<_, _> = document
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|e| e["language"] == crate::full::UNRESOLVED_REP_LANGUAGE)
+        .filter_map(|e| {
+            let spelling = e.get("body")?.as_str()?;
+            let leaf = crate::ids::reference_path_name(spelling).to_owned();
+            Some((crate::json::dangling_id(spelling), leaf))
+        })
+        .collect();
+    let external = |id: &str| external(id).or_else(|| recovered.get(id).cloned());
+    // These expression carriers spell only a target, never a Membership
+    // alias. Full emission can nevertheless project the target's memberName.
+    // Ignore that projection for structural pairing with the lifted graph.
+    // Namespace and general Expression body aliases retain authored names.
+    let mut pairing_document = std::borrow::Cow::Borrowed(document);
+    if let Some(elements) = document.as_array() {
+        let reference_memberships: std::collections::HashSet<_> = elements
+            .iter()
+            .filter(|e| {
+                matches!(
+                    e["@type"].as_str(),
+                    Some(
+                        "FeatureReferenceExpression"
+                            | "FeatureChainExpression"
+                            | "InvocationExpression"
+                            | "ConstructorExpression"
+                            | "MetadataAccessExpression"
+                    )
+                )
+            })
+            .filter_map(|e| e["ownedRelationship"].as_array())
+            .flatten()
+            .filter_map(|r| r["@id"].as_str())
+            .collect();
+        let projected: Vec<_> = elements
+            .iter()
+            .enumerate()
+            .filter(|(_, e)| {
+                e["@type"] == "Membership"
+                    && e.get("qualifiedName").is_some()
+                    && e["@id"]
+                        .as_str()
+                        .is_some_and(|id| reference_memberships.contains(id))
+                    && (e["memberName"].is_string() || e["memberShortName"].is_string())
+            })
+            .map(|(i, _)| i)
+            .collect();
+        if !projected.is_empty() {
+            let elements = pairing_document.to_mut().as_array_mut().unwrap();
+            for i in projected {
+                let row = elements[i].as_object_mut().unwrap();
+                row.remove("memberName");
+                row.remove("memberShortName");
+            }
+        }
+    }
+    // Pair the same authored composition that the lift reconstructs. Generated
+    // redefinitions can supply effective names to otherwise positional argument
+    // carriers, and omitted relationships can shift later positional segments.
+    // Keep row indices stable while removing only the lift's omitted composition
+    // edges; semantic references and authored naming evidence remain untouched.
+    if !omitted.is_empty() {
+        if let Some(elements) = pairing_document.to_mut().as_array_mut() {
+            for element in elements {
+                for key in ["ownedRelationship", "ownedRelatedElement"] {
+                    if let Some(children) = element.get_mut(key).and_then(Value::as_array_mut) {
+                        children.retain(|child| {
+                            !child["@id"].as_str().is_some_and(|id| omitted.contains(id))
+                        });
+                    }
+                }
+            }
+        }
+    }
+    let (mut doc_paths, model_paths) = match (
+        segment_paths(&pairing_document, &external),
+        segment_paths(emitted, &external),
     ) {
         (Ok(d), Ok(m)) => (d, m),
         (Err(e), _) | (_, Err(e)) => {
@@ -48,6 +211,16 @@ pub fn explicit_id_map(
             return (HashMap::new(), 0);
         }
     };
+    // Detached omitted rows must not become roots, especially Namespace rows
+    // that would change the document ordinal of every following authored root.
+    for (i, path) in doc_paths.iter_mut().enumerate() {
+        if document[i]["@id"]
+            .as_str()
+            .is_some_and(|id| omitted.contains(id))
+        {
+            *path = None;
+        }
+    }
     let id_at = |v: &Value, i: usize| -> Option<Uuid> {
         v.get(i)?
             .get("@id")?
@@ -88,7 +261,7 @@ pub fn explicit_id_map(
                 .collect()
         };
     let doc_paths = ordinal_paths(doc_paths, document);
-    let model_paths = ordinal_paths(model_paths, &emitted);
+    let model_paths = ordinal_paths(model_paths, emitted);
     // A document whose root is not a document Namespace (a bare Package
     // at the top, as other producers emit) is rebuilt under a synthetic
     // root Namespace whose sole member it becomes: re-root the document's
@@ -151,44 +324,38 @@ pub fn explicit_id_map(
             })
         })
         .collect();
-    let mut by_path: HashMap<(usize, String), (Uuid, String)> = HashMap::new();
+    let mut by_path: HashMap<(usize, String), Option<(Uuid, String)>> = HashMap::new();
     for (i, path) in model_paths.into_iter().enumerate() {
-        if let (Some(path), Some(id)) = (path, id_at(&emitted, i)) {
-            by_path.insert(path, (id, ty_at(&emitted, i)));
+        if let (Some(path), Some(id)) = (path, id_at(emitted, i)) {
+            by_path
+                .entry(path)
+                .and_modify(|value| *value = None)
+                .or_insert_with(|| Some((id, ty_at(emitted, i))));
         }
     }
     // Elements the lift deliberately drops are not "unpreserved": implied
     // relationships and unresolved-reference recovery annotations (with
     // their memberships) of a full-form document.
-    let recovery: std::collections::HashSet<String> = document
-        .as_array()
-        .map(|a| {
-            let mut set = std::collections::HashSet::new();
-            for e in a {
-                if e["language"] == crate::full::UNRESOLVED_REP_LANGUAGE {
-                    if let Some(id) = e["@id"].as_str() {
-                        set.insert(id.to_string());
-                    }
-                    if let Some(m) = e["owningRelationship"]["@id"].as_str() {
-                        set.insert(m.to_string());
-                    }
-                }
-            }
-            set
-        })
-        .unwrap_or_default();
+    let mut doc_path_counts = HashMap::new();
+    for path in doc_paths.iter().flatten() {
+        *doc_path_counts.entry(path).or_insert(0usize) += 1;
+    }
     let mut map = HashMap::new();
     let mut unmatched = 0usize;
-    for (i, path) in doc_paths.into_iter().enumerate() {
+    for (i, path) in doc_paths.iter().enumerate() {
         let Some(given) = id_at(document, i) else {
             continue;
         };
-        let el = &document[i];
-        if el["isImplied"] == true || recovery.contains(given.to_string().as_str()) {
+        if omitted.contains(given.to_string().as_str()) {
             continue;
         }
         let doc_ty = ty_at(document, i);
-        match path.and_then(|p| by_path.get(&p)) {
+        match path
+            .as_ref()
+            .filter(|p| doc_path_counts.get(p) == Some(&1))
+            .and_then(|p| by_path.get(p))
+            .and_then(Option::as_ref)
+        {
             // Positional pairing is only trusted between elements of the
             // same metaclass (a document that lists a feature's typing
             // and value in the other order must not swap their ids). The
@@ -198,10 +365,8 @@ pub fn explicit_id_map(
                 if *model_ty == doc_ty
                     || (doc_ty == "Membership" && model_ty == "OwningMembership") =>
             {
-                if *derived != given {
-                    let ty = crate::metaclass_name(model_ty).unwrap_or("");
-                    map.insert(*derived, (given, ty));
-                }
+                let ty = crate::metaclass_name(model_ty).unwrap_or("");
+                map.insert(*derived, (given, ty));
             }
             _ => unmatched += 1,
         }
@@ -217,6 +382,63 @@ pub fn explicit_id_map(
 /// so the overlay is applied on every emission path; the resolved model
 /// carries the same overlay for the read API.
 pub fn overlay_explicit_ids(value: &mut Value, explicit_ids: &ExplicitIds) {
+    overlay_explicit_ids_impl(value, explicit_ids, true);
+}
+
+/// Apply explicit identities and only the payload-proven reference bindings.
+/// Authored UUID-shaped `@ref` spellings without such evidence stay names.
+/// Supply the current endpoint values from `ResolvedModel::payload_id_reference_values`
+/// after binding each rebuilt model; spelling hints are not endpoint values.
+pub fn overlay_payload_ids(
+    value: &mut Value,
+    explicit_ids: &ExplicitIds,
+    bindings: &IdReferenceBindings,
+) {
+    overlay_explicit_ids_impl(value, explicit_ids, false);
+    let Some(elements) = value.as_array_mut() else {
+        return;
+    };
+    for element in elements {
+        let Some(owner) = element
+            .get("@id")
+            .and_then(Value::as_str)
+            .and_then(|s| Uuid::parse_str(s).ok())
+        else {
+            continue;
+        };
+        let ty = element["@type"]
+            .as_str()
+            .and_then(crate::metaclass_name)
+            .unwrap_or("");
+        let Some(properties) = element.as_object_mut() else {
+            continue;
+        };
+        for (key, property) in properties.iter_mut() {
+            if crate::model::is_payload_usage_flag(ty, key) {
+                continue;
+            }
+            let apply = |slot: String, value: &mut Value| {
+                if let Some(target) = bindings.get(&(owner, slot)) {
+                    // The retained hint already proves that this exact slot
+                    // was spelled as its UUID in the rebuilt source. Repeated
+                    // lowering can otherwise resolve a lexical UUID namesake.
+                    if value.get("@ref").is_some() || value.get("@id").is_some() {
+                        *value = serde_json::json!({"@id": target.to_string()});
+                    }
+                }
+            };
+            if let Some(items) = property.as_array_mut() {
+                for (index, item) in items.iter_mut().enumerate() {
+                    apply(format!("{key}#{index}"), item);
+                }
+            } else {
+                apply(key.clone(), property);
+            }
+        }
+    }
+}
+
+fn overlay_explicit_ids_impl(value: &mut Value, explicit_ids: &ExplicitIds, bind_unproven: bool) {
     let text_map: HashMap<String, String> = explicit_ids
         .iter()
         .map(|(d, (g, _))| (d.to_string(), g.to_string()))
@@ -224,7 +446,15 @@ pub fn overlay_explicit_ids(value: &mut Value, explicit_ids: &ExplicitIds) {
     fn remap(v: &mut Value, map: &HashMap<String, String>) {
         match v {
             Value::Object(o) => {
+                let ty = o
+                    .get("@type")
+                    .and_then(Value::as_str)
+                    .and_then(crate::metaclass_name)
+                    .unwrap_or("");
                 for (k, x) in o.iter_mut() {
+                    if crate::model::is_payload_usage_flag(ty, k) {
+                        continue;
+                    }
                     if (k == "@id"
                         || k == "elementId"
                         || k == "memberElementId"
@@ -258,13 +488,115 @@ pub fn overlay_explicit_ids(value: &mut Value, explicit_ids: &ExplicitIds) {
                     o.insert("@id".into(), Value::String(id));
                     return;
                 }
-                o.values_mut().for_each(bind);
+                let ty = o
+                    .get("@type")
+                    .and_then(Value::as_str)
+                    .and_then(crate::metaclass_name)
+                    .unwrap_or("");
+                for (key, value) in o.iter_mut() {
+                    if !crate::model::is_payload_usage_flag(ty, key) {
+                        bind(value);
+                    }
+                }
             }
             Value::Array(a) => a.iter_mut().for_each(bind),
             _ => {}
         }
     }
-    bind(value);
+    if bind_unproven {
+        bind(value);
+    }
+}
+
+/// Retain only independently paired owned Boolean fields. UUID equality alone
+/// is not a pairing proof, and ambiguous source or payload identities refuse.
+fn retain_payload_usage_flags(
+    model: &mut Model,
+    resolved: &ResolvedModel,
+    document: &Value,
+    pairs: &ExplicitIds,
+    warnings: &mut Vec<String>,
+) -> usize {
+    let mut source_ids = HashMap::new();
+    let mut anchors = HashMap::new();
+    for e in resolved.user_elements() {
+        source_ids
+            .entry(resolved.element_id(e))
+            .and_modify(|v| *v = None)
+            .or_insert(Some(e));
+        if let Some((unit, path)) = resolved.payload_owned_flag_anchor(e) {
+            *anchors.entry((unit, path)).or_insert(0usize) += 1;
+        }
+    }
+    let mut input_ids = HashMap::new();
+    for row in document.as_array().into_iter().flatten() {
+        if let Some(id) = row
+            .get("@id")
+            .and_then(Value::as_str)
+            .and_then(|id| Uuid::parse_str(id).ok())
+        {
+            input_ids
+                .entry(id)
+                .and_modify(|v| *v = None)
+                .or_insert(Some(row));
+        }
+    }
+    let mut restored = 0;
+    let mut declined = 0;
+    for (derived, (given, ty)) in pairs {
+        if !crate::metaclass::conforms(ty, "Usage") {
+            continue;
+        }
+        let Some(row) = input_ids.get(given).copied().flatten() else {
+            declined += 1;
+            continue;
+        };
+        let mut flags = crate::properties::Properties::new();
+        let mut present = false;
+        for &key in crate::model::PAYLOAD_USAGE_FLAGS {
+            let Some((_, Some(spec))) = crate::semantic_catalog::property(ty, key) else {
+                continue;
+            };
+            if spec.derived || spec.target != "Boolean" {
+                continue;
+            }
+            for &name in spec.storage_names {
+                if let Some(value) = row.get(name) {
+                    flags.insert_payload_flag(name, value.clone());
+                    present = true;
+                }
+            }
+        }
+        if !present {
+            continue;
+        }
+        let Some(element) = source_ids.get(derived).copied().flatten() else {
+            declined += 1;
+            continue;
+        };
+        let Some(anchor) = resolved.payload_owned_flag_anchor(element) else {
+            declined += 1;
+            continue;
+        };
+        if resolved.element_type(element) != *ty || anchors.get(&anchor) != Some(&1) {
+            declined += 1;
+            continue;
+        }
+        let (unit, path) = anchor;
+        model.retain_payload_flags(
+            unit,
+            path,
+            crate::model::PayloadOwnedFlags {
+                metaclass: ty,
+                flags,
+            },
+        );
+        restored += 1;
+    }
+    if declined != 0 {
+        warnings.push(format!("{declined} Usage payload row(s) could not preserve owned flags because their structural pairing is ambiguous"));
+    }
+    restored
 }
 
 /// Load a compact (or full) interchange document into a fresh model
@@ -273,15 +605,36 @@ pub fn overlay_explicit_ids(value: &mut Value, explicit_ids: &ExplicitIds) {
 /// produces), the text is rebuilt, and the document's ids are kept as
 /// explicit ids. Returns the model, its resolved form with the overlay
 /// applied, the overlay, and the lift's non-fatal problems.
+/// This compatibility entry point rebuilds legacy graphs and reports unpaired
+/// rows as warnings. Use [`load_document_with_format`] to enforce a graph contract.
 pub fn load_document(
     document: &Value,
     names: &HashMap<String, Vec<String>>,
+) -> Result<(Model, ResolvedModel, ExplicitIds, Vec<String>), String> {
+    load_document_impl(document, names, crate::model::GraphFormat::LegacyV2)
+}
+
+/// Load a document under its explicitly selected authored graph contract.
+/// Use the migration API before loading legacy conditional graphs as canonical.
+pub fn load_document_with_format(
+    document: &Value,
+    names: &HashMap<String, Vec<String>>,
+    format: crate::model::GraphFormat,
+) -> Result<(Model, ResolvedModel, ExplicitIds, Vec<String>), String> {
+    crate::migration::validate_conditional_graph_format(document, format)?;
+    load_document_impl(document, names, format)
+}
+
+fn load_document_impl(
+    document: &Value,
+    names: &HashMap<String, Vec<String>>,
+    format: crate::model::GraphFormat,
 ) -> Result<(Model, ResolvedModel, ExplicitIds, Vec<String>), String> {
     let mut names = names.clone();
     names.extend(crate::lift::document_reference_name_map(document));
     let docs =
         crate::lift::split_documents(document).unwrap_or_else(|| vec![(None, document.clone())]);
-    let mut model = Model::new();
+    let mut model = Model::with_graph_format(format);
     let mut warnings = Vec::new();
     for (i, (_, doc)) in docs.iter().enumerate() {
         let lifted = crate::lift::from_compact_json_with_names(doc, &names)?;
@@ -291,7 +644,7 @@ pub fn load_document(
             _ => "sysml",
         };
         let text = sysmlv2_syntax::print::print_source(&lifted.unit);
-        let unit = model.add_source(format!("document-{}.{ext}", i + 1), &text);
+        let unit = model.add_payload_source(format!("document-{}.{ext}", i + 1), &text);
         if let Some(d) = unit
             .diagnostics
             .iter()
@@ -302,7 +655,33 @@ pub fn load_document(
     }
     let mut resolved = ResolvedModel::build(&model);
     let external = |s: &str| names.get(s).and_then(|segs| segs.last().cloned());
-    let (mut explicit_ids, unmatched) = explicit_id_map(document, &model, &external, &mut warnings);
+    let mut pairing_warnings = Vec::new();
+    let (pairs, mut unmatched) = paired_id_map(
+        document,
+        &resolved.source_compact_json(),
+        &external,
+        &mut pairing_warnings,
+    );
+    let restored =
+        retain_payload_usage_flags(&mut model, &resolved, document, &pairs, &mut warnings);
+    let mut explicit_ids = if restored != 0 {
+        // Restore raw owned input before resolution; all future Model builds
+        // follow this same path. No already-published inferred bit is patched.
+        resolved = ResolvedModel::build(&model);
+        pairing_warnings.clear();
+        let (pairs, missing) = paired_id_map(
+            document,
+            &resolved.source_compact_json(),
+            &external,
+            &mut pairing_warnings,
+        );
+        unmatched = missing;
+        pairs
+    } else {
+        pairs
+    };
+    warnings.extend(pairing_warnings);
+    explicit_ids.retain(|derived, (given, _)| derived != given);
     if unmatched > 0 {
         warnings.push(format!(
             "{unmatched} element(s) of the document have no structural counterpart in the \
@@ -312,6 +691,359 @@ pub fn load_document(
     let map: HashMap<Uuid, Uuid> = explicit_ids.iter().map(|(d, (g, _))| (*d, *g)).collect();
     let applied = resolved.override_ids(&map);
     explicit_ids.retain(|d, _| applied.iter().any(|(a, _, _)| a == d));
-    resolved.bind_id_spelled_references();
+    if warnings
+        .iter()
+        .any(|w| w.contains("cannot name reference target"))
+    {
+        resolved.bind_id_spelled_references_with(&mut id_reference_bindings(document));
+    } else {
+        resolved.bind_id_spelled_references_with(&mut HashMap::new());
+    }
     Ok((model, resolved, explicit_ids, warnings))
 }
+
+#[cfg(test)]
+mod pairing_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn omitted_naming_edges_do_not_change_authored_pairing_or_root_order() {
+        let mut model = Model::with_graph_format(crate::model::GraphFormat::CanonicalV3);
+        let unit = model.add_source(
+            "pairing.kerml",
+            "class C { feature base; } class D specializes C { feature redefines base; } feature value = 1/0;",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let emitted = model_to_compact_json(&model);
+        let elements = emitted.as_array().unwrap();
+        let positions: HashMap<_, _> = elements
+            .iter()
+            .enumerate()
+            .map(|(i, row)| (row["@id"].as_str().unwrap(), i))
+            .collect();
+        let operator = elements
+            .iter()
+            .find(|row| row["@type"] == "OperatorExpression")
+            .unwrap();
+        let membership =
+            &elements[positions[operator["ownedRelationship"][0]["@id"].as_str().unwrap()]];
+        let argument = positions[membership["ownedRelatedElement"][0]["@id"]
+            .as_str()
+            .unwrap()];
+        let expected: ExplicitIds = elements
+            .iter()
+            .enumerate()
+            .map(|(i, row)| {
+                (
+                    Uuid::parse_str(row["@id"].as_str().unwrap()).unwrap(),
+                    (
+                        Uuid::from_u128(1000 + i as u128),
+                        crate::metaclass_name(row["@type"].as_str().unwrap()).unwrap(),
+                    ),
+                )
+            })
+            .collect();
+        let mut document = emitted.clone();
+        overlay_explicit_ids(&mut document, &expected);
+        let argument_id = document[argument]["@id"].clone();
+        let generated = Uuid::from_u128(900);
+        let external = Uuid::from_u128(901);
+        document[argument]["ownedRelationship"]
+            .as_array_mut()
+            .unwrap()
+            .insert(0, json!({"@id": generated}));
+        let elements = document.as_array_mut().unwrap();
+        elements.push(json!({
+            "@id": generated, "@type": "Redefinition", "isImplied": true,
+            "owningRelatedElement": {"@id": argument_id},
+            "redefinedFeature": {"@id": external}
+        }));
+        elements.insert(
+            0,
+            json!({
+                "@id": Uuid::from_u128(902), "@type": "Namespace", "isImplied": true,
+                "ownedRelationship": []
+            }),
+        );
+        let name = |id: &str| (id == external.to_string()).then(|| "input".to_owned());
+        let authored_paths = crate::ids::segment_paths(&emitted, &name).unwrap();
+        assert!(
+            authored_paths
+                .iter()
+                .flatten()
+                .any(|(_, path)| path == "::D/::base")
+        );
+        let mut warnings = Vec::new();
+        let (actual, unmatched) = paired_id_map(&document, &emitted, &name, &mut warnings);
+        assert!(warnings.is_empty(), "{warnings:?}");
+        assert_eq!(unmatched, 0);
+        assert_eq!(actual, expected);
+    }
+}
+
+#[cfg(test)]
+mod payload_flag_tests {
+    use super::*;
+    use serde_json::json;
+
+    fn source() -> Model {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("document-1.sysml", "part def P { end part p; }")
+                .diagnostics
+                .is_empty()
+        );
+        model
+    }
+    fn named(resolved: &ResolvedModel) -> crate::json::ElementRef {
+        resolved
+            .user_elements()
+            .find(|&e| {
+                resolved
+                    .element_properties(e)
+                    .get("declaredName")
+                    .and_then(Value::as_str)
+                    == Some("p")
+            })
+            .unwrap()
+    }
+    fn values() -> Vec<Value> {
+        vec![
+            json!(true),
+            json!(false),
+            Value::Null,
+            json!("malformed"),
+            json!(17),
+            json!([false,{"@id":"00000000-0000-0000-0000-000000000001"}]),
+            json!({"@ref":"'00000000-0000-0000-0000-000000000001'"}),
+        ]
+    }
+    #[test]
+    fn full_and_compact_owned_flags_survive_loader_rebuild_and_identity_overlays() {
+        for full in [false, true] {
+            for &key in crate::model::PAYLOAD_USAGE_FLAGS {
+                for value in values() {
+                    let original = if key == "isPortion" {
+                        let mut m = Model::new();
+                        assert!(
+                            m.add_source("document-1.sysml", "part def P { part p; }")
+                                .diagnostics
+                                .is_empty()
+                        );
+                        m
+                    } else {
+                        source()
+                    };
+                    let mut doc = if full {
+                        crate::full::model_to_full_json(&original)
+                    } else {
+                        model_to_compact_json(&original)
+                    };
+                    let row = doc
+                        .as_array_mut()
+                        .unwrap()
+                        .iter_mut()
+                        .find(|e| e["declaredName"] == "p")
+                        .unwrap();
+                    row[key] = value.clone();
+                    let original_id = Uuid::parse_str(row["@id"].as_str().unwrap()).unwrap();
+                    let (model, resolved, ids, warnings) = load_document(&doc, &HashMap::new())
+                        .unwrap_or_else(|e| panic!("{full} {key} {value}: {e}"));
+                    assert!(
+                        warnings
+                            .iter()
+                            .all(|w| w.contains("no structural counterpart")),
+                        "{full} {key} {value}: {warnings:?}"
+                    );
+                    let e = named(&resolved);
+                    assert_eq!(resolved.element_id(e), original_id);
+                    assert_eq!(
+                        resolved.element_properties(e).get(key),
+                        Some(&value),
+                        "{full} {key}"
+                    );
+                    let mut rebuilt = ResolvedModel::build(&model);
+                    let e = named(&rebuilt);
+                    assert_eq!(rebuilt.element_properties(e).get(key), Some(&value));
+                    let before = rebuilt.element_id(e);
+                    rebuilt.override_ids(&HashMap::from([(before, Uuid::from_u128(93))]));
+                    rebuilt.bind_id_spelled_references();
+                    assert_eq!(rebuilt.element_properties(e).get(key), Some(&value));
+                    let mut emitted = model_to_compact_json(&model);
+                    overlay_explicit_ids(&mut emitted, &ids);
+                    assert_eq!(
+                        emitted
+                            .as_array()
+                            .unwrap()
+                            .iter()
+                            .find(|e| e["declaredName"] == "p")
+                            .unwrap()
+                            .get(key),
+                        Some(&value)
+                    );
+                }
+            }
+        }
+    }
+    #[test]
+    fn malformed_boolean_reference_shapes_are_literal_across_all_overlay_paths() {
+        let old = Uuid::from_u128(1);
+        let new = Uuid::from_u128(2);
+        let mut p = crate::properties::Properties::new();
+        let value = json!({"@id":old,"nested":[{"@ref":format!("'{old}'")}]});
+        p.insert_payload_flag("isConstant", value.clone());
+        p.insert("target", json!({"@id":old}));
+        for atom in p.values_mut() {
+            atom.remap(&HashMap::from([(old, new)]));
+        }
+        let restored: crate::properties::Properties =
+            crate::cache_codec::decode(&crate::cache_codec::encode(&p).unwrap()).unwrap();
+        assert_eq!(restored.get("isConstant").unwrap().to_json(), value);
+        assert_eq!(
+            restored.get("target").unwrap().to_json(),
+            json!({"@id":new})
+        );
+        for flag in [
+            json!({"@id":old}),
+            json!({"@ref":format!("'{old}'")}),
+            value,
+        ] {
+            let doc =
+                json!([{"@id":old,"@type":"PartUsage","isConstant":flag,"target":{"@id":old}}]);
+            let hints = id_reference_bindings(&doc);
+            assert!(!hints.contains_key(&(old, "isConstant".into())));
+            assert_eq!(hints.get(&(old, "target".into())), Some(&old));
+            let ids = HashMap::from([(old, (new, "PartUsage"))]);
+            let mut legacy = doc.clone();
+            overlay_explicit_ids(&mut legacy, &ids);
+            assert_eq!(legacy[0]["isConstant"], flag);
+            assert_eq!(legacy[0]["target"], json!({"@id":new}));
+            let mut strict = doc;
+            overlay_payload_ids(
+                &mut strict,
+                &ids,
+                &HashMap::from([((new, "isConstant".into()), new)]),
+            );
+            assert_eq!(strict[0]["isConstant"], flag);
+        }
+    }
+    #[test]
+    fn identity_equal_pairing_retains_flags_without_inventing_an_overlay() {
+        let mut doc = model_to_compact_json(&source());
+        doc.as_array_mut()
+            .unwrap()
+            .iter_mut()
+            .find(|e| e["declaredName"] == "p")
+            .unwrap()["isConstant"] = Value::Null;
+        let (mut model, resolved, ids, warnings) = load_document(&doc, &HashMap::new()).unwrap();
+        assert!(warnings.is_empty());
+        assert!(ids.is_empty());
+        assert_eq!(
+            resolved.element_properties(named(&resolved))["isConstant"],
+            Value::Null
+        );
+        // Adding a library later changes build ordering, not original unit ordinals.
+        model.add_library_source("late.kerml", "package Library { class T; }");
+        let reordered = ResolvedModel::build(&model);
+        assert_eq!(
+            reordered.element_properties(named(&reordered))["isConstant"],
+            Value::Null
+        );
+        model.add_source("ordinary.sysml", "part def Q { end part p; }");
+        assert!(model.payload_source_flags(1).is_none());
+        assert!(model.payload_source_flags(2).is_none());
+        let rebuilt = ResolvedModel::build(&model);
+        let p: Vec<_> = rebuilt
+            .user_elements()
+            .filter(|&e| {
+                rebuilt
+                    .element_properties(e)
+                    .get("declaredName")
+                    .and_then(Value::as_str)
+                    == Some("p")
+            })
+            .collect();
+        assert_eq!(p.len(), 2);
+        assert_eq!(rebuilt.element_properties(p[0])["isConstant"], Value::Null);
+        assert_eq!(rebuilt.element_properties(p[1])["isConstant"], json!(false));
+    }
+    #[test]
+    fn duplicate_payload_identity_cannot_choose_owned_flags() {
+        let mut doc = model_to_compact_json(&source());
+        let mut row = doc
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|e| e["declaredName"] == "p")
+            .unwrap()
+            .clone();
+        row["isConstant"] = json!("ambiguous");
+        doc.as_array_mut().unwrap().push(row);
+        let (model, _, _, _) = load_document(&doc, &HashMap::new()).unwrap();
+        assert!(model.payload_source_flags(0).unwrap().is_empty());
+    }
+    #[test]
+    fn payload_flags_are_reapplied_before_fresh_recorded_prepared_and_decoded_builds() {
+        let mut library = Model::new();
+        library.add_library_source(
+            "lib.kerml",
+            "package Base { classifier Anything; feature things : Anything; }",
+        );
+        let prepared =
+            std::sync::Arc::new(crate::prepared::PreparedLibrary::build(&library).unwrap());
+        let decoded = std::sync::Arc::new(
+            crate::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(7).unwrap(), 7)
+                .unwrap(),
+        );
+        let value = json!({"@id":"00000000-0000-0000-0000-000000000001"});
+        for mode in 0..4 {
+            let mut model = Model::new();
+            if mode < 2 {
+                model.add_library_source(
+                    "lib.kerml",
+                    "package Base { classifier Anything; feature things : Anything; }",
+                );
+            } else {
+                model
+                    .install_prepared(if mode == 2 {
+                        prepared.clone()
+                    } else {
+                        decoded.clone()
+                    })
+                    .unwrap();
+            }
+            let unit = model.unit_count();
+            model.add_payload_source("payload.sysml", "part def P { end part p; }");
+            let resolved = ResolvedModel::build(&model);
+            let e = named(&resolved);
+            let (_, path) = resolved.payload_owned_flag_anchor(e).unwrap();
+            let mut flags = crate::properties::Properties::new();
+            flags.insert_payload_flag("isConstant", value.clone());
+            model.retain_payload_flags(
+                unit,
+                path,
+                crate::model::PayloadOwnedFlags {
+                    metaclass: "PartUsage",
+                    flags,
+                },
+            );
+            if mode == 1 {
+                model.record_library_cache();
+            }
+            let restored = ResolvedModel::build(&model);
+            assert_eq!(
+                restored.element_properties(named(&restored))["isConstant"],
+                value
+            );
+            if mode == 1 {
+                let cache = model.take_recorded_library_cache().unwrap();
+                model.set_library_cache(cache);
+            }
+            let again = ResolvedModel::build(&model);
+            assert_eq!(again.element_properties(named(&again))["isConstant"], value);
+            assert!(again.payload_owned_flag_anchor(named(&again)).is_some());
+        }
+    }
+}
diff --git a/crates/sysmlv2-model/src/metamodel.rs b/crates/sysmlv2-model/src/metamodel.rs
new file mode 100644
index 0000000..88d991d
--- /dev/null
+++ b/crates/sysmlv2-model/src/metamodel.rs
@@ -0,0 +1,139 @@
+//! Normative declaration metadata for SDK generation. Declaration availability
+//! does not imply executable semantic support or whole-model conformance.
+
+pub use crate::operation_catalog::{OperationSpec, ParameterSpec};
+pub use crate::semantic_catalog::PropertySpec;
+
+/// A property name on a concrete or abstract metaclass and its redefinition.
+#[derive(Debug)]
+pub struct PropertyDescriptor {
+    /// The declaration determining the shape of the requested name.
+    pub requested: &'static PropertySpec,
+    /// The most specific redefinition. `None` means incomparable redefinitions;
+    /// callers must not arbitrarily select a branch of multiple inheritance.
+    pub effective: Option<&'static PropertySpec>,
+}
+
+/// Resolve a specification property name, including inherited spellings.
+pub fn property(metaclass: &str, name: &str) -> Option<PropertyDescriptor> {
+    crate::semantic_catalog::property(metaclass, name).map(|(requested, effective)| {
+        PropertyDescriptor {
+            requested,
+            effective,
+        }
+    })
+}
+
+/// All visible property names, in lexical order; unknown metaclasses yield none.
+pub fn properties(metaclass: &str) -> impl Iterator<Item = PropertyDescriptor> {
+    crate::semantic_catalog::properties(metaclass)
+        .unwrap_or(&[])
+        .iter()
+        .map(|&(requested, effective)| PropertyDescriptor {
+            requested: &crate::semantic_catalog::PROPERTIES[requested as usize],
+            effective: crate::semantic_catalog::PROPERTIES.get(effective as usize),
+        })
+}
+
+/// All declared operations in normative identity order. Overrides remain
+/// separate declarations with explicit redefinition links. This is an inventory,
+/// not an execution dispatcher; parameter metadata is preserved without guessing
+/// missing result declarations or directions in the source XMI.
+pub fn operations() -> &'static [OperationSpec] {
+    crate::operation_catalog::OPERATIONS
+}
+
+/// Find one operation by normative declaration identity (not its ambiguous name).
+pub fn operation(id: &str) -> Option<&'static OperationSpec> {
+    operations()
+        .binary_search_by_key(&id, |op| op.id)
+        .ok()
+        .map(|i| &operations()[i])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn property_metadata_preserves_identity_shape_and_ambiguity() {
+        let usage = property("PartUsage", "isVariable").unwrap();
+        assert_eq!(usage.requested.declaring_metaclass, "Feature");
+        assert_eq!(usage.effective.unwrap().name, "mayTimeVary");
+        assert!(usage.effective.unwrap().derived);
+        let source = property("FeatureTyping", "source").unwrap();
+        assert_eq!(source.requested.upper, None);
+        assert!(source.requested.ordered);
+        assert!(
+            !property("Element", "owningRelationship")
+                .unwrap()
+                .requested
+                .ordered
+        );
+        assert!(
+            property("Namespace", "ownedMember")
+                .unwrap()
+                .requested
+                .ordered
+        );
+        assert_eq!(source.effective.unwrap().upper, Some(1));
+        assert!(
+            property("BindingConnectorAsUsage", "type")
+                .unwrap()
+                .effective
+                .is_none()
+        );
+        assert!(property("Missing", "type").is_none());
+        assert_eq!(properties("Missing").count(), 0);
+    }
+
+    #[test]
+    fn every_visible_property_resolves_by_its_declared_name() {
+        use crate::semantic_catalog::{CLASSES, PROPERTIES};
+        for &(metaclass, rows) in CLASSES {
+            let names: Vec<_> = rows
+                .iter()
+                .map(|&(requested, _)| PROPERTIES[requested as usize].name)
+                .collect();
+            assert!(names.windows(2).all(|w| w[0] < w[1]), "{metaclass}");
+            for (descriptor, name) in properties(metaclass).zip(names) {
+                let found = property(metaclass, name).unwrap();
+                assert!(std::ptr::eq(found.requested, descriptor.requested));
+                assert_eq!(
+                    found.effective.map(|e| e as *const _),
+                    descriptor.effective.map(|e| e as *const _),
+                    "{metaclass}.{name}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn operation_inventory_preserves_declarations_without_inventing_signatures() {
+        let ops = operations();
+        assert_eq!(ops.len(), 103);
+        let names: std::collections::HashSet<_> = ops.iter().map(|op| op.name).collect();
+        assert_eq!(names.len(), 69);
+        for op in ops {
+            assert!(std::ptr::eq(operation(op.id).unwrap(), op));
+            for id in op.redefines {
+                assert!(operation(id).is_some(), "{id}");
+            }
+        }
+        let name = ops
+            .iter()
+            .find(|o| o.declaring_metaclass == "Element" && o.name == "effectiveName")
+            .unwrap();
+        assert_eq!(name.parameters.len(), 1);
+        assert_eq!(name.parameters[0].name, "");
+        assert_eq!(name.parameters[0].direction, None);
+        assert_eq!(name.parameters[0].target, "String");
+        let compatible = ops
+            .iter()
+            .find(|o| o.declaring_metaclass == "Type" && o.name == "isCompatibleWith")
+            .unwrap();
+        assert_eq!(compatible.parameters.len(), 1);
+        assert_eq!(compatible.parameters[0].name, "otherType");
+        assert!(operation("effectiveName").is_none());
+    }
+}
diff --git a/crates/sysmlv2-model/src/migration.rs b/crates/sysmlv2-model/src/migration.rs
new file mode 100644
index 0000000..dc44f7d
--- /dev/null
+++ b/crates/sysmlv2-model/src/migration.rs
@@ -0,0 +1,1819 @@
+//! Explicit migration of authored compact graphs. Input is never mutated.
+use crate::model::GraphFormat;
+use serde_json::{Value, json};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use uuid::Uuid;
+
+/// A complete migration result. Apply `ids` simultaneously to references held
+/// outside this document; a new wrapper can occupy a former operand UUID.
+#[derive(Debug)]
+pub struct GraphMigration {
+    pub source: GraphFormat,
+    pub target: GraphFormat,
+    pub document: Value,
+    /// Every original identity, including unchanged identities.
+    pub ids: BTreeMap<Uuid, Uuid>,
+    pub added: Vec<Uuid>,
+    /// Original row index → migrated row index, including document roots.
+    pub element_indices: Vec<usize>,
+}
+
+fn id(value: &Value) -> Result<Uuid, String> {
+    value
+        .get("@id")
+        .and_then(Value::as_str)
+        .and_then(|s| Uuid::parse_str(s).ok())
+        .ok_or_else(|| "expected a UUID reference".to_owned())
+}
+fn refs(row: &Value, key: &str) -> Result<Vec<Uuid>, String> {
+    match row.get(key) {
+        None => Ok(Vec::new()),
+        Some(Value::Array(a)) => a.iter().map(id).collect(),
+        _ => Err(format!("{key} must be a reference array")),
+    }
+}
+fn one(row: &Value, key: &str) -> Result<Uuid, String> {
+    let ids = refs(row, key)?;
+    if ids.len() != 1 {
+        return Err(format!("expected exactly one {key}"));
+    }
+    Ok(ids[0])
+}
+fn charge(steps: &mut usize, n: usize) -> Result<(), String> {
+    *steps = steps.saturating_add(n);
+    if *steps > crate::eval::MAX_STEPS {
+        Err("graph migration work limit".into())
+    } else {
+        Ok(())
+    }
+}
+
+/// Check the authored ownership forest before deriving or changing identities.
+fn index(rows: &[Value], steps: &mut usize) -> Result<HashMap<Uuid, usize>, String> {
+    charge(steps, rows.len())?;
+    let mut by_id = HashMap::new();
+    for (i, row) in rows.iter().enumerate() {
+        if by_id.insert(id(row)?, i).is_some() {
+            return Err("duplicate element identity".into());
+        }
+        let ty = row
+            .get("@type")
+            .and_then(Value::as_str)
+            .ok_or("missing metaclass")?;
+        if crate::metaclass_name(ty).is_none() {
+            return Err("unknown metaclass".into());
+        }
+        for key in row.as_object().ok_or("element must be an object")?.keys() {
+            charge(steps, 1)?;
+            if !matches!(
+                key.as_str(),
+                "@id"
+                    | "@type"
+                    | "elementId"
+                    | "isImpliedIncluded"
+                    | "owningRelationship"
+                    | "owningRelatedElement"
+                    | "ownedRelationship"
+                    | "ownedRelatedElement"
+            ) && !crate::json::is_owned_property(ty, key)
+            {
+                return Err(format!(
+                    "migration requires compact owned properties: {ty}.{key}"
+                ));
+            }
+        }
+        if row.get("isImplied").is_some_and(|v| v != false) {
+            return Err("migration requires authored compact rows".into());
+        }
+        if row
+            .get("elementId")
+            .is_some_and(|v| v.as_str() != row["@id"].as_str())
+        {
+            return Err("elementId contradicts @id".into());
+        }
+    }
+    let mut parents = vec![None; rows.len()];
+    let mut children = vec![Vec::new(); rows.len()];
+    for (i, row) in rows.iter().enumerate() {
+        for (forward, inverse) in [
+            ("ownedRelationship", "owningRelatedElement"),
+            ("ownedRelatedElement", "owningRelationship"),
+        ] {
+            let edges = refs(row, forward)?;
+            if forward == "ownedRelatedElement"
+                && !edges.is_empty()
+                && !crate::metaclass::conforms(row["@type"].as_str().unwrap(), "Relationship")
+            {
+                return Err("ownedRelatedElement source is not a Relationship".into());
+            }
+            charge(steps, edges.len())?;
+            for child in edges {
+                let &j = by_id.get(&child).ok_or("external ownership target")?;
+                if parents[j].replace(i).is_some() {
+                    return Err("multiple ownership claims".into());
+                }
+                if rows[j].get(inverse).map(id).transpose()? != Some(id(row)?) {
+                    return Err("nonreciprocal ownership".into());
+                }
+                let other_inverse = if inverse == "owningRelationship" {
+                    "owningRelatedElement"
+                } else {
+                    "owningRelationship"
+                };
+                if rows[j].get(other_inverse).is_some_and(|v| !v.is_null()) {
+                    return Err("contradictory ownership roles".into());
+                }
+                if forward == "ownedRelationship"
+                    && !crate::metaclass::conforms(
+                        rows[j]["@type"].as_str().unwrap(),
+                        "Relationship",
+                    )
+                {
+                    return Err("ownedRelationship target is not a Relationship".into());
+                }
+                children[i].push(j);
+            }
+        }
+    }
+    let mut pending = Vec::new();
+    for (i, row) in rows.iter().enumerate() {
+        for key in ["owningRelationship", "owningRelatedElement"] {
+            if row.get(key).is_some_and(|v| !v.is_null()) {
+                let owner = id(&row[key])?;
+                if parents[i].map(|p| id(&rows[p])).transpose()? != Some(owner) {
+                    return Err("unlisted inverse ownership claim".into());
+                }
+            }
+        }
+        if parents[i].is_none() {
+            if row["@type"] != "Namespace" {
+                return Err("unowned non-root element".into());
+            }
+            pending.push(i);
+        }
+    }
+    let mut seen = HashSet::new();
+    while let Some(i) = pending.pop() {
+        charge(steps, 1)?;
+        if !seen.insert(i) {
+            return Err("ownership cycle".into());
+        }
+        pending.extend(children[i].iter().copied());
+    }
+    if seen.len() != rows.len() {
+        return Err("unreachable ownership cycle".into());
+    }
+    Ok(by_id)
+}
+
+// (FeatureValue, expression) for every grammar-owned conditional operand.
+fn operands(
+    rows: &[Value],
+    by: &HashMap<Uuid, usize>,
+    steps: &mut usize,
+) -> Result<Vec<(usize, usize)>, String> {
+    let mut out = Vec::new();
+    for row in rows {
+        charge(steps, 1)?;
+        if row["@type"] != "OperatorExpression" {
+            continue;
+        }
+        let expected = match row["operator"].as_str() {
+            Some("if") => 3,
+            Some("and" | "or" | "implies" | "??") => 2,
+            _ => continue,
+        };
+        let owned = refs(row, "ownedRelationship")?;
+        charge(steps, owned.len())?;
+        let parameters: Vec<_> = owned
+            .iter()
+            .map(|r| by[r])
+            .filter(|&i| rows[i]["@type"] == "ParameterMembership")
+            .collect();
+        if parameters.len() != expected {
+            return Err("conditional operand cardinality".into());
+        }
+        for membership in parameters.into_iter().skip(1) {
+            let parameter = by[&one(&rows[membership], "ownedRelatedElement")?];
+            if rows[parameter]["@type"] != "Feature" {
+                return Err("conditional operand requires a Feature".into());
+            }
+            let rels = refs(&rows[parameter], "ownedRelationship")?;
+            charge(steps, rels.len())?;
+            let values: Vec<_> = rels
+                .iter()
+                .map(|r| by[r])
+                .filter(|&i| rows[i]["@type"] == "FeatureValue")
+                .collect();
+            if values.len() != 1 {
+                return Err("conditional operand requires one value".into());
+            }
+            let value = values[0];
+            let expression = by[&one(&rows[value], "ownedRelatedElement")?];
+            if !crate::metaclass::conforms(
+                rows[expression]["@type"].as_str().unwrap(),
+                "Expression",
+            ) {
+                return Err("operand value is not an Expression".into());
+            }
+            out.push((value, expression));
+        }
+    }
+    Ok(out)
+}
+fn wrapped(rows: &[Value], by: &HashMap<Uuid, usize>, expression: usize) -> Result<bool, String> {
+    if rows[expression]["@type"] != "FeatureReferenceExpression" {
+        return Ok(false);
+    }
+    let rels = refs(&rows[expression], "ownedRelationship")?;
+    if rels.len() != 1 {
+        return Ok(false);
+    }
+    let member = &rows[by[&rels[0]]];
+    if member["@type"] != "FeatureMembership" {
+        return Ok(false);
+    }
+    let children = refs(member, "ownedRelatedElement")?;
+    Ok(children.len() == 1
+        && crate::metaclass::conforms(
+            rows[by[&children[0]]]["@type"].as_str().unwrap(),
+            "Expression",
+        ))
+}
+
+/// The authored constructor fragment admitted by the canonical contract.
+/// Generated semantic relationships do not participate in authored shape checks.
+struct ConstructorShape {
+    owner: usize,
+    selector: usize,
+    selector_end: usize,
+    parameters: Vec<usize>,
+}
+
+// Constructor syntax has no spelling for flags on its structural wrapper
+// Features and relationships. Admit absent/default values (including full
+// export's materialized defaults), but never silently discard nondefaults.
+fn constructor_syntax_scalars(row: &Value, direction: Option<&str>) -> Result<(), String> {
+    let ty = row["@type"]
+        .as_str()
+        .ok_or("missing constructor metaclass")?;
+    for (key, value) in row.as_object().ok_or("constructor row must be an object")? {
+        if matches!(key.as_str(), "elementId" | "isImpliedIncluded") {
+            continue; // identity and export closure metadata, not syntax flags
+        }
+        // Direct selector names retain the existing interchange behavior:
+        // compatibility full export materializes them from the target's
+        // effective name, which can depend on an external library. The new
+        // result/argument wrapper guard does not certify those legacy names.
+        if ty == "Membership" && matches!(key.as_str(), "memberName" | "memberShortName") {
+            continue;
+        }
+        let Some((_, Some(spec))) = crate::semantic_catalog::property(ty, key) else {
+            continue;
+        };
+        if spec.derived
+            || !(matches!(spec.target, "Boolean" | "String" | "Integer" | "Real")
+                || !spec.enum_values.is_empty())
+        {
+            continue;
+        }
+        let expected = if key == "direction" {
+            direction.map_or(Value::Null, |value| json!(value))
+        } else if let Some(default) = spec.default_json {
+            serde_json::from_str(default).map_err(|_| "invalid scalar schema default")?
+        } else if spec.upper != Some(1) {
+            json!([])
+        } else {
+            Value::Null
+        };
+        if *value != expected {
+            return Err(format!("constructor syntax cannot preserve {ty}.{key}"));
+        }
+    }
+    Ok(())
+}
+
+fn constructor_shapes(
+    rows: &[Value],
+    format: GraphFormat,
+    strict_legacy: bool,
+    steps: &mut usize,
+) -> Result<Vec<ConstructorShape>, String> {
+    let mut by = HashMap::new();
+    let mut inverse: HashMap<(&str, &str), Vec<usize>> = HashMap::new();
+    for (i, row) in rows.iter().enumerate() {
+        charge(steps, 1 + row.as_object().map_or(0, |object| object.len()))?;
+        if let Some(id) = row["@id"].as_str() {
+            by.entry(id).and_modify(|v| *v = None).or_insert(Some(i));
+        }
+        if row["isImplied"] != true {
+            for key in ["owningRelatedElement", "owningRelationship"] {
+                if let Some(owner) = row[key]["@id"].as_str() {
+                    inverse.entry((key, owner)).or_default().push(i);
+                }
+            }
+        }
+    }
+    let lookup = |reference: &Value| -> Result<usize, String> {
+        reference["@id"]
+            .as_str()
+            .and_then(|id| by.get(id).copied().flatten())
+            .ok_or_else(|| "missing or ambiguous constructor ownership target".into())
+    };
+    let children = |owner: usize, key: &str| -> Result<Vec<usize>, String> {
+        let inverse_key = if key == "ownedRelationship" {
+            "owningRelatedElement"
+        } else {
+            "owningRelationship"
+        };
+        let other_inverse = if key == "ownedRelationship" {
+            "owningRelationship"
+        } else {
+            "owningRelatedElement"
+        };
+        let mut children = Vec::new();
+        let mut seen = HashSet::new();
+        if let Some(values) = rows[owner].get(key) {
+            for reference in values
+                .as_array()
+                .ok_or("constructor ownership must be an array")?
+            {
+                let child = lookup(reference)?;
+                if rows[child]["isImplied"] == true {
+                    continue;
+                }
+                if !seen.insert(child)
+                    || rows[child][inverse_key]["@id"] != rows[owner]["@id"]
+                    || rows[child].get(other_inverse).is_some_and(|v| !v.is_null())
+                {
+                    return Err("nonreciprocal or duplicate constructor ownership".into());
+                }
+                children.push(child);
+            }
+        }
+        if let Some(claims) = rows[owner]["@id"]
+            .as_str()
+            .and_then(|id| inverse.get(&(inverse_key, id)))
+        {
+            if claims.len() != children.len() || claims.iter().any(|i| !seen.contains(i)) {
+                return Err("unlisted inverse constructor ownership claim".into());
+            }
+        }
+        Ok(children)
+    };
+    let member = |membership: usize| -> Result<usize, String> {
+        let owned = children(membership, "ownedRelatedElement")?;
+        if owned.len() != 1 {
+            return Err("constructor membership must own exactly one element".into());
+        }
+        constructor_syntax_scalars(&rows[membership], None)?;
+        let ty = rows[membership]["@type"]
+            .as_str()
+            .ok_or("missing membership metaclass")?;
+        for key in [
+            "memberElement",
+            "ownedMemberElement",
+            "ownedMemberFeature",
+            "ownedMemberParameter",
+            "value",
+            "target",
+        ] {
+            if crate::semantic_catalog::property(ty, key).is_none() {
+                continue;
+            }
+            if let Some(alias) = rows[membership].get(key).filter(|v| !v.is_null()) {
+                let target = if key == "target" {
+                    let aliases = alias
+                        .as_array()
+                        .ok_or("constructor target alias must be an array")?;
+                    if aliases.len() != 1 {
+                        return Err("constructor target alias cardinality".into());
+                    }
+                    &aliases[0]
+                } else {
+                    alias
+                };
+                if lookup(target)? != owned[0] {
+                    return Err("constructor membership alias contradicts ownership".into());
+                }
+            }
+        }
+        for key in [
+            "membershipOwningNamespace",
+            "owningType",
+            "featureWithValue",
+            "source",
+        ] {
+            if crate::semantic_catalog::property(ty, key).is_none() {
+                continue;
+            }
+            if let Some(alias) = rows[membership].get(key).filter(|v| !v.is_null()) {
+                let source = if key == "source" {
+                    let aliases = alias
+                        .as_array()
+                        .ok_or("constructor source alias must be an array")?;
+                    if aliases.len() != 1 {
+                        return Err("constructor source alias cardinality".into());
+                    }
+                    &aliases[0]
+                } else {
+                    alias
+                };
+                if lookup(source)? != lookup(&rows[membership]["owningRelatedElement"])? {
+                    return Err("constructor membership owner alias contradicts ownership".into());
+                }
+            }
+        }
+        let owner = lookup(&rows[membership]["owningRelatedElement"])?;
+        let child = owned[0];
+        let child_type = rows[child]["@type"]
+            .as_str()
+            .ok_or("missing member metaclass")?;
+        for key in [
+            "owningMembership",
+            "owningFeatureMembership",
+            "owningParameterMembership",
+            "owner",
+            "owningNamespace",
+            "owningType",
+        ] {
+            if crate::semantic_catalog::property(child_type, key).is_none() {
+                continue;
+            }
+            if let Some(alias) = rows[child].get(key).filter(|v| !v.is_null()) {
+                let requires_feature_membership =
+                    matches!(key, "owningFeatureMembership" | "owningType");
+                let requires_parameter_membership = key == "owningParameterMembership";
+                if (requires_feature_membership
+                    && !crate::metaclass::conforms(ty, "FeatureMembership"))
+                    || (requires_parameter_membership
+                        && !crate::metaclass::conforms(ty, "ParameterMembership"))
+                {
+                    return Err(
+                        "constructor member owner alias has an invalid relationship kind".into(),
+                    );
+                }
+                let expected = if matches!(
+                    key,
+                    "owningMembership" | "owningFeatureMembership" | "owningParameterMembership"
+                ) {
+                    membership
+                } else {
+                    owner
+                };
+                if lookup(alias)? != expected {
+                    return Err("constructor member owner alias contradicts ownership".into());
+                }
+            }
+        }
+        if let Some(alias) = rows[membership]
+            .get("relatedElement")
+            .filter(|v| !v.is_null())
+        {
+            let references = alias
+                .as_array()
+                .ok_or("constructor relatedElement alias must be an array")?;
+            if references.len() != 2
+                || lookup(&references[0])? != owner
+                || lookup(&references[1])? != child
+            {
+                return Err("constructor relatedElement alias contradicts ownership".into());
+            }
+        }
+        for key in ["memberElementId", "ownedMemberElementId"] {
+            if crate::semantic_catalog::property(ty, key).is_some() {
+                if let Some(alias) = rows[membership].get(key).filter(|v| !v.is_null()) {
+                    if alias != &rows[owned[0]]["@id"] {
+                        return Err(
+                            "constructor member identity alias contradicts ownership".into()
+                        );
+                    }
+                }
+            }
+        }
+        Ok(owned[0])
+    };
+    let owned_feature_aliases = |owner: usize, memberships: &[usize]| -> Result<(), String> {
+        let ty = rows[owner]["@type"]
+            .as_str()
+            .ok_or("missing constructor owner metaclass")?;
+        for key in ["ownedFeatureMembership", "ownedFeature"] {
+            if crate::semantic_catalog::property(ty, key).is_none() {
+                continue;
+            }
+            let Some(alias) = rows[owner].get(key) else {
+                continue;
+            };
+            let values = alias
+                .as_array()
+                .ok_or("constructor owned-feature alias must be an array")?;
+            if values.len() != memberships.len() {
+                return Err("constructor owned-feature alias cardinality".into());
+            }
+            for (reference, &membership) in values.iter().zip(memberships) {
+                let expected = if key == "ownedFeature" {
+                    member(membership)?
+                } else {
+                    membership
+                };
+                if lookup(reference)? != expected {
+                    return Err("constructor owned-feature alias contradicts ownership".into());
+                }
+            }
+        }
+        Ok(())
+    };
+    let mut shapes = Vec::new();
+    for (owner, row) in rows.iter().enumerate() {
+        charge(steps, 1)?;
+        if row["@type"] != "ConstructorExpression" || row["isImplied"] == true {
+            continue;
+        }
+        // Keep the historical recovery boundary for legacy imports; recognize
+        // and refuse the canonical result rather than flattening it silently.
+        if format == GraphFormat::LegacyV2 && !strict_legacy {
+            let forward = row["ownedRelationship"]
+                .as_array()
+                .into_iter()
+                .flatten()
+                .filter_map(|r| lookup(r).ok());
+            let inverse_claims = row["@id"]
+                .as_str()
+                .and_then(|id| inverse.get(&("owningRelatedElement", id)))
+                .into_iter()
+                .flatten()
+                .copied();
+            if forward.chain(inverse_claims).any(|i| {
+                rows[i]["@type"] == "ReturnParameterMembership" && rows[i]["isImplied"] != true
+            }) {
+                return Err("canonical constructor result requires CanonicalV3; migrate explicitly before changing formats".into());
+            }
+            continue;
+        }
+        let relationships = children(owner, "ownedRelationship")?;
+        charge(steps, relationships.len())?;
+        let Some(&selector) = relationships.first() else {
+            return Err("constructor requires a type selector".into());
+        };
+        // A dotted instantiated type owns its synthesized feature chain through
+        // an OwningMembership. This is still the selector, not a result Feature.
+        let mut selector_end = selector;
+        match rows[selector]["@type"].as_str() {
+            Some("Membership") if children(selector, "ownedRelatedElement")?.is_empty() => {
+                constructor_syntax_scalars(&rows[selector], None)?;
+            }
+            Some("OwningMembership") => {
+                let chain = member(selector)?;
+                if rows[chain]["@type"] != "Feature" {
+                    return Err("constructor chain selector must own a Feature".into());
+                }
+                constructor_syntax_scalars(&rows[chain], None)?;
+                selector_end = selector_end.max(chain);
+                let links = children(chain, "ownedRelationship")?;
+                charge(steps, links.len())?;
+                if links.len() < 2 {
+                    return Err("constructor chain selector requires at least two links".into());
+                }
+                for link in links {
+                    if rows[link]["@type"] != "FeatureChaining"
+                        || !children(link, "ownedRelatedElement")?.is_empty()
+                        || !children(link, "ownedRelationship")?.is_empty()
+                    {
+                        return Err("unsupported constructor chain selector relationship".into());
+                    }
+                    constructor_syntax_scalars(&rows[link], None)?;
+                    let target = &rows[link]["chainingFeature"];
+                    if target["@id"].as_str().is_none() && target["@ref"].as_str().is_none() {
+                        return Err("constructor chain link requires a target".into());
+                    }
+                    selector_end = selector_end.max(link);
+                }
+            }
+            _ => {
+                return Err(
+                    "constructor requires a type Membership or owned feature-chain selector".into(),
+                );
+            }
+        }
+        let target = &rows[selector]["memberElement"];
+        if target["@ref"].as_str().is_none() && target["@id"].as_str().is_none() {
+            return Err("constructor selector requires a target".into());
+        }
+        // This is an authored transport contract. The selected element may
+        // fail the semantic Type requirement while still being valid syntax;
+        // preserve it so checked semantic consumers can diagnose that failure.
+        if target["@id"]
+            .as_str()
+            .and_then(|id| by.get(id))
+            .is_some_and(Option::is_none)
+        {
+            return Err("ambiguous constructor selector target".into());
+        }
+        let parameters = if format == GraphFormat::CanonicalV3 {
+            if relationships.len() != 2
+                || rows[relationships[1]]["@type"] != "ReturnParameterMembership"
+            {
+                return Err(
+                    "canonical constructor must own exactly one result after its selector".into(),
+                );
+            }
+            let result = member(relationships[1])?;
+            if rows[result]["@type"] != "Feature" || rows[result]["direction"] != "out" {
+                return Err("constructor result must be an out Feature".into());
+            }
+            constructor_syntax_scalars(&rows[result], Some("out"))?;
+            if let Some(alias) = row.get("result").filter(|v| !v.is_null()) {
+                if lookup(alias)? != result {
+                    return Err("constructor result alias contradicts ownership".into());
+                }
+            }
+            let parameters = children(result, "ownedRelationship")?;
+            owned_feature_aliases(owner, &[relationships[1]])?;
+            owned_feature_aliases(result, &parameters)?;
+            parameters
+        } else {
+            relationships[1..].to_vec()
+        };
+        charge(steps, parameters.len())?;
+        for &parameter in &parameters {
+            if rows[parameter]["@type"] != "ParameterMembership" {
+                return Err("constructor arguments require ParameterMembership".into());
+            }
+            let feature = member(parameter)?;
+            if rows[feature]["@type"] != "Feature" || rows[feature]["direction"] != "in" {
+                return Err("constructor argument must be an in Feature".into());
+            }
+            constructor_syntax_scalars(&rows[feature], Some("in"))?;
+            let relationships = children(feature, "ownedRelationship")?;
+            charge(steps, relationships.len())?;
+            let mut value = None;
+            let mut redefinition = false;
+            for relationship in relationships {
+                constructor_syntax_scalars(&rows[relationship], None)?;
+                match rows[relationship]["@type"].as_str() {
+                    Some("FeatureValue") if value.is_none() => value = Some(relationship),
+                    Some("Redefinition") if !redefinition => {
+                        redefinition = true;
+                        for key in [
+                            "redefiningFeature",
+                            "subsettingFeature",
+                            "specific",
+                            "owningFeature",
+                            "owningType",
+                        ] {
+                            if let Some(alias) =
+                                rows[relationship].get(key).filter(|v| !v.is_null())
+                            {
+                                if lookup(alias)? != feature {
+                                    return Err(
+                                        "constructor redefinition source contradicts ownership"
+                                            .into(),
+                                    );
+                                }
+                            }
+                        }
+                        let target = &rows[relationship]["redefinedFeature"];
+                        if target["@id"].as_str().is_none() && target["@ref"].as_str().is_none() {
+                            return Err("constructor redefinition requires a target".into());
+                        }
+                        let same_target = |reference: &Value| {
+                            reference.get("@id") == target.get("@id")
+                                && reference.get("@ref") == target.get("@ref")
+                        };
+                        for key in ["general", "subsettedFeature", "target"] {
+                            if crate::semantic_catalog::property("Redefinition", key).is_none() {
+                                continue;
+                            }
+                            if let Some(alias) =
+                                rows[relationship].get(key).filter(|v| !v.is_null())
+                            {
+                                let reference = if key == "target" {
+                                    let references = alias.as_array().ok_or(
+                                        "constructor redefinition target must be an array",
+                                    )?;
+                                    if references.len() != 1 {
+                                        return Err(
+                                            "constructor redefinition target cardinality".into()
+                                        );
+                                    }
+                                    &references[0]
+                                } else {
+                                    alias
+                                };
+                                if !same_target(reference) {
+                                    return Err("constructor redefinition target alias contradicts redefinedFeature".into());
+                                }
+                            }
+                        }
+                        if let Some(source) =
+                            rows[relationship].get("source").filter(|v| !v.is_null())
+                        {
+                            let references = source
+                                .as_array()
+                                .ok_or("constructor redefinition source must be an array")?;
+                            if references.len() != 1 || lookup(&references[0])? != feature {
+                                return Err(
+                                    "constructor redefinition source contradicts ownership".into(),
+                                );
+                            }
+                        }
+                        if let Some(related) = rows[relationship]
+                            .get("relatedElement")
+                            .filter(|v| !v.is_null())
+                        {
+                            let references = related.as_array().ok_or(
+                                "constructor redefinition relatedElement must be an array",
+                            )?;
+                            if references.len() != 2
+                                || lookup(&references[0])? != feature
+                                || !same_target(&references[1])
+                            {
+                                return Err(
+                                    "constructor redefinition relatedElement contradicts endpoints"
+                                        .into(),
+                                );
+                            }
+                        }
+                    }
+                    _ => {
+                        return Err(
+                            "unsupported or duplicate constructor argument relationship".into()
+                        );
+                    }
+                }
+            }
+            let value = value.ok_or("constructor argument requires one value")?;
+            let expression = member(value)?;
+            if !rows[expression]["@type"]
+                .as_str()
+                .is_some_and(|ty| crate::metaclass::conforms(ty, "Expression"))
+            {
+                return Err("constructor value must own exactly one Expression".into());
+            }
+            if let Some(alias) = rows[value].get("value").filter(|v| !v.is_null()) {
+                if lookup(alias)? != expression {
+                    return Err("constructor value alias contradicts ownership".into());
+                }
+            }
+        }
+        shapes.push(ConstructorShape {
+            owner,
+            selector,
+            selector_end,
+            parameters,
+        });
+    }
+    Ok(shapes)
+}
+
+/// Validate authored compact shapes for an explicit graph contract.
+/// This checks ownership and conditional/constructor fragments, not whole-model conformance.
+pub fn validate_graph_format(document: &Value, format: GraphFormat) -> Result<(), String> {
+    let rows = document
+        .as_array()
+        .ok_or("expected a compact element array")?;
+    let mut steps = 0;
+    let by = index(rows, &mut steps)?;
+    for (_, expression) in operands(rows, &by, &mut steps)? {
+        if wrapped(rows, &by, expression)? != (format == GraphFormat::CanonicalV3) {
+            return Err("conditional operand shape differs from graph format".into());
+        }
+    }
+    validate_conditional_graph_format(document, format)?;
+    Ok(())
+}
+
+/// Check authored conditional and constructor fragments in compact or full interchange.
+/// Generated relationships are ignored. Unrelated graph fragments retain the
+/// loader's existing recovery behavior; ambiguous ownership in these fragments fails.
+/// Historical direct selector name recovery is not a lossless-import guarantee.
+pub fn validate_conditional_graph_format(
+    document: &Value,
+    format: GraphFormat,
+) -> Result<(), String> {
+    let rows = document.as_array().ok_or("expected an element array")?;
+    let mut steps = 0;
+    constructor_shapes(rows, format, false, &mut steps)?;
+    let mut by = HashMap::new();
+    for (i, row) in rows.iter().enumerate() {
+        charge(&mut steps, 1)?;
+        if let Some(id) = row["@id"].as_str() {
+            by.entry(id).and_modify(|v| *v = None).or_insert(Some(i));
+        }
+    }
+    let lookup = |reference: &Value| -> Result<usize, String> {
+        reference
+            .get("@id")
+            .and_then(Value::as_str)
+            .and_then(|id| by.get(id).copied().flatten())
+            .ok_or_else(|| "missing or ambiguous conditional ownership target".into())
+    };
+    if format == GraphFormat::LegacyV2 {
+        // Legacy loaders have always accepted foreign direct-expression
+        // parameters and recovered other malformed syntax. Only refuse the
+        // recognizable new wrapper: rebuilding it as legacy loses identities.
+        let mut pending = Vec::new();
+        for row in rows {
+            if row["@type"] != "OperatorExpression"
+                || !matches!(
+                    row["operator"].as_str(),
+                    Some("if" | "and" | "or" | "implies" | "??")
+                )
+            {
+                continue;
+            }
+            let Some(relationships) = row["ownedRelationship"].as_array() else {
+                continue;
+            };
+            charge(&mut steps, relationships.len())?;
+            pending.extend(
+                relationships
+                    .iter()
+                    .filter_map(|r| lookup(r).ok())
+                    .filter(|&i| {
+                        rows[i]["@type"] == "ParameterMembership" && rows[i]["isImplied"] != true
+                    })
+                    .skip(1)
+                    .map(|i| (i, 0)),
+            );
+        }
+        let mut seen = HashSet::new();
+        while let Some((i, phase)) = pending.pop() {
+            if !seen.insert((i, phase)) {
+                continue;
+            }
+            charge(&mut steps, 1)?;
+            let key = match phase {
+                0 | 2 | 4 => "ownedRelatedElement",
+                _ => "ownedRelationship",
+            };
+            let Some(references) = rows[i][key].as_array() else {
+                continue;
+            };
+            charge(&mut steps, references.len())?;
+            for child in references.iter().filter_map(|r| lookup(r).ok()) {
+                if rows[child]["isImplied"] == true {
+                    continue;
+                }
+                match phase {
+                    0 if rows[child]["@type"] == "Feature" => pending.push((child, 1)),
+                    0 | 2 if rows[child]["@type"] == "FeatureReferenceExpression" => {
+                        pending.push((child, 3))
+                    }
+                    1 if rows[child]["@type"] == "FeatureValue" => pending.push((child, 2)),
+                    3 if rows[child]["@type"] == "FeatureMembership" => pending.push((child, 4)),
+                    4 if rows[child]["@type"]
+                        .as_str()
+                        .is_some_and(|ty| crate::metaclass::conforms(ty, "Expression")) =>
+                    {
+                        return Err("canonical conditional wrapper requires CanonicalV3; migrate explicitly before changing formats".into());
+                    }
+                    _ => {}
+                }
+            }
+        }
+        return Ok(());
+    }
+    let children = |owner: usize, key: &str| -> Result<Vec<usize>, String> {
+        let inverse = if key == "ownedRelationship" {
+            "owningRelatedElement"
+        } else {
+            "owningRelationship"
+        };
+        let Some(values) = rows[owner].get(key) else {
+            return Ok(Vec::new());
+        };
+        let values = values
+            .as_array()
+            .ok_or("conditional ownership must be an array")?;
+        let mut result = Vec::new();
+        let mut seen = HashSet::new();
+        for value in values {
+            let i = lookup(value)?;
+            if rows[i]["isImplied"] == true {
+                continue;
+            }
+            if !seen.insert(i) || rows[i][inverse]["@id"] != rows[owner]["@id"] {
+                return Err("nonreciprocal or duplicate conditional ownership".into());
+            }
+            let other_inverse = if inverse == "owningRelationship" {
+                "owningRelatedElement"
+            } else {
+                "owningRelationship"
+            };
+            if rows[i].get(other_inverse).is_some_and(|v| !v.is_null()) {
+                return Err("contradictory conditional ownership roles".into());
+            }
+            result.push(i);
+        }
+        Ok(result)
+    };
+    let one_child = |owner| -> Result<usize, String> {
+        let children = children(owner, "ownedRelatedElement")?;
+        if children.len() != 1 {
+            return Err("conditional membership must own exactly one element".into());
+        }
+        Ok(children[0])
+    };
+    for (operator, row) in rows.iter().enumerate() {
+        charge(&mut steps, 1)?;
+        if row["@type"] != "OperatorExpression" || row["isImplied"] == true {
+            continue;
+        }
+        let expected = match row["operator"].as_str() {
+            Some("if") => 3,
+            Some("and" | "or" | "implies" | "??") => 2,
+            _ => continue,
+        };
+        let relationships = children(operator, "ownedRelationship")?;
+        charge(&mut steps, relationships.len())?;
+        let parameters: Vec<_> = relationships
+            .into_iter()
+            .filter(|&i| rows[i]["@type"] == "ParameterMembership")
+            .collect();
+        if parameters.len() != expected {
+            return Err("conditional operand cardinality".into());
+        }
+        for parameter in parameters.into_iter().skip(1) {
+            let feature = one_child(parameter)?;
+            if rows[feature]["@type"] != "Feature" {
+                return Err("conditional operand requires a Feature".into());
+            }
+            if rows[feature]
+                .get("direction")
+                .is_some_and(|direction| direction != "in")
+            {
+                return Err("conditional operand direction must be in".into());
+            }
+            let relationships = children(feature, "ownedRelationship")?;
+            charge(&mut steps, relationships.len())?;
+            let values: Vec<_> = relationships
+                .into_iter()
+                .filter(|&i| rows[i]["@type"] == "FeatureValue")
+                .collect();
+            if values.len() != 1 {
+                return Err("conditional operand requires one value".into());
+            }
+            let expression = one_child(values[0])?;
+            if !rows[expression]["@type"]
+                .as_str()
+                .is_some_and(|ty| crate::metaclass::conforms(ty, "Expression"))
+            {
+                return Err("conditional value must own an Expression".into());
+            }
+            let mut wrapper = false;
+            if rows[expression]["@type"] == "FeatureReferenceExpression" {
+                let relationships = children(expression, "ownedRelationship")?;
+                charge(&mut steps, relationships.len())?;
+                let members: Vec<_> = relationships
+                    .iter()
+                    .copied()
+                    .filter(|&i| rows[i]["@type"] == "FeatureMembership")
+                    .collect();
+                if !members.is_empty() {
+                    if members.len() != 1 || relationships.len() != 1 {
+                        return Err("ambiguous conditional expression wrapper".into());
+                    }
+                    let member = members[0];
+                    let inner = one_child(member)?;
+                    if !rows[inner]["@type"]
+                        .as_str()
+                        .is_some_and(|ty| crate::metaclass::conforms(ty, "Expression"))
+                    {
+                        return Err("conditional wrapper must own an Expression".into());
+                    }
+                    if let Some(alias) = rows[member].get("memberElement") {
+                        if !alias.is_null() && lookup(alias)? != inner {
+                            return Err("conditional memberElement contradicts ownership".into());
+                        }
+                    }
+                    wrapper = true;
+                }
+            }
+            if wrapper != (format == GraphFormat::CanonicalV3) {
+                return Err("conditional operand shape differs from graph format; migrate explicitly before changing formats".into());
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Migrate a complete user-model authored compact ownership forest from LegacyV2 to
+/// CanonicalV3, inserting conditional wrappers and relocating constructor arguments
+/// under their new result. References between all supplied documents are updated atomically.
+/// External inbound references must be updated by the caller using the returned
+/// simultaneous identity map. Decode old ID-elided payloads before migration.
+/// Every non-root input identity must match legacy graph derivation. Foreign
+/// explicit identities remain loadable but require deliberate source rebuilding
+/// before migration. `external_name` must name referenced library targets as in
+/// ids::derive_ids; unresolved derivation is refused.
+/// Regenerate library graphs from source; their normative IDs use a different rule.
+pub fn migrate_conditional_graph(
+    document: &Value,
+    external_name: &dyn Fn(&str) -> Option<String>,
+) -> Result<GraphMigration, String> {
+    let original = document
+        .as_array()
+        .ok_or("expected a compact element array")?;
+    let mut steps = 0;
+    let by = index(original, &mut steps)?;
+    let mut external_ids = HashSet::new();
+    collect_external_references(document, &by, &mut external_ids, 0, &mut steps)?;
+    let derived = crate::ids::derive_ids(document, external_name).map_err(|e| e.to_string())?;
+    for (row, derived) in original.iter().zip(derived) {
+        let root = row["@type"] == "Namespace"
+            && row["owningRelationship"].is_null()
+            && row["owningRelatedElement"].is_null();
+        if !root && derived != Some(id(row)?) {
+            return Err("migration requires legacy graph-derived identities; rebuild foreign-ID or library graphs from source".into());
+        }
+    }
+    let constructors = constructor_shapes(original, GraphFormat::LegacyV2, true, &mut steps)?;
+    let targets = operands(original, &by, &mut steps)?;
+    let mut insertions = HashMap::new();
+    let mut rows = original.clone();
+    // Temporary placeholders participate in both identity derivation and the
+    // simultaneous rewrite map. They must not capture an external reference,
+    // even when their eventual graph-derived identity would be distinct.
+    let mut used: HashSet<_> = by.keys().chain(external_ids.iter()).copied().collect();
+    for (value, expression) in targets {
+        if wrapped(original, &by, expression)? {
+            return Err("document already contains canonical conditional operands".into());
+        }
+        let old = id(&original[expression])?;
+        let wrapper = Uuid::new_v5(&old, b"canonical-conditional-wrapper");
+        let membership = Uuid::new_v5(&old, b"canonical-conditional-membership");
+        if !used.insert(wrapper) || !used.insert(membership) {
+            return Err("temporary migration identity collision".into());
+        }
+        rows[value]["ownedRelatedElement"] = json!([{"@id":wrapper}]);
+        rows[expression]["owningRelationship"] = json!({"@id":membership});
+        let additions = vec![
+            json!({"@id":wrapper,"@type":"FeatureReferenceExpression","elementId":wrapper,"isImpliedIncluded":false,"ownedRelationship":[{"@id":membership}],"owningRelationship":{"@id":id(&original[value])?}}),
+            json!({"@id":membership,"@type":"FeatureMembership","elementId":membership,"isImplied":false,"isImpliedIncluded":false,"ownedRelationship":[],"ownedRelatedElement":[{"@id":old}],"owningRelationship":null,"owningRelatedElement":{"@id":wrapper}}),
+        ];
+        if insertions.insert(expression, additions).is_some() {
+            return Err("operand has multiple values".into());
+        }
+    }
+    for constructor in constructors {
+        let owner = id(&original[constructor.owner])?;
+        let result = Uuid::new_v5(&owner, b"canonical-constructor-result");
+        let membership = Uuid::new_v5(&owner, b"canonical-constructor-result-membership");
+        if !used.insert(result) || !used.insert(membership) {
+            return Err("temporary migration identity collision".into());
+        }
+        let selector = id(&original[constructor.selector])?;
+        let parameters = constructor
+            .parameters
+            .iter()
+            .map(|&i| id(&original[i]))
+            .collect::<Result<Vec<_>, _>>()?;
+        rows[constructor.owner]["ownedRelationship"] = json!([{"@id":selector},{"@id":membership}]);
+        for &parameter in &constructor.parameters {
+            rows[parameter]["owningRelatedElement"] = json!({"@id":result});
+        }
+        let additions = vec![
+            json!({"@id":membership,"@type":"ReturnParameterMembership","elementId":membership,"isImplied":false,"isImpliedIncluded":false,"ownedRelationship":[],"ownedRelatedElement":[{"@id":result}],"owningRelationship":null,"owningRelatedElement":{"@id":owner}}),
+            json!({"@id":result,"@type":"Feature","elementId":result,"isImpliedIncluded":false,"ownedRelationship":parameters.into_iter().map(|id| json!({"@id":id})).collect::<Vec<_>>(),"owningRelationship":{"@id":membership},"direction":"out"}),
+        ];
+        // Source lowering emits the pair after the entire selector subtree, even
+        // for an empty constructor. Preserve all existing row order.
+        insertions
+            .entry(constructor.selector_end + 1)
+            .or_default()
+            .splice(0..0, additions);
+    }
+    let mut expanded = Vec::with_capacity(rows.len() + insertions.len() * 2);
+    let mut element_indices = Vec::with_capacity(rows.len());
+    let mut added_indices = Vec::new();
+    for (i, row) in rows.into_iter().enumerate() {
+        if let Some(additions) = insertions.remove(&i) {
+            for addition in additions {
+                added_indices.push(expanded.len());
+                expanded.push(addition);
+            }
+        }
+        element_indices.push(expanded.len());
+        expanded.push(row);
+    }
+    if let Some(additions) = insertions.remove(&element_indices.len()) {
+        for addition in additions {
+            added_indices.push(expanded.len());
+            expanded.push(addition);
+        }
+    }
+    let mut document = Value::Array(expanded);
+    let rows = document.as_array().unwrap();
+    let roots = rows
+        .iter()
+        .enumerate()
+        .filter(|(_, row)| {
+            row["@type"] == "Namespace"
+                && row["owningRelationship"].is_null()
+                && row["owningRelatedElement"].is_null()
+        })
+        .map(|(i, row)| Ok((i, id(row)?)))
+        .collect::<Result<HashMap<_, _>, String>>()?;
+    // Assign top-down from final parent IDs. derive_ids intentionally compares
+    // each row against its current parent and must not be used for a migration.
+    let derived =
+        crate::ids::assign_ids(&document, &roots, external_name).map_err(|e| e.to_string())?;
+    let mut replacement = HashMap::new();
+    let mut final_ids = HashSet::new();
+    for (row, derived) in rows.iter().zip(derived) {
+        let old = id(row)?;
+        let new = derived;
+        if external_ids.contains(&new) {
+            return Err("migrated identity collides with an external reference".into());
+        }
+        if !final_ids.insert(new) {
+            return Err("migrated identity collision".into());
+        }
+        replacement.insert(old, new);
+    }
+    let ids = by.keys().map(|old| (*old, replacement[old])).collect();
+    let added = added_indices
+        .iter()
+        .map(|&i| replacement[&id(&rows[i]).unwrap()])
+        .collect();
+    rewrite(&mut document, &replacement, 0, &mut steps)?;
+    validate_graph_format(&document, GraphFormat::CanonicalV3)?;
+    Ok(GraphMigration {
+        source: GraphFormat::LegacyV2,
+        target: GraphFormat::CanonicalV3,
+        document,
+        ids,
+        added,
+        element_indices,
+    })
+}
+fn collect_external_references(
+    value: &Value,
+    local: &HashMap<Uuid, usize>,
+    external: &mut HashSet<Uuid>,
+    depth: usize,
+    steps: &mut usize,
+) -> Result<(), String> {
+    charge(steps, 1)?;
+    if depth > 128 {
+        return Err("nested JSON exceeds migration depth limit".into());
+    }
+    match value {
+        Value::Array(values) => {
+            for value in values {
+                collect_external_references(value, local, external, depth + 1, steps)?;
+            }
+        }
+        Value::Object(object) => {
+            if let Some(id) = object
+                .get("@id")
+                .and_then(Value::as_str)
+                .and_then(|id| Uuid::parse_str(id).ok())
+            {
+                if !local.contains_key(&id) {
+                    external.insert(id);
+                }
+            }
+            for value in object.values() {
+                collect_external_references(value, local, external, depth + 1, steps)?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+fn rewrite(
+    value: &mut Value,
+    replacements: &HashMap<Uuid, Uuid>,
+    depth: usize,
+    steps: &mut usize,
+) -> Result<(), String> {
+    charge(steps, 1)?;
+    if depth > 128 {
+        return Err("nested JSON exceeds migration depth limit".into());
+    }
+    match value {
+        Value::Array(a) => {
+            for v in a {
+                rewrite(v, replacements, depth + 1, steps)?;
+            }
+        }
+        Value::Object(map) => {
+            for (key, v) in map {
+                if matches!(key.as_str(), "@id" | "elementId") {
+                    if let Some(new) = v
+                        .as_str()
+                        .and_then(|s| Uuid::parse_str(s).ok())
+                        .and_then(|id| replacements.get(&id))
+                    {
+                        *v = json!(new);
+                    }
+                } else {
+                    rewrite(v, replacements, depth + 1, steps)?;
+                }
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{json::model_to_compact_json, loader::load_document_with_format, model::Model};
+
+    fn source(format: GraphFormat) -> Model {
+        let mut model = Model::with_graph_format(format);
+        assert!(model.add_source("document-1.sysml",
+            "package P { attribute x = 1; attribute y = 2; attribute z = if true ? x else y; }").diagnostics.is_empty());
+        model
+    }
+
+    fn constructor_source(format: GraphFormat, expression: &str) -> Model {
+        let mut model = Model::with_graph_format(format);
+        let text = format!(
+            "class C {{feature x; feature y;}} class H {{feature t:C;}} feature h:H; feature call={expression};"
+        );
+        assert!(
+            model
+                .add_source("constructor.kerml", &text)
+                .diagnostics
+                .is_empty()
+        );
+        model
+    }
+
+    #[test]
+    fn constructor_migration_matches_direct_lowering_and_preserves_identity_domain() {
+        for expression in [
+            "new C()",
+            "new C(1)",
+            "new C(y=2, x=1)",
+            "new h.t()",
+            "new h.t(1)",
+            "new h.t(y=2, x=1)",
+            "new C(new h.t(), if true ? new h.t(1) else new C(y=2))",
+            "new C(new C(), if true ? new C(1) else new C(y=2))",
+        ] {
+            let legacy =
+                model_to_compact_json(&constructor_source(GraphFormat::LegacyV2, expression));
+            let canonical =
+                model_to_compact_json(&constructor_source(GraphFormat::CanonicalV3, expression));
+            let migrated = migrate_conditional_graph(&legacy, &|_| None).unwrap();
+            assert_eq!(migrated.document, canonical, "{expression}");
+            assert!(
+                load_document_with_format(&canonical, &HashMap::new(), GraphFormat::CanonicalV3)
+                    .is_ok(),
+                "{expression}"
+            );
+            assert_eq!(migrated.ids.len(), legacy.as_array().unwrap().len());
+            assert_eq!(
+                migrated.element_indices.len(),
+                legacy.as_array().unwrap().len()
+            );
+            for (old, &new_index) in legacy
+                .as_array()
+                .unwrap()
+                .iter()
+                .zip(&migrated.element_indices)
+            {
+                assert_eq!(
+                    migrated.ids[&id(old).unwrap()],
+                    id(&canonical[new_index]).unwrap()
+                );
+                assert_eq!(old["@type"], canonical[new_index]["@type"]);
+            }
+            for row in canonical
+                .as_array()
+                .unwrap()
+                .iter()
+                .filter(|r| r["@type"] == "ReturnParameterMembership")
+            {
+                let result = id(&row["ownedRelatedElement"][0]).unwrap();
+                assert!(
+                    !migrated.ids.contains_key(&result),
+                    "result must not reuse a legacy argument UUID"
+                );
+                assert!(!migrated.ids.contains_key(&id(row).unwrap()));
+            }
+            assert!(migrate_conditional_graph(&canonical, &|_| None).is_err());
+        }
+    }
+
+    #[test]
+    fn constructor_transport_preserves_semantically_invalid_selector_for_diagnostics() {
+        let source = "package P; feature call=new P();";
+        let mut legacy = Model::with_graph_format(GraphFormat::LegacyV2);
+        let mut canonical = Model::with_graph_format(GraphFormat::CanonicalV3);
+        assert!(
+            legacy
+                .add_source("invalid-selector.kerml", source)
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            canonical
+                .add_source("invalid-selector.kerml", source)
+                .diagnostics
+                .is_empty()
+        );
+        let legacy = model_to_compact_json(&legacy);
+        let canonical = model_to_compact_json(&canonical);
+        assert_eq!(
+            migrate_conditional_graph(&legacy, &|_| None)
+                .unwrap()
+                .document,
+            canonical
+        );
+        assert!(validate_graph_format(&canonical, GraphFormat::CanonicalV3).is_ok());
+        assert!(
+            load_document_with_format(&canonical, &HashMap::new(), GraphFormat::CanonicalV3)
+                .is_ok()
+        );
+        // No Type claim is made: the selector remains the Package from source.
+        let rows = canonical.as_array().unwrap();
+        let by = index(rows, &mut 0).unwrap();
+        let constructor = rows
+            .iter()
+            .find(|r| r["@type"] == "ConstructorExpression")
+            .unwrap();
+        let selector = by[&refs(constructor, "ownedRelationship").unwrap()[0]];
+        let target = by[&id(&rows[selector]["memberElement"]).unwrap()];
+        assert_eq!(rows[target]["@type"], "Package");
+    }
+
+    #[test]
+    fn constructor_shape_refuses_mixed_contracts_and_malformed_claims() {
+        let original =
+            model_to_compact_json(&constructor_source(GraphFormat::CanonicalV3, "new C(x=1)"));
+        let rows = original.as_array().unwrap();
+        let by = index(rows, &mut 0).unwrap();
+        let owner = rows
+            .iter()
+            .position(|r| r["@type"] == "ConstructorExpression")
+            .unwrap();
+        let relationships = refs(&rows[owner], "ownedRelationship").unwrap();
+        let membership = by[&relationships[1]];
+        let result = by[&one(&rows[membership], "ownedRelatedElement").unwrap()];
+        let parameter = by[&one(&rows[result], "ownedRelationship").unwrap()];
+        assert!(validate_conditional_graph_format(&original, GraphFormat::CanonicalV3).is_ok());
+        assert!(validate_conditional_graph_format(&original, GraphFormat::LegacyV2).is_err());
+        let mut hidden_result = original.clone();
+        hidden_result[owner]["ownedRelationship"] = json!([{"@id":relationships[0]}]);
+        assert!(validate_conditional_graph_format(&hidden_result, GraphFormat::LegacyV2).is_err());
+        let legacy =
+            model_to_compact_json(&constructor_source(GraphFormat::LegacyV2, "new C(x=1)"));
+        assert!(validate_conditional_graph_format(&legacy, GraphFormat::CanonicalV3).is_err());
+        for mutation in 0..8 {
+            let mut document = original.clone();
+            match mutation {
+                0 => document[result]["direction"] = json!("in"),
+                1 => document[owner]["ownedRelationship"]
+                    .as_array_mut()
+                    .unwrap()
+                    .push(json!({"@id":relationships[1]})),
+                2 => document[result]["ownedRelationship"] = json!([]),
+                3 => {
+                    document[parameter]["owningRelatedElement"] =
+                        json!({"@id":id(&rows[owner]).unwrap()})
+                }
+                4 => document[owner]["result"] = json!({"@id":id(&rows[owner]).unwrap()}),
+                5 => {
+                    document[membership]["memberElement"] = json!({"@id":id(&rows[owner]).unwrap()})
+                }
+                6 => document[membership]["ownedRelatedElement"] = json!([]),
+                _ => document[result]["declaredName"] = json!("lost"),
+            }
+            assert!(
+                validate_conditional_graph_format(&document, GraphFormat::CanonicalV3).is_err(),
+                "mutation {mutation}"
+            );
+        }
+    }
+
+    #[test]
+    fn canonical_constructor_refuses_unrepresentable_scalars_and_contradictory_aliases() {
+        let model = constructor_source(GraphFormat::CanonicalV3, "new C(x=1)");
+        for original in [
+            model_to_compact_json(&model),
+            crate::full::model_to_full_json(&model),
+        ] {
+            validate_conditional_graph_format(&original, GraphFormat::CanonicalV3).unwrap();
+            let rows = original.as_array().unwrap();
+            let by: HashMap<_, _> = rows
+                .iter()
+                .enumerate()
+                .map(|(i, row)| (id(row).unwrap(), i))
+                .collect();
+            let constructor = rows
+                .iter()
+                .position(|row| row["@type"] == "ConstructorExpression")
+                .unwrap();
+            let result_membership = by[&refs(&rows[constructor], "ownedRelationship").unwrap()[1]];
+            let result = by[&one(&rows[result_membership], "ownedRelatedElement").unwrap()];
+            let parameter = refs(&rows[result], "ownedRelationship")
+                .unwrap()
+                .into_iter()
+                .map(|id| by[&id])
+                .find(|&i| rows[i]["@type"] == "ParameterMembership")
+                .unwrap();
+            let argument = by[&one(&rows[parameter], "ownedRelatedElement").unwrap()];
+            let redefinition = refs(&rows[argument], "ownedRelationship")
+                .unwrap()
+                .into_iter()
+                .map(|id| by[&id])
+                .find(|&i| rows[i]["@type"] == "Redefinition")
+                .unwrap();
+            let selector = by[&refs(&rows[constructor], "ownedRelationship").unwrap()[0]];
+            let value = refs(&rows[argument], "ownedRelationship")
+                .unwrap()
+                .into_iter()
+                .map(|id| by[&id])
+                .find(|&i| rows[i]["@type"] == "FeatureValue")
+                .unwrap();
+            for (index, key, invalid) in [
+                (result, "isUnique", json!(false)),
+                (result, "isUnique", Value::Null),
+                (result, "isConstant", json!(true)),
+                (result, "isOrdered", json!(true)),
+                (result, "isAbstract", json!(true)),
+                (argument, "isUnique", json!(false)),
+                (argument, "isVariable", json!(true)),
+                (argument, "declaredName", json!("lost")),
+                (argument, "aliasIds", json!(["lost"])),
+                (selector, "visibility", json!("private")),
+                (parameter, "visibility", json!("private")),
+                (result_membership, "visibility", json!("protected")),
+                (value, "isInitial", json!(true)),
+                (value, "isDefault", json!(true)),
+                (value, "isDefault", Value::Null),
+            ] {
+                let mut document = original.clone();
+                document[index][key] = invalid;
+                assert!(
+                    validate_conditional_graph_format(&document, GraphFormat::CanonicalV3).is_err(),
+                    "{index}.{key}"
+                );
+                assert!(
+                    load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                        .is_err(),
+                    "{index}.{key}"
+                );
+            }
+            let wrong = json!({"@id":id(&rows[result_membership]).unwrap()});
+            for (index, key, invalid) in [
+                (parameter, "ownedMemberParameter", wrong.clone()),
+                (parameter, "ownedMemberFeature", wrong.clone()),
+                (result_membership, "ownedMemberParameter", wrong.clone()),
+                (parameter, "source", json!([wrong.clone()])),
+                (value, "value", wrong.clone()),
+                (value, "featureWithValue", wrong.clone()),
+                (redefinition, "general", wrong.clone()),
+                (redefinition, "subsettedFeature", wrong.clone()),
+                (redefinition, "target", json!([wrong.clone()])),
+                (redefinition, "source", json!([wrong.clone()])),
+                (
+                    redefinition,
+                    "relatedElement",
+                    json!([wrong.clone(), wrong.clone()]),
+                ),
+                (argument, "owningMembership", wrong.clone()),
+                (argument, "owningFeatureMembership", wrong.clone()),
+                (argument, "owningType", wrong.clone()),
+                (
+                    parameter,
+                    "relatedElement",
+                    json!([wrong.clone(), wrong.clone()]),
+                ),
+                (result, "ownedFeature", json!([wrong.clone()])),
+                (constructor, "ownedFeature", json!([wrong.clone()])),
+                (
+                    constructor,
+                    "ownedFeatureMembership",
+                    json!([{"@id":id(&rows[parameter]).unwrap()}]),
+                ),
+            ] {
+                let mut document = original.clone();
+                document[index][key] = invalid;
+                assert!(
+                    validate_conditional_graph_format(&document, GraphFormat::CanonicalV3).is_err(),
+                    "{index}.{key}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn constructor_full_selector_retains_external_name_compatibility() {
+        let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+        model.add_library_source("constructor-library.kerml", "class External {feature x;}");
+        assert!(
+            model
+                .add_source(
+                    "external-constructor.kerml",
+                    "feature call=new External(x=1);"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        let mut document = crate::full::model_to_full_json(&model);
+        let rows = document.as_array().unwrap();
+        let by: HashMap<_, _> = rows
+            .iter()
+            .enumerate()
+            .map(|(i, row)| (id(row).unwrap(), i))
+            .collect();
+        let constructor = rows
+            .iter()
+            .find(|row| row["@type"] == "ConstructorExpression")
+            .unwrap();
+        let selector = by[&refs(constructor, "ownedRelationship").unwrap()[0]];
+        let target = id(&rows[selector]["memberElement"]).unwrap();
+        assert!(
+            !by.contains_key(&target),
+            "library target should be outside user payload"
+        );
+        // A full producer with the external library context can materialize
+        // these names. Their historical recovery is outside the new wrapper
+        // preservation contract; shape validation is not a lossless certificate.
+        document[selector]["memberName"] = json!("External");
+        document[selector]["memberShortName"] = json!("Ext");
+        validate_conditional_graph_format(&document, GraphFormat::CanonicalV3).unwrap();
+    }
+
+    #[test]
+    fn constructor_migration_refuses_existing_result_and_temporary_capture_atomically() {
+        let original =
+            model_to_compact_json(&constructor_source(GraphFormat::LegacyV2, "new C(1)"));
+        let constructor = original
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|r| r["@type"] == "ConstructorExpression")
+            .unwrap();
+        for label in [
+            b"canonical-constructor-result".as_slice(),
+            b"canonical-constructor-result-membership".as_slice(),
+        ] {
+            let mut document = original.clone();
+            let external = Uuid::new_v5(&id(constructor).unwrap(), label);
+            let root = id(&document[0]).unwrap();
+            let alias = Uuid::new_v5(&root, b"::externalAlias");
+            document[0]["ownedRelationship"]
+                .as_array_mut()
+                .unwrap()
+                .push(json!({"@id":alias}));
+            document.as_array_mut().unwrap().push(json!({
+                "@id":alias,"@type":"Membership","elementId":alias,"isImplied":false,
+                "ownedRelationship":[],"ownedRelatedElement":[],"owningRelationship":null,
+                "owningRelatedElement":{"@id":root},"memberName":"externalAlias","memberElement":{"@id":external}
+            }));
+            let snapshot = document.clone();
+            assert!(
+                migrate_conditional_graph(&document, &|_| None)
+                    .unwrap_err()
+                    .contains("temporary migration identity collision")
+            );
+            assert_eq!(document, snapshot);
+        }
+    }
+
+    #[test]
+    fn loaders_refuse_profile_mismatches_even_when_operand_metaclasses_match() {
+        for source_format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let model = source(source_format);
+            let other = if source_format == GraphFormat::LegacyV2 {
+                GraphFormat::CanonicalV3
+            } else {
+                GraphFormat::LegacyV2
+            };
+            for document in [
+                model_to_compact_json(&model),
+                crate::full::model_to_full_json(&model),
+            ] {
+                assert!(validate_conditional_graph_format(&document, source_format).is_ok());
+                assert!(
+                    load_document_with_format(&document, &HashMap::new(), source_format).is_ok()
+                );
+                assert!(load_document_with_format(&document, &HashMap::new(), other).is_err());
+            }
+        }
+    }
+
+    #[test]
+    fn unversioned_loader_retains_foreign_conditional_recovery() {
+        let canonical = source(GraphFormat::CanonicalV3);
+        for document in [
+            model_to_compact_json(&canonical),
+            crate::full::model_to_full_json(&canonical),
+        ] {
+            let (model, mut resolved, _, warnings) =
+                crate::loader::load_document(&document, &HashMap::new()).unwrap();
+            assert_eq!(model.graph_format(), GraphFormat::LegacyV2);
+            assert!(
+                warnings
+                    .iter()
+                    .any(|warning| warning.contains("no structural counterpart")),
+                "{warnings:?}"
+            );
+            assert_eq!(
+                resolved.evaluate_qualified("P::z"),
+                Ok(crate::eval::Value::Integer(1))
+            );
+            assert!(
+                load_document_with_format(&document, &HashMap::new(), GraphFormat::LegacyV2)
+                    .is_err()
+            );
+            assert!(
+                load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                    .is_ok()
+            );
+        }
+    }
+
+    #[test]
+    fn conditional_alias_and_direction_contradictions_are_refused() {
+        let model = source(GraphFormat::CanonicalV3);
+        let original = model_to_compact_json(&model);
+        let rows = original.as_array().unwrap();
+        let mut steps = 0;
+        let by = index(rows, &mut steps).unwrap();
+        let (value, expression) = operands(rows, &by, &mut steps).unwrap()[0];
+        let member_index = by[&one(&rows[expression], "ownedRelationship").unwrap()];
+        let mut document = original.clone();
+        let wrong = document[0]["@id"].clone();
+        document[member_index]["memberElement"] = json!({"@id": wrong});
+        assert!(validate_conditional_graph_format(&document, GraphFormat::CanonicalV3).is_err());
+        let feature = by[&id(&rows[value]["owningRelatedElement"]).unwrap()];
+        let mut document = original.clone();
+        document[feature]["direction"] = json!("out");
+        assert!(validate_graph_format(&document, GraphFormat::CanonicalV3).is_err());
+        assert!(
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn migration_distinguishes_identity_domain_from_library_metaclass() {
+        let text = "standard library package L { feature value = if true ? 1 else 2; }";
+        let mut user = Model::new();
+        user.add_source("user.kerml", text);
+        assert!(migrate_conditional_graph(&model_to_compact_json(&user), &|_| None).is_ok());
+        let mut library = Model::new();
+        library.add_library_source("library.kerml", text);
+        assert!(
+            migrate_conditional_graph(&crate::json::library_to_compact_json(&library), &|_| None)
+                .is_err()
+        );
+        let mut foreign = model_to_compact_json(&source(GraphFormat::LegacyV2));
+        let old = id(&foreign[1]).unwrap();
+        let new = Uuid::new_v5(&old, b"foreign-id");
+        rewrite(&mut foreign, &HashMap::from([(old, new)]), 0, &mut 0).unwrap();
+        assert!(
+            load_document_with_format(&foreign, &HashMap::new(), GraphFormat::LegacyV2).is_ok()
+        );
+        assert!(migrate_conditional_graph(&foreign, &|_| None).is_err());
+    }
+
+    #[test]
+    fn migration_refuses_duplicate_ownership_roles() {
+        let mut document = model_to_compact_json(&source(GraphFormat::LegacyV2));
+        let row = document
+            .as_array_mut()
+            .unwrap()
+            .iter_mut()
+            .find(|row| row["owningRelationship"].is_object())
+            .unwrap();
+        row["owningRelatedElement"] = row["owningRelationship"].clone();
+        assert!(migrate_conditional_graph(&document, &|_| None).is_err());
+    }
+
+    #[test]
+    fn migration_refuses_capturing_an_external_reference() {
+        let mut document = model_to_compact_json(&source(GraphFormat::LegacyV2));
+        let initial = migrate_conditional_graph(&document, &|_| None).unwrap();
+        let old_ids: HashSet<_> = initial.ids.keys().copied().collect();
+        // Added wrappers may reuse former operand/relationship UUIDs. A moved
+        // descendant still introduces a final identity outside the old domain.
+        let added = initial
+            .document
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|row| id(row).unwrap())
+            .find(|id| !old_ids.contains(id))
+            .unwrap();
+        let root = id(&document[0]).unwrap();
+        let alias = Uuid::new_v5(&root, b"::externalAlias");
+        document[0]["ownedRelationship"]
+            .as_array_mut()
+            .unwrap()
+            .push(json!({"@id":alias}));
+        document.as_array_mut().unwrap().push(json!({
+            "@id":alias,"@type":"Membership","elementId":alias,"isImplied":false,
+            "ownedRelationship":[],"ownedRelatedElement":[],"owningRelationship":null,
+            "owningRelatedElement":{"@id":root},"memberName":"externalAlias",
+            "memberElement":{"@id":added}
+        }));
+        let error = migrate_conditional_graph(&document, &|_| None).unwrap_err();
+        assert!(
+            error.contains("collides with an external reference"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn migration_temporary_ids_cannot_capture_external_references() {
+        let original = model_to_compact_json(&source(GraphFormat::LegacyV2));
+        let rows = original.as_array().unwrap();
+        let by = index(rows, &mut 0).unwrap();
+        let (_, expression) = operands(rows, &by, &mut 0).unwrap()[0];
+        let operand = id(&rows[expression]).unwrap();
+        for label in [
+            b"canonical-conditional-wrapper".as_slice(),
+            b"canonical-conditional-membership".as_slice(),
+        ] {
+            let external = Uuid::new_v5(&operand, label);
+            let mut document = original.clone();
+            let root = id(&document[0]).unwrap();
+            let alias = Uuid::new_v5(&root, b"::externalAlias");
+            document[0]["ownedRelationship"]
+                .as_array_mut()
+                .unwrap()
+                .push(json!({"@id":alias}));
+            document.as_array_mut().unwrap().push(json!({
+                "@id":alias,"@type":"Membership","elementId":alias,"isImplied":false,
+                "ownedRelationship":[],"ownedRelatedElement":[],"owningRelationship":null,
+                "owningRelatedElement":{"@id":root},"memberName":"externalAlias",
+                "memberElement":{"@id":external}
+            }));
+            let snapshot = document.clone();
+            let error = migrate_conditional_graph(&document, &|_| None).unwrap_err();
+            assert!(
+                error.contains("temporary migration identity collision"),
+                "{error}"
+            );
+            assert_eq!(document, snapshot);
+        }
+    }
+
+    #[test]
+    fn legacy_loader_preserves_foreign_direct_expression_parameter_support() {
+        let mut document = model_to_compact_json(&source(GraphFormat::LegacyV2));
+        let rows = document.as_array().unwrap();
+        let by = index(rows, &mut 0).unwrap();
+        let (value, expression) = operands(rows, &by, &mut 0).unwrap()[0];
+        let feature = by[&id(&rows[value]["owningRelatedElement"]).unwrap()];
+        let parameter = by[&id(&rows[feature]["owningRelationship"]).unwrap()];
+        let expression_id = id(&rows[expression]).unwrap();
+        let parameter_id = id(&rows[parameter]).unwrap();
+        document[parameter]["ownedRelatedElement"] = json!([{"@id":expression_id}]);
+        document[expression]["owningRelationship"] = json!({"@id":parameter_id});
+        let rows = document.as_array_mut().unwrap();
+        for i in [value.max(feature), value.min(feature)] {
+            rows.remove(i);
+        }
+        assert!(
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::LegacyV2).is_ok()
+        );
+        assert!(
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                .is_err()
+        );
+        assert!(migrate_conditional_graph(&document, &|_| None).is_err());
+    }
+
+    #[test]
+    fn direct_lift_does_not_override_a_conflicting_member_alias() {
+        let mut document = model_to_compact_json(&source(GraphFormat::CanonicalV3));
+        let rows = document.as_array().unwrap();
+        let by = index(rows, &mut 0).unwrap();
+        let (_, expression) = operands(rows, &by, &mut 0).unwrap()[0];
+        let member = by[&one(&rows[expression], "ownedRelationship").unwrap()];
+        let other = rows.iter().find(|row| row["declaredName"] == "y").unwrap()["@id"].clone();
+        document[member]["memberElement"] = json!({"@id":other});
+        // The compatibility lifter retains its existing alias-first fallback;
+        // graph-aware loading rejects this contradiction before lifting.
+        let lifted = crate::lift::from_compact_json(&document).unwrap();
+        let text = sysmlv2_syntax::print::print_source(&lifted.unit);
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source("replayed.sysml", &text)
+                .diagnostics
+                .is_empty()
+        );
+        let mut resolved = crate::json::ResolvedModel::build(&model);
+        assert_eq!(
+            resolved.evaluate_qualified("P::z"),
+            Ok(crate::eval::Value::Integer(2))
+        );
+        assert!(
+            load_document_with_format(&document, &HashMap::new(), GraphFormat::CanonicalV3)
+                .is_err()
+        );
+    }
+}
diff --git a/crates/sysmlv2-model/src/model.rs b/crates/sysmlv2-model/src/model.rs
index 8b97a00..96a64f4 100644
--- a/crates/sysmlv2-model/src/model.rs
+++ b/crates/sysmlv2-model/src/model.rs
@@ -86,9 +86,58 @@ impl ParsedSource {
     }
 }
 
+/// Original owned Boolean inputs from one structurally paired payload row.
+/// This is source provenance, not inferred semantic state.
+#[derive(Clone)]
+pub(crate) struct PayloadOwnedFlags {
+    pub(crate) metaclass: &'static str,
+    pub(crate) flags: crate::properties::Properties,
+}
+
+// Retain the original syntax allocation so an edited or replaced source cannot
+// reuse payload values merely by occupying the same ordinal and lowering path.
+struct PayloadSource {
+    name: String,
+    syntax: std::sync::Arc<SourceUnit>,
+    flags: std::collections::HashMap<String, PayloadOwnedFlags>,
+}
+
+pub(crate) const PAYLOAD_USAGE_FLAGS: &[&str] =
+    &["isConstant", "isEnd", "isComposite", "isPortion"];
+
+pub(crate) fn is_payload_usage_flag(metaclass: &str, name: &str) -> bool {
+    PAYLOAD_USAGE_FLAGS.contains(&name)
+        && crate::metaclass::conforms(metaclass, "Usage")
+        && crate::semantic_catalog::property(metaclass, name)
+            .and_then(|(_, effective)| effective)
+            .is_some_and(|p| !p.derived && p.target == "Boolean")
+}
+
+/// Authored graph/identity contract. Existing constructors retain the legacy shape.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[non_exhaustive]
+pub enum GraphFormat {
+    #[default]
+    LegacyV2,
+    /// Conditional operands own expression-reference wrappers; constructor
+    /// arguments are owned by an explicit result Feature. Textual end constancy
+    /// uses checked variability evidence.
+    CanonicalV3,
+}
+impl GraphFormat {
+    /// Version carried by graph-aware caches and binary interchange.
+    pub const fn version(self) -> u8 {
+        match self {
+            Self::LegacyV2 => 2,
+            Self::CanonicalV3 => 3,
+        }
+    }
+}
+
 /// A set of parsed source units sharing one global root namespace.
 #[derive(Default)]
 pub struct Model {
+    graph_format: GraphFormat,
     units: Vec<ModelUnit>,
     // Original text is retained only for library snapshots. Public ModelUnit
     // continues to expose the exact, shared syntax tree.
@@ -100,6 +149,25 @@ pub struct Model {
     /// Interior mutability: the builder consumes hints / deposits a
     /// recording through `&Model`.
     lib_cache: std::cell::RefCell<LibCacheSlot>,
+    // Original unit ordinal + lowering path identify immutable input syntax
+    // before graph-effective IDs are assigned. Empty entries still mark a
+    // lifted payload unit, which must not acquire text-only defaults.
+    payload_sources: std::collections::HashMap<usize, PayloadSource>,
+    /// The outcomes the next build starts from, and the outcomes a build
+    /// settled on (see [`crate::json::settled`]). Interior mutability: the
+    /// builder takes the one and deposits the other through `&Model`.
+    settled: std::cell::RefCell<SettledSlot>,
+}
+
+/// The settled-outcomes state carried by a [`Model`].
+#[derive(Default)]
+pub(crate) struct SettledSlot {
+    /// Whether a build keeps the outcomes it settles on.
+    keep: bool,
+    /// The outcomes the next build starts from.
+    start: Option<std::sync::Arc<crate::json::settled::SettledOutcomes>>,
+    /// The outcomes the last build settled on, when kept.
+    kept: Option<std::sync::Arc<crate::json::settled::SettledOutcomes>>,
 }
 
 /// Library-cache state carried by a [`Model`].
@@ -115,12 +183,83 @@ pub(crate) enum LibCacheSlot {
     Record,
     /// Outcomes recorded by a build, awaiting [`Model::take_recorded_library_cache`].
     Recorded(crate::libcache::LibraryCache),
-    /// A recording on disk, read only if a build cannot reuse the prepared
+    /// A recording held back, read only if a build cannot reuse the prepared
     /// graph. Prepared builds never pay for loading it.
-    Lazy(std::path::PathBuf),
+    Lazy(LazyRecording),
+}
+
+/// Where a held-back recording comes from: a cache file, or the encoded
+/// bytes a host already holds (a browser fetched them beside the prepared
+/// snapshot), decoded only when a build needs them.
+pub(crate) enum LazyRecording {
+    File(std::path::PathBuf),
+    Bytes(std::sync::Arc<[u8]>),
+}
+
+impl LazyRecording {
+    fn load(&self) -> Option<crate::libcache::LibraryCache> {
+        match self {
+            Self::File(path) => crate::libcache::LibraryCache::load(path),
+            Self::Bytes(bytes) => crate::libcache::LibraryCache::from_bytes(bytes),
+        }
+    }
 }
 
 impl Model {
+    /// Choose the authored graph format before loading sources or prepared libraries.
+    pub fn with_graph_format(graph_format: GraphFormat) -> Self {
+        Self {
+            graph_format,
+            ..Self::default()
+        }
+    }
+
+    pub fn graph_format(&self) -> GraphFormat {
+        self.graph_format
+    }
+
+    pub(crate) fn add_payload_source(&mut self, name: impl Into<String>, text: &str) -> &ModelUnit {
+        let index = self.unit_count();
+        let unit = self.add_source(name, text);
+        let origin = PayloadSource {
+            name: unit.name.clone(),
+            syntax: unit.unit.clone(),
+            flags: std::collections::HashMap::new(),
+        };
+        self.payload_sources.insert(index, origin);
+        self.unit(index)
+    }
+
+    pub(crate) fn payload_source_flags(
+        &self,
+        unit: usize,
+    ) -> Option<&std::collections::HashMap<String, PayloadOwnedFlags>> {
+        let origin = self.payload_sources.get(&unit)?;
+        if unit >= self.unit_count() {
+            return None;
+        }
+        let current = self.unit(unit);
+        (!current.is_library
+            && current.name == origin.name
+            && std::sync::Arc::ptr_eq(&current.unit, &origin.syntax))
+        .then_some(&origin.flags)
+    }
+
+    pub(crate) fn retain_payload_flags(
+        &mut self,
+        unit: usize,
+        path: String,
+        input: PayloadOwnedFlags,
+    ) {
+        if self.payload_source_flags(unit).is_some() {
+            self.payload_sources
+                .get_mut(&unit)
+                .unwrap()
+                .flags
+                .insert(path, input);
+        }
+    }
+
     pub(crate) fn install_prepared(
         &mut self,
         library: std::sync::Arc<crate::prepared::PreparedLibrary>,
@@ -131,11 +270,46 @@ impl Model {
                 "install a prepared library before adding source units",
             ));
         }
+        if library.graph_format() != self.graph_format {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "prepared library graph format differs from the model",
+            ));
+        }
         self.library = Some(library.units.clone());
+        // A library decoded from a snapshot keeps no recording, but it may hold
+        // the encoded one for the build that must resolve it jointly after all.
+        if library.recording.is_none() {
+            if let Some(bytes) = &library.lazy_recording {
+                let mut slot = self.lib_cache.borrow_mut();
+                if matches!(*slot, LibCacheSlot::Off) {
+                    *slot = LibCacheSlot::Lazy(LazyRecording::Bytes(std::sync::Arc::clone(bytes)));
+                }
+            }
+        }
         self.prepared = Some(library);
         Ok(())
     }
 
+    /// Arm the recording the installed prepared library keeps, for a build
+    /// that cannot reuse its prepared graph: such a build then replays the
+    /// recording instead of resolving the whole library afresh. A slot the
+    /// caller set (a recording in progress, a snapshot, a lazy cache file)
+    /// stays in place.
+    pub(crate) fn arm_prepared_recording(&self) {
+        let Some(recording) = self
+            .prepared
+            .as_ref()
+            .and_then(|library| library.recording.as_ref())
+        else {
+            return;
+        };
+        let mut slot = self.lib_cache.borrow_mut();
+        if matches!(*slot, LibCacheSlot::Off) {
+            *slot = LibCacheSlot::Use(std::sync::Arc::clone(recording));
+        }
+    }
+
     /// Prepare and retain this library-only model for subsequent user builds.
     pub fn prepare_library(
         &mut self,
@@ -191,6 +365,13 @@ impl Model {
     /// Parse and add a user source. The dialect is chosen by the name's
     /// extension, read without case (`.kerml` → KerML, anything else →
     /// SysML).
+    ///
+    /// The name also seeds the source document's root identity and therefore
+    /// its derived user-element IDs. Give distinct documents distinct stable
+    /// names, such as project-relative paths; a basename alone is insufficient
+    /// when files in different directories share it. Names are not deduplicated
+    /// or normalized by this method. Reusing a name can produce duplicate IDs;
+    /// changing it changes the freshly derived identities for that document.
     pub fn add_source(&mut self, name: impl Into<String>, src: &str) -> &ModelUnit {
         self.add_parsed_source(ParsedSource::new(name, src))
     }
@@ -301,6 +482,52 @@ impl Model {
         sources
     }
 
+    /// Keep the outcomes the next build settles on, for
+    /// [`Self::settled_outcomes`].
+    pub fn keep_settled_outcomes(&mut self) {
+        self.settled.get_mut().keep = true;
+    }
+
+    /// Start the next build, on a prepared library, from `outcomes`, the
+    /// outcomes a previous build settled on (see [`crate::json::settled`]):
+    /// a unit lowered to the references it was lowered to then starts from
+    /// their outcomes, and is confirmed in one pass when it resolves as it
+    /// did; any other unit starts unresolved. The outcomes the build
+    /// settles on are kept in turn.
+    pub fn start_from_settled(
+        &mut self,
+        outcomes: std::sync::Arc<crate::json::settled::SettledOutcomes>,
+    ) {
+        let slot = self.settled.get_mut();
+        slot.start = Some(outcomes);
+        slot.keep = true;
+    }
+
+    /// The outcomes the last build settled on, when kept; `None` when it
+    /// did not settle.
+    pub fn settled_outcomes(
+        &self,
+    ) -> Option<std::sync::Arc<crate::json::settled::SettledOutcomes>> {
+        self.settled.borrow().kept.clone()
+    }
+
+    pub(crate) fn take_settled(
+        &self,
+    ) -> Option<std::sync::Arc<crate::json::settled::SettledOutcomes>> {
+        self.settled.borrow_mut().start.take()
+    }
+
+    pub(crate) fn keeps_settled(&self) -> bool {
+        self.settled.borrow().keep
+    }
+
+    pub(crate) fn deposit_settled(
+        &self,
+        outcomes: std::sync::Arc<crate::json::settled::SettledOutcomes>,
+    ) {
+        self.settled.borrow_mut().kept = Some(outcomes);
+    }
+
     /// Replay `cache` on the next build of this model (library units must
     /// match the content the cache was recorded from — key by
     /// [`crate::libcache::hash_library_dir`]).
@@ -336,7 +563,7 @@ impl Model {
             // invocation may build more than once).
             LibCacheSlot::Use(c) => LibCacheSlot::Use(std::sync::Arc::clone(c)),
             LibCacheSlot::Record => std::mem::take(&mut *slot),
-            LibCacheSlot::Lazy(path) => match crate::libcache::LibraryCache::load(path) {
+            LibCacheSlot::Lazy(source) => match source.load() {
                 Some(cache) => {
                     let cache = std::sync::Arc::new(cache);
                     *slot = LibCacheSlot::Use(std::sync::Arc::clone(&cache));
@@ -351,10 +578,21 @@ impl Model {
         }
     }
 
+    /// The resolution recording the last library build replayed or made.
+    pub(crate) fn library_recording(
+        &self,
+    ) -> Option<std::sync::Arc<crate::libcache::LibraryCache>> {
+        match &*self.lib_cache.borrow() {
+            LibCacheSlot::Use(cache) => Some(std::sync::Arc::clone(cache)),
+            LibCacheSlot::Recorded(cache) => Some(std::sync::Arc::new(cache.clone())),
+            _ => None,
+        }
+    }
+
     /// Keep a recording available for builds that fall back from the
     /// prepared graph, without reading it up front or disabling that graph.
     pub(crate) fn set_lazy_library_cache(&self, path: std::path::PathBuf) {
-        *self.lib_cache.borrow_mut() = LibCacheSlot::Lazy(path);
+        *self.lib_cache.borrow_mut() = LibCacheSlot::Lazy(LazyRecording::File(path));
     }
 
     #[cfg(test)]
@@ -435,3 +673,84 @@ mod dialect_tests {
         assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
     }
 }
+
+#[cfg(test)]
+mod payload_source_tests {
+    use super::*;
+
+    fn model() -> Model {
+        let mut m = Model::new();
+        m.add_payload_source("input.sysml", "part def P { end part p; }");
+        m.add_payload_source("second.sysml", "part def Q { end part p; }");
+        assert!(m.payload_source_flags(0).is_some());
+        m
+    }
+
+    #[test]
+    fn payload_origin_refuses_replacement_edit_reinsert_reorder_and_role_changes() {
+        let mut m = model();
+        let find = |resolved: &crate::json::ResolvedModel| {
+            resolved
+                .user_elements()
+                .find(|&e| {
+                    resolved
+                        .element_properties(e)
+                        .get("declaredName")
+                        .and_then(serde_json::Value::as_str)
+                        == Some("p")
+                })
+                .unwrap()
+        };
+        let initial = crate::json::ResolvedModel::build(&m);
+        let (_, path) = initial.payload_owned_flag_anchor(find(&initial)).unwrap();
+        let mut flags = crate::properties::Properties::new();
+        flags.insert_payload_flag("isConstant", serde_json::json!("original payload"));
+        m.retain_payload_flags(
+            0,
+            path,
+            PayloadOwnedFlags {
+                metaclass: "PartUsage",
+                flags,
+            },
+        );
+        let retained = crate::json::ResolvedModel::build(&m);
+        assert_eq!(
+            retained.element_properties(find(&retained))["isConstant"],
+            serde_json::json!("original payload")
+        );
+        let mut replacement = Model::new();
+        assert!(
+            replacement
+                .add_source("input.sysml", "part def P { constant end part p; }")
+                .diagnostics
+                .is_empty()
+        );
+        m.units[0] = replacement.units.remove(0);
+        assert!(m.payload_source_flags(0).is_none());
+        let rebuilt = crate::json::ResolvedModel::build(&m);
+        assert_eq!(
+            rebuilt.element_properties(find(&rebuilt))["isConstant"],
+            serde_json::json!(true)
+        );
+        let mut m = model();
+        std::sync::Arc::make_mut(&mut m.units[0].unit)
+            .members
+            .clear();
+        assert!(m.payload_source_flags(0).is_none());
+        let mut m = model();
+        m.units.remove(0);
+        m.add_source("input.sysml", "part def P { end part p; }");
+        assert!(m.payload_source_flags(0).is_none());
+        assert!(m.payload_source_flags(1).is_none());
+        let mut m = model();
+        m.units.swap(0, 1);
+        assert!(m.payload_source_flags(0).is_none());
+        assert!(m.payload_source_flags(1).is_none());
+        let mut m = model();
+        m.units[0].is_library = true;
+        assert!(m.payload_source_flags(0).is_none());
+        let mut m = model();
+        m.units[0].name = "renamed.sysml".into();
+        assert!(m.payload_source_flags(0).is_none());
+    }
+}
diff --git a/crates/sysmlv2-model/src/operation_catalog.rs b/crates/sysmlv2-model/src/operation_catalog.rs
new file mode 100644
index 0000000..175fa18
--- /dev/null
+++ b/crates/sysmlv2-model/src/operation_catalog.rs
@@ -0,0 +1,414 @@
+//! Generated by `tools/operation_catalog.py` from the normative 20250201 XMI.
+//! Declaration metadata only; no executable support is implied.
+
+#[derive(Debug)]
+pub struct ParameterSpec {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub target: &'static str,
+    /// The explicit XMI direction, or None if omitted. No return role is inferred.
+    pub direction: Option<&'static str>,
+    pub lower: usize,
+    pub upper: Option<usize>,
+    pub ordered: bool,
+    pub unique: bool,
+}
+
+#[derive(Debug)]
+pub struct OperationSpec {
+    pub id: &'static str,
+    pub declaring_metaclass: &'static str,
+    pub name: &'static str,
+    pub redefines: &'static [&'static str],
+    /// Source declaration order, including unnamed parameters.
+    pub parameters: &'static [ParameterSpec],
+}
+
+#[rustfmt::skip]
+pub static OPERATIONS: &[OperationSpec] = &[
+    OperationSpec { id: "Core-Features-Feature-allRedefinedFeatures_", declaring_metaclass: "Feature", name: "allRedefinedFeatures", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-allRedefinedFeatures_-", name: "", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-asCartesianProduct_", declaring_metaclass: "Feature", name: "asCartesianProduct", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-asCartesianProduct_-", name: "", target: "Type", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-canAccess_Feature", declaring_metaclass: "Feature", name: "canAccess", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-canAccess_Feature-feature", name: "feature", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-canAccess_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-directionFor_Type", declaring_metaclass: "Feature", name: "directionFor", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-directionFor_Type-type", name: "type", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-directionFor_Type-", name: "", target: "FeatureDirectionKind", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-effectiveName_", declaring_metaclass: "Feature", name: "effectiveName", redefines: &["Root-Elements-Element-effectiveName_"], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-effectiveName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-effectiveShortName_", declaring_metaclass: "Feature", name: "effectiveShortName", redefines: &["Root-Elements-Element-effectiveShortName_"], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-effectiveShortName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-isCartesianProduct_", declaring_metaclass: "Feature", name: "isCartesianProduct", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-isCartesianProduct_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-isCompatibleWith_Type", declaring_metaclass: "Feature", name: "isCompatibleWith", redefines: &["Core-Types-Type-isCompatibleWith_Type"], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-isCompatibleWith_Type-otherType", name: "otherType", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-isFeaturedWithin_Type", declaring_metaclass: "Feature", name: "isFeaturedWithin", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-isFeaturedWithin_Type-type", name: "type", target: "Type", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-isFeaturedWithin_Type-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-isFeaturingType_Type", declaring_metaclass: "Feature", name: "isFeaturingType", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-isFeaturingType_Type-type", name: "type", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-isFeaturingType_Type-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-isOwnedCrossFeature_", declaring_metaclass: "Feature", name: "isOwnedCrossFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-isOwnedCrossFeature_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-namingFeature_", declaring_metaclass: "Feature", name: "namingFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-namingFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-ownedCrossFeature_", declaring_metaclass: "Feature", name: "ownedCrossFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-ownedCrossFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-redefinesFromLibrary_String", declaring_metaclass: "Feature", name: "redefinesFromLibrary", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-redefinesFromLibrary_String-libraryFeatureName", name: "libraryFeatureName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-redefinesFromLibrary_String-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-redefines_Feature", declaring_metaclass: "Feature", name: "redefines", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-redefines_Feature-redefinedFeature", name: "redefinedFeature", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-redefines_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-subsetsChain_Feature_Feature", declaring_metaclass: "Feature", name: "subsetsChain", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-subsetsChain_Feature_Feature-first", name: "first", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-subsetsChain_Feature_Feature-second", name: "second", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-subsetsChain_Feature_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-supertypes_Boolean", declaring_metaclass: "Feature", name: "supertypes", redefines: &["Core-Types-Type-supertypes_Boolean"], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-supertypes_Boolean-excludeImplied", name: "excludeImplied", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Features-Feature-supertypes_Boolean-", name: "", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Features-Feature-typingFeatures_", declaring_metaclass: "Feature", name: "typingFeatures", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Features-Feature-typingFeatures_-", name: "", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-allRedefinedFeaturesOf_Membership", declaring_metaclass: "Type", name: "allRedefinedFeaturesOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-allRedefinedFeaturesOf_Membership-membership", name: "membership", target: "Membership", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-allRedefinedFeaturesOf_Membership-", name: "", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-allSupertypes_", declaring_metaclass: "Type", name: "allSupertypes", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-allSupertypes_-result", name: "result", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-directionOfExcluding_Feature_Type", declaring_metaclass: "Type", name: "directionOfExcluding", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-directionOfExcluding_Feature_Type-feature", name: "feature", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-directionOfExcluding_Feature_Type-excluded", name: "excluded", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-directionOfExcluding_Feature_Type-", name: "", target: "FeatureDirectionKind", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-directionOf_Feature", declaring_metaclass: "Type", name: "directionOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-directionOf_Feature-feature", name: "feature", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-directionOf_Feature-", name: "", target: "FeatureDirectionKind", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean", declaring_metaclass: "Type", name: "inheritableMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludedNamespaces", name: "excludedNamespaces", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludedTypes", name: "excludedTypes", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-excludeImplied", name: "excludeImplied", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean", declaring_metaclass: "Type", name: "inheritedMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludedNamespaces", name: "excludedNamespaces", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludedTypes", name: "excludedTypes", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-excludeImplied", name: "excludeImplied", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-isCompatibleWith_Type", declaring_metaclass: "Type", name: "isCompatibleWith", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-isCompatibleWith_Type-otherType", name: "otherType", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-multiplicities_", declaring_metaclass: "Type", name: "multiplicities", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-multiplicities_-", name: "", target: "Multiplicity", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean", declaring_metaclass: "Type", name: "nonPrivateMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludedNamespaces", name: "excludedNamespaces", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludedTypes", name: "excludedTypes", target: "Type", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-excludeImplied", name: "excludeImplied", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-removeRedefinedFeatures_Membership", declaring_metaclass: "Type", name: "removeRedefinedFeatures", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-removeRedefinedFeatures_Membership-memberships", name: "memberships", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+        ParameterSpec { id: "Core-Types-Type-removeRedefinedFeatures_Membership-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-specializesFromLibrary_String", declaring_metaclass: "Type", name: "specializesFromLibrary", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-specializesFromLibrary_String-libraryTypeName", name: "libraryTypeName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-specializesFromLibrary_String-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-specializes_Type", declaring_metaclass: "Type", name: "specializes", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-specializes_Type-supertype", name: "supertype", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-specializes_Type-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-supertypes_Boolean", declaring_metaclass: "Type", name: "supertypes", redefines: &[], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-supertypes_Boolean-excludeImplied", name: "excludeImplied", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-supertypes_Boolean-", name: "", target: "Type", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean", declaring_metaclass: "Type", name: "visibleMemberships", redefines: &["Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean"], parameters: &[
+        ParameterSpec { id: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-isRecursive", name: "isRecursive", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-includeAll", name: "includeAll", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Core-Types-Type-visibleMemberships_Namespace_Boolean_Boolean-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Behaviors-ParameterMembership-parameterDirection_", declaring_metaclass: "ParameterMembership", name: "parameterDirection", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Behaviors-ParameterMembership-parameterDirection_-", name: "", target: "FeatureDirectionKind", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-ConstructorExpression-modelLevelEvaluable_Feature", declaring_metaclass: "ConstructorExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-ConstructorExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-ConstructorExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-FeatureChainExpression-sourceTargetFeature_", declaring_metaclass: "FeatureChainExpression", name: "sourceTargetFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-FeatureChainExpression-sourceTargetFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-FeatureReferenceExpression-evaluate_Element", declaring_metaclass: "FeatureReferenceExpression", name: "evaluate", redefines: &["Kernel-Functions-Expression-evaluate_Element"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-FeatureReferenceExpression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-FeatureReferenceExpression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-FeatureReferenceExpression-modelLevelEvaluable_Feature", declaring_metaclass: "FeatureReferenceExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-FeatureReferenceExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-FeatureReferenceExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-InstantiationExpression-instantiatedType_", declaring_metaclass: "InstantiationExpression", name: "instantiatedType", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-InstantiationExpression-instantiatedType_-", name: "", target: "Type", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-InvocationExpression-evaluate_Element", declaring_metaclass: "InvocationExpression", name: "evaluate", redefines: &["Kernel-Functions-Expression-evaluate_Element"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-InvocationExpression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-InvocationExpression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-InvocationExpression-modelLevelEvaluable_Feature", declaring_metaclass: "InvocationExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-InvocationExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-InvocationExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-LiteralExpression-evaluate_Element", declaring_metaclass: "LiteralExpression", name: "evaluate", redefines: &["Kernel-Functions-Expression-evaluate_Element"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-LiteralExpression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-LiteralExpression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature", declaring_metaclass: "LiteralExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-MetadataAccessExpression-evaluate_Element", declaring_metaclass: "MetadataAccessExpression", name: "evaluate", redefines: &["Kernel-Functions-Expression-evaluate_Element"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-MetadataAccessExpression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-MetadataAccessExpression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-MetadataAccessExpression-metaclassFeature_", declaring_metaclass: "MetadataAccessExpression", name: "metaclassFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-MetadataAccessExpression-metaclassFeature_-", name: "", target: "MetadataFeature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature", declaring_metaclass: "MetadataAccessExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-MetadataAccessExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-NullExpression-evaluate_Element", declaring_metaclass: "NullExpression", name: "evaluate", redefines: &["Kernel-Functions-Expression-evaluate_Element"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-NullExpression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-NullExpression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature", declaring_metaclass: "NullExpression", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Expressions-NullExpression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Expressions-OperatorExpression-instantiatedType_", declaring_metaclass: "OperatorExpression", name: "instantiatedType", redefines: &["Kernel-Expressions-InstantiationExpression-instantiatedType_"], parameters: &[
+        ParameterSpec { id: "Kernel-Expressions-OperatorExpression-instantiatedType_-", name: "", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Functions-Expression-checkCondition_Element", declaring_metaclass: "Expression", name: "checkCondition", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Functions-Expression-checkCondition_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Functions-Expression-checkCondition_Element-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Functions-Expression-evaluate_Element", declaring_metaclass: "Expression", name: "evaluate", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Functions-Expression-evaluate_Element-target", name: "target", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Functions-Expression-evaluate_Element-result", name: "result", target: "Element", direction: None, lower: 0, upper: None, ordered: true, unique: false },
+    ] },
+    OperationSpec { id: "Kernel-Functions-Expression-modelLevelEvaluable_Feature", declaring_metaclass: "Expression", name: "modelLevelEvaluable", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Functions-Expression-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Functions-Expression-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Functions-ReturnParameterMembership-parameterDirection_", declaring_metaclass: "ReturnParameterMembership", name: "parameterDirection", redefines: &["Kernel-Behaviors-ParameterMembership-parameterDirection_"], parameters: &[
+        ParameterSpec { id: "Kernel-Functions-ReturnParameterMembership-parameterDirection_-", name: "", target: "FeatureDirectionKind", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Metadata-MetadataFeature-evaluateFeature_Feature", declaring_metaclass: "MetadataFeature", name: "evaluateFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Metadata-MetadataFeature-evaluateFeature_Feature-baseFeature", name: "baseFeature", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Metadata-MetadataFeature-evaluateFeature_Feature-", name: "", target: "Element", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Metadata-MetadataFeature-isSemantic_", declaring_metaclass: "MetadataFeature", name: "isSemantic", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Metadata-MetadataFeature-isSemantic_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Metadata-MetadataFeature-isSyntactic_", declaring_metaclass: "MetadataFeature", name: "isSyntactic", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Metadata-MetadataFeature-isSyntactic_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Metadata-MetadataFeature-syntaxElement_", declaring_metaclass: "MetadataFeature", name: "syntaxElement", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Metadata-MetadataFeature-syntaxElement_-", name: "", target: "Element", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Multiplicities-MultiplicityRange-hasBounds_Integer_UnlimitedNatural", declaring_metaclass: "MultiplicityRange", name: "hasBounds", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Multiplicities-MultiplicityRange-hasBounds_Integer_UnlimitedNatural-lower", name: "lower", target: "Integer", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Multiplicities-MultiplicityRange-hasBounds_Integer_UnlimitedNatural-upper", name: "upper", target: "UnlimitedNatural", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Multiplicities-MultiplicityRange-hasBounds_Integer_UnlimitedNatural-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Multiplicities-MultiplicityRange-valueOf_Expression", declaring_metaclass: "MultiplicityRange", name: "valueOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Multiplicities-MultiplicityRange-valueOf_Expression-bound", name: "bound", target: "Expression", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Multiplicities-MultiplicityRange-valueOf_Expression-", name: "", target: "UnlimitedNatural", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Packages-LibraryPackage-libraryNamespace_", declaring_metaclass: "LibraryPackage", name: "libraryNamespace", redefines: &["Root-Elements-Element-libraryNamespace_"], parameters: &[
+        ParameterSpec { id: "Kernel-Packages-LibraryPackage-libraryNamespace_-", name: "", target: "Namespace", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Packages-Package-importedMemberships_Namespace", declaring_metaclass: "Package", name: "importedMemberships", redefines: &["Root-Namespaces-Namespace-importedMemberships_Namespace"], parameters: &[
+        ParameterSpec { id: "Kernel-Packages-Package-importedMemberships_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Packages-Package-importedMemberships_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Kernel-Packages-Package-includeAsMember_Element", declaring_metaclass: "Package", name: "includeAsMember", redefines: &[], parameters: &[
+        ParameterSpec { id: "Kernel-Packages-Package-includeAsMember_Element-element", name: "element", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Kernel-Packages-Package-includeAsMember_Element-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Element-effectiveName_", declaring_metaclass: "Element", name: "effectiveName", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Elements-Element-effectiveName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Element-effectiveShortName_", declaring_metaclass: "Element", name: "effectiveShortName", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Elements-Element-effectiveShortName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Element-escapedName_", declaring_metaclass: "Element", name: "escapedName", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Elements-Element-escapedName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Element-libraryNamespace_", declaring_metaclass: "Element", name: "libraryNamespace", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Elements-Element-libraryNamespace_-", name: "", target: "Namespace", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Element-path_", declaring_metaclass: "Element", name: "path", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Elements-Element-path_-", name: "", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Relationship-libraryNamespace_", declaring_metaclass: "Relationship", name: "libraryNamespace", redefines: &["Root-Elements-Element-libraryNamespace_"], parameters: &[
+        ParameterSpec { id: "Root-Elements-Relationship-libraryNamespace_-", name: "", target: "Namespace", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Elements-Relationship-path_", declaring_metaclass: "Relationship", name: "path", redefines: &["Root-Elements-Element-path_"], parameters: &[
+        ParameterSpec { id: "Root-Elements-Relationship-path_-", name: "", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Import-importedMemberships_Namespace", declaring_metaclass: "Import", name: "importedMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Import-importedMemberships_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Import-importedMemberships_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Membership-isDistinguishableFrom_Membership", declaring_metaclass: "Membership", name: "isDistinguishableFrom", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Membership-isDistinguishableFrom_Membership-other", name: "other", target: "Membership", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Membership-isDistinguishableFrom_Membership-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-MembershipImport-importedMemberships_Namespace", declaring_metaclass: "MembershipImport", name: "importedMemberships", redefines: &["Root-Namespaces-Import-importedMemberships_Namespace"], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-MembershipImport-importedMemberships_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-MembershipImport-importedMemberships_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-importedMemberships_Namespace", declaring_metaclass: "Namespace", name: "importedMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-importedMemberships_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-importedMemberships_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace", declaring_metaclass: "Namespace", name: "membershipsOfVisibility", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-visibility", name: "visibility", target: "VisibilityKind", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-membershipsOfVisibility_VisibilityKind_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-namesOf_Element", declaring_metaclass: "Namespace", name: "namesOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-namesOf_Element-element", name: "element", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-namesOf_Element-", name: "", target: "String", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-qualificationOf_String", declaring_metaclass: "Namespace", name: "qualificationOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-qualificationOf_String-qualifiedName", name: "qualifiedName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-qualificationOf_String-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-resolveGlobal_String", declaring_metaclass: "Namespace", name: "resolveGlobal", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveGlobal_String-qualifiedName", name: "qualifiedName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveGlobal_String-", name: "", target: "Membership", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-resolveLocal_String", declaring_metaclass: "Namespace", name: "resolveLocal", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveLocal_String-name", name: "name", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveLocal_String-", name: "", target: "Membership", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-resolveVisible_String", declaring_metaclass: "Namespace", name: "resolveVisible", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveVisible_String-name", name: "name", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolveVisible_String-", name: "", target: "Membership", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-resolve_String", declaring_metaclass: "Namespace", name: "resolve", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolve_String-qualifiedName", name: "qualifiedName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-resolve_String-", name: "", target: "Membership", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-unqualifiedNameOf_String", declaring_metaclass: "Namespace", name: "unqualifiedNameOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-unqualifiedNameOf_String-qualifiedName", name: "qualifiedName", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-unqualifiedNameOf_String-", name: "", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-visibilityOf_Membership", declaring_metaclass: "Namespace", name: "visibilityOf", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibilityOf_Membership-mem", name: "mem", target: "Membership", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibilityOf_Membership-", name: "", target: "VisibilityKind", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean", declaring_metaclass: "Namespace", name: "visibleMemberships", redefines: &[], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-isRecursive", name: "isRecursive", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-includeAll", name: "includeAll", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-NamespaceImport-importedMemberships_Namespace", declaring_metaclass: "NamespaceImport", name: "importedMemberships", redefines: &["Root-Namespaces-Import-importedMemberships_Namespace"], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-NamespaceImport-importedMemberships_Namespace-excluded", name: "excluded", target: "Namespace", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Root-Namespaces-NamespaceImport-importedMemberships_Namespace-", name: "", target: "Membership", direction: None, lower: 0, upper: None, ordered: true, unique: true },
+    ] },
+    OperationSpec { id: "Root-Namespaces-OwningMembership-path_", declaring_metaclass: "OwningMembership", name: "path", redefines: &["Root-Elements-Relationship-path_"], parameters: &[
+        ParameterSpec { id: "Root-Namespaces-OwningMembership-path_-", name: "", target: "String", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-AcceptActionUsage-isTriggerAction_", declaring_metaclass: "AcceptActionUsage", name: "isTriggerAction", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-AcceptActionUsage-isTriggerAction_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-ActionUsage-argument_Integer", declaring_metaclass: "ActionUsage", name: "argument", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-ActionUsage-argument_Integer-i", name: "i", target: "Integer", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Actions-ActionUsage-argument_Integer-", name: "", target: "Expression", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-ActionUsage-inputParameter_Integer", declaring_metaclass: "ActionUsage", name: "inputParameter", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-ActionUsage-inputParameter_Integer-i", name: "i", target: "Integer", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Actions-ActionUsage-inputParameter_Integer-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-ActionUsage-inputParameters_", declaring_metaclass: "ActionUsage", name: "inputParameters", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-ActionUsage-inputParameters_-", name: "", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-ActionUsage-isSubactionUsage_", declaring_metaclass: "ActionUsage", name: "isSubactionUsage", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-ActionUsage-isSubactionUsage_-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-ControlNode-multiplicityHasBounds_Multiplicity_Integer_UnlimitedNatural", declaring_metaclass: "ControlNode", name: "multiplicityHasBounds", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Actions-ControlNode-multiplicityHasBounds_Multiplicity_Integer_UnlimitedNatural-mult", name: "mult", target: "Multiplicity", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Actions-ControlNode-multiplicityHasBounds_Multiplicity_Integer_UnlimitedNatural-lower", name: "lower", target: "Integer", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Actions-ControlNode-multiplicityHasBounds_Multiplicity_Integer_UnlimitedNatural-upper", name: "upper", target: "UnlimitedNatural", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Actions-ControlNode-multiplicityHasBounds_Multiplicity_Integer_UnlimitedNatural-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-PerformActionUsage-namingFeature_", declaring_metaclass: "PerformActionUsage", name: "namingFeature", redefines: &["Systems-DefinitionAndUsage-Usage-namingFeature_"], parameters: &[
+        ParameterSpec { id: "Systems-Actions-PerformActionUsage-namingFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Actions-TriggerInvocationExpression-instantiatedType_", declaring_metaclass: "TriggerInvocationExpression", name: "instantiatedType", redefines: &["Kernel-Expressions-InstantiationExpression-instantiatedType_"], parameters: &[
+        ParameterSpec { id: "Systems-Actions-TriggerInvocationExpression-instantiatedType_-", name: "", target: "Type", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature", declaring_metaclass: "CalculationUsage", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Calculations-CalculationUsage-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature", declaring_metaclass: "ConstraintUsage", name: "modelLevelEvaluable", redefines: &["Kernel-Functions-Expression-modelLevelEvaluable_Feature"], parameters: &[
+        ParameterSpec { id: "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature-visited", name: "visited", target: "Feature", direction: None, lower: 0, upper: None, ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Constraints-ConstraintUsage-modelLevelEvaluable_Feature-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Constraints-ConstraintUsage-namingFeature_", declaring_metaclass: "ConstraintUsage", name: "namingFeature", redefines: &["Systems-DefinitionAndUsage-Usage-namingFeature_"], parameters: &[
+        ParameterSpec { id: "Systems-Constraints-ConstraintUsage-namingFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-DefinitionAndUsage-ReferenceUsage-namingFeature_", declaring_metaclass: "ReferenceUsage", name: "namingFeature", redefines: &["Systems-DefinitionAndUsage-Usage-namingFeature_"], parameters: &[
+        ParameterSpec { id: "Systems-DefinitionAndUsage-ReferenceUsage-namingFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-DefinitionAndUsage-Usage-namingFeature_", declaring_metaclass: "Usage", name: "namingFeature", redefines: &["Core-Features-Feature-namingFeature_"], parameters: &[
+        ParameterSpec { id: "Systems-DefinitionAndUsage-Usage-namingFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-DefinitionAndUsage-Usage-referencedFeatureTarget_", declaring_metaclass: "Usage", name: "referencedFeatureTarget", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-DefinitionAndUsage-Usage-referencedFeatureTarget_-", name: "", target: "Feature", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Ports-ConjugatedPortDefinition-effectiveName_", declaring_metaclass: "ConjugatedPortDefinition", name: "effectiveName", redefines: &["Root-Elements-Element-effectiveName_"], parameters: &[
+        ParameterSpec { id: "Systems-Ports-ConjugatedPortDefinition-effectiveName_-", name: "", target: "String", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-States-StateUsage-isSubstateUsage_Boolean", declaring_metaclass: "StateUsage", name: "isSubstateUsage", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-States-StateUsage-isSubstateUsage_Boolean-isParallel", name: "isParallel", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-States-StateUsage-isSubstateUsage_Boolean-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-States-TransitionUsage-sourceFeature_", declaring_metaclass: "TransitionUsage", name: "sourceFeature", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-States-TransitionUsage-sourceFeature_-", name: "", target: "Feature", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-States-TransitionUsage-triggerPayloadParameter_", declaring_metaclass: "TransitionUsage", name: "triggerPayloadParameter", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-States-TransitionUsage-triggerPayloadParameter_-", name: "", target: "ReferenceUsage", direction: None, lower: 0, upper: Some(1), ordered: false, unique: true },
+    ] },
+    OperationSpec { id: "Systems-Views-ViewUsage-includeAsExposed_Element", declaring_metaclass: "ViewUsage", name: "includeAsExposed", redefines: &[], parameters: &[
+        ParameterSpec { id: "Systems-Views-ViewUsage-includeAsExposed_Element-element", name: "element", target: "Element", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+        ParameterSpec { id: "Systems-Views-ViewUsage-includeAsExposed_Element-", name: "", target: "Boolean", direction: None, lower: 1, upper: Some(1), ordered: false, unique: true },
+    ] },
+];
diff --git a/crates/sysmlv2-model/src/prepared.rs b/crates/sysmlv2-model/src/prepared.rs
index e4426a7..4c3d3dc 100644
--- a/crates/sysmlv2-model/src/prepared.rs
+++ b/crates/sysmlv2-model/src/prepared.rs
@@ -113,7 +113,22 @@ impl LibraryUnits {
 // 8: the integrity trailer is the same fixed hash the resolution cache
 // uses, so a snapshot outlives a change of the standard library's
 // hasher.
-const MAGIC: &[u8] = b"SYSML-PREPARED-8\n";
+// 9: aliases retain their Membership relationship and lookup outcomes carry
+// the selected alias Membership through re-exports.
+// 10: preserve nonconvergent recorded-lookup qualification.
+// 12: calculations no longer keep their declared input names apart.
+// 13: scopes carry the spellings of every redefinition their owner writes.
+// 14: retain those complete QualifiedNames, including qualification and source spans.
+const MAGIC: &[u8] = b"SYSML-PREPARED-14\n";
+
+/// The records a snapshot carries, in order.
+#[derive(Deserialize)]
+struct Wire {
+    units: Arc<LibraryUnits>,
+    builder: Builder,
+    facts: Arc<crate::check::facts::Facts>,
+    root_names: std::collections::HashSet<String>,
+}
 /// A resolved library with source text and static-analysis facts. Loaded syntax
 /// trees are reconstructed on demand. Models share immutable element and scope
 /// prefixes; user additions and resolver caches remain private.
@@ -123,6 +138,15 @@ pub struct PreparedLibrary {
     pub(crate) builder: Builder,
     facts: Arc<crate::check::facts::Facts>,
     pub(crate) root_names: std::collections::HashSet<String>,
+    /// The resolution recording the library was prepared with, replayed by
+    /// builds that must resolve the library together with user units. Kept
+    /// in memory only; a decoded snapshot has none.
+    #[serde(skip)]
+    pub(crate) recording: Option<Arc<crate::libcache::LibraryCache>>,
+    /// The encoded recording a decoded handle keeps for joint builds, which
+    /// decode it on first need; installing arms the model's lazy slot with it.
+    #[serde(skip)]
+    pub(crate) lazy_recording: Option<Arc<[u8]>>,
 }
 impl PreparedLibrary {
     /// Original unit names and text in library order, without loading syntax trees.
@@ -141,6 +165,11 @@ impl PreparedLibrary {
             .map(|s| (s.name.as_str(), s.source.as_ref()))
     }
 
+    /// Authored graph contract captured by this prepared library.
+    pub fn graph_format(&self) -> crate::model::GraphFormat {
+        self.builder.graph_format
+    }
+
     /// Prepare a library-only model. User units are refused.
     pub fn build(model: &Model) -> io::Result<Self> {
         if (0..model.unit_count()).any(|i| !model.is_library_unit(i)) {
@@ -152,6 +181,9 @@ impl PreparedLibrary {
         let mut builder = Builder::default();
         builder.build_model(model);
         let mut resolved = crate::json::ResolvedModel::from_builder(builder, model);
+        // Keep logical semantic readiness for warming, but never freeze a
+        // published semantic suffix into the source-only prepared prefix.
+        resolved.b.suppress_semantic_publication();
         resolved.prepare_quantity_memo();
         let mut builder = resolved.b;
         let mut facts = builder.prepare_facts();
@@ -166,8 +198,30 @@ impl PreparedLibrary {
             builder,
             facts,
             root_names: crate::json::top_level_names(model.units().iter()),
+            recording: model.library_recording(),
+            lazy_recording: None,
         })
     }
+
+    /// The resolution recording a source-prepared handle keeps, encoded
+    /// ([`crate::libcache::LibraryCache::to_bytes`]); `None` for a decoded handle.
+    #[must_use]
+    pub fn recording_bytes(&self) -> Option<Vec<u8>> {
+        self.recording
+            .as_ref()
+            .map(|recording| recording.to_bytes())
+    }
+
+    /// Keep an encoded resolution recording ([`crate::libcache::LibraryCache::to_bytes`])
+    /// for the builds that cannot reuse the prepared graph; a handle that
+    /// already holds a decoded recording ignores it. Nothing is decoded here.
+    #[must_use]
+    pub fn with_lazy_recording(mut self, bytes: Vec<u8>) -> Self {
+        if self.recording.is_none() {
+            self.lazy_recording = Some(Arc::from(bytes));
+        }
+        self
+    }
     /// Attach this library to an empty model, without parsing or graph lowering.
     pub fn install(self: Arc<Self>, model: &mut Model) -> io::Result<()> {
         model.install_prepared(self)
@@ -190,19 +244,61 @@ impl PreparedLibrary {
         if saved_key != key || checksum(payload) != sum {
             return None;
         }
-        #[derive(Deserialize)]
-        struct Wire {
-            units: Arc<LibraryUnits>,
-            builder: Builder,
-            facts: Arc<crate::check::facts::Facts>,
-            root_names: std::collections::HashSet<String>,
+        Self::from_wire(crate::cache_codec::decode(payload).ok()?)
+    }
+
+    /// [`Self::from_bytes`] over a snapshot the caller feeds in chunks: `fill`
+    /// copies the next bytes of the `len`-byte snapshot into the buffer it
+    /// is given and answers how many (0 once exhausted). Only a window of the
+    /// snapshot is ever held here, so a host that already holds the bytes
+    /// elsewhere (a browser's heap) pays no second copy of them. The
+    /// checksum is verified once the payload has been consumed whole, so a
+    /// corrupt snapshot costs a decode before it is refused; a stale or
+    /// truncated one is refused the same as from `from_bytes`.
+    pub fn from_chunks<F: FnMut(&mut [u8]) -> usize>(
+        len: usize,
+        fill: F,
+        key: u64,
+    ) -> Option<Self> {
+        if len as u64 > MAX_BYTES {
+            return None;
+        }
+        let build = crate::libcache::TOOLKIT_BUILD.as_bytes();
+        let mut src = crate::cache_codec::Chunked::new(len, 64 * 1024, fill);
+        {
+            use crate::cache_codec::Source;
+            if src.take(MAGIC.len()).ok()? != MAGIC
+                || src.take(build.len()).ok()? != build
+                || src.take(1).ok()? != b"\n"
+            {
+                return None;
+            }
+            let saved_key = u64::from_le_bytes(src.take(8).ok()?.try_into().ok()?);
+            if saved_key != key {
+                return None;
+            }
+        }
+        let sum = {
+            use crate::cache_codec::Source;
+            u64::from_le_bytes(src.take(8).ok()?.try_into().ok()?)
+        };
+        src.reset_checksum();
+        let wire: Wire = crate::cache_codec::decode_from(&mut src).ok()?;
+        if src.checksum() != sum {
+            return None;
         }
-        let wire: Wire = crate::cache_codec::decode(payload).ok()?;
+        Self::from_wire(wire)
+    }
+
+    /// The decoded records into a handle, validated and frozen.
+    fn from_wire(wire: Wire) -> Option<Self> {
         let mut result = Self {
             units: wire.units,
             builder: wire.builder,
             facts: wire.facts,
             root_names: wire.root_names,
+            recording: None,
+            lazy_recording: None,
         };
         result.builder.reset_lookup_caches();
         if result.units.sources.iter().any(|u| !u.is_library)
@@ -293,9 +389,10 @@ pub fn load_library_with_cache(model: &mut Model, dir: &Path) -> io::Result<Libr
 /// [`load_library_with_cache`] with an explicit content key and resolution
 /// cache path. The complete snapshot lives beside that path under the
 /// `prepared` extension. A prepared model also keeps the resolution recording
-/// reachable, unread, for builds that must resolve jointly after all: those
-/// replay it instead of resolving the whole library cold. A snapshot miss
-/// records that recording while preparing.
+/// reachable for builds that must resolve jointly after all: those replay it
+/// instead of resolving the whole library cold. A snapshot miss records that
+/// recording while preparing, and the handle then keeps it in memory; a
+/// decoded handle leaves it on disk, unread until such a build.
 pub(crate) fn load_library_with_cache_at(
     model: &mut Model,
     dir: &Path,
@@ -306,7 +403,16 @@ pub(crate) fn load_library_with_cache_at(
         collections::HashMap,
         sync::{Mutex, OnceLock, Weak},
     };
-    static SHARED: OnceLock<Mutex<HashMap<u64, Weak<PreparedLibrary>>>> = OnceLock::new();
+    type SharedLibraries = Mutex<HashMap<(u64, u8), Weak<PreparedLibrary>>>;
+    static SHARED: OnceLock<SharedLibraries> = OnceLock::new();
+    let cache = cache.map(|(key, path)| {
+        let path = if model.graph_format() == crate::model::GraphFormat::CanonicalV3 {
+            path.with_extension("v3.cache")
+        } else {
+            path
+        };
+        (key, path)
+    });
     let mut warnings = Vec::new();
     if model.unit_count() == 0 {
         if let Some((key, path)) = cache {
@@ -314,15 +420,24 @@ pub(crate) fn load_library_with_cache_at(
             let cached = {
                 let mut entries = shared.lock().unwrap_or_else(|e| e.into_inner());
                 entries.retain(|_, value| value.strong_count() > 0);
-                entries.get(&key).and_then(Weak::upgrade)
+                entries
+                    .get(&(key, model.graph_format().version()))
+                    .and_then(Weak::upgrade)
             };
             if let Some(library) = cached {
+                // A handle prepared from source in this process keeps its
+                // recording in memory, so the cache file is left unread.
+                let recorded = library.recording.is_some();
                 library.install(model)?;
-                model.set_lazy_library_cache(path);
+                if !recorded {
+                    model.set_lazy_library_cache(path);
+                }
                 return Ok(LibraryLoad::default());
             }
             let snapshot = path.with_extension("prepared");
-            let library = if let Some(library) = PreparedLibrary::load(&snapshot, key) {
+            let library = if let Some(library) = PreparedLibrary::load(&snapshot, key)
+                .filter(|library| library.graph_format() == model.graph_format())
+            {
                 let library = Arc::new(library);
                 library.clone().install(model)?;
                 library
@@ -341,11 +456,13 @@ pub(crate) fn load_library_with_cache_at(
                 }
                 library
             };
-            model.set_lazy_library_cache(path);
-            shared
-                .lock()
-                .unwrap_or_else(|e| e.into_inner())
-                .insert(key, Arc::downgrade(&library));
+            if library.recording.is_none() {
+                model.set_lazy_library_cache(path);
+            }
+            shared.lock().unwrap_or_else(|e| e.into_inner()).insert(
+                (key, model.graph_format().version()),
+                Arc::downgrade(&library),
+            );
             return Ok(LibraryLoad {
                 recording_path: None,
                 warnings,
@@ -371,6 +488,191 @@ pub(crate) fn load_library_with_cache_at(
 mod tests {
     use super::*;
     use crate::json::ResolvedModel;
+    /// A library prepared while recording, or with a snapshot the preparing
+    /// build rejects as stale, keeps a recording; a build that must resolve
+    /// the library together with user units arms it, validates it and
+    /// replays it, and equals a cold build in both graphs. A decoded handle
+    /// has none, a lazy cache slot the loader set is left alone, and a model
+    /// that gains a library unit after installing builds without the handle.
+    #[test]
+    fn joint_builds_replay_the_recording_the_library_was_prepared_with() {
+        let library = "package L { part def A; part def B :> A; }";
+        // `Parts` is a root name the library looked up and missed.
+        let user = "package Parts; package U { part a : L::A; part b : L::B; }";
+        let graphs = |model: &Model| {
+            (
+                crate::json::model_to_compact_json(model),
+                crate::json::library_to_compact_json(model),
+            )
+        };
+        let mut cold = Model::new();
+        cold.add_library_source("lib.sysml", library);
+        cold.add_source("user.sysml", user);
+        let cold = graphs(&cold);
+        // A snapshot of another library decodes but fails the build's
+        // validation, so the preparing build records in its place.
+        let mut other = Model::new();
+        other.add_library_source("lib.sysml", "package L { part def A; }");
+        other.record_library_cache();
+        let _ = ResolvedModel::build(&other);
+        let stale = other.take_recorded_library_cache().unwrap();
+        let mut prepared = None;
+        for (label, snapshot) in [
+            ("recording while preparing", None),
+            ("rejecting a stale snapshot", Some(stale)),
+        ] {
+            let mut base = Model::new();
+            base.add_library_source("lib.sysml", library);
+            match snapshot {
+                Some(cache) => base.set_library_cache(cache),
+                None => base.record_library_cache(),
+            }
+            let library = base.prepare_library().unwrap();
+            assert!(library.recording.is_some(), "{label}: preparing recorded");
+            let mut warm = Model::new();
+            Arc::clone(&library).install(&mut warm).unwrap();
+            assert_eq!(
+                warm.lib_cache_kind(),
+                "off",
+                "{label}: installing arms nothing"
+            );
+            warm.add_source("user.sysml", user);
+            let r = ResolvedModel::build(&warm);
+            assert!(r.b.library_facts.is_none(), "{label}: resolved jointly");
+            assert_eq!(
+                warm.lib_cache_kind(),
+                "use",
+                "{label}: the joint build armed the recording and it validated"
+            );
+            assert_eq!(
+                graphs(&warm),
+                cold,
+                "{label}: both graphs equal a cold build's"
+            );
+            prepared = Some(library);
+        }
+        let prepared = prepared.unwrap();
+        // A decoded prepared snapshot carries no recording; its joint builds
+        // resolve the library cold.
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(9).unwrap(), 9).unwrap());
+        assert!(decoded.recording.is_none());
+        let mut fresh = Model::new();
+        decoded.install(&mut fresh).unwrap();
+        fresh.add_source("user.sysml", user);
+        assert!(ResolvedModel::build(&fresh).b.library_facts.is_none());
+        assert_eq!(fresh.lib_cache_kind(), "off", "nothing to arm");
+        assert_eq!(graphs(&fresh), cold);
+        // The same snapshot fed in chunks decodes to the same library; a
+        // window narrower than any item still works, and the refusals match.
+        {
+            let bytes = prepared.to_bytes(9).unwrap();
+            fn feed(bytes: &[u8], step: usize) -> impl FnMut(&mut [u8]) -> usize + '_ {
+                let mut at = 0;
+                move |buf: &mut [u8]| {
+                    let n = buf.len().min(step).min(bytes.len() - at);
+                    buf[..n].copy_from_slice(&bytes[at..at + n]);
+                    at += n;
+                    n
+                }
+            }
+            for step in [1, 1000, usize::MAX] {
+                let chunked = Arc::new(
+                    PreparedLibrary::from_chunks(bytes.len(), feed(&bytes, step), 9).unwrap(),
+                );
+                let mut m = Model::new();
+                chunked.install(&mut m).unwrap();
+                m.add_source("user.sysml", user);
+                assert_eq!(graphs(&m), cold, "step {step}");
+            }
+            assert!(
+                PreparedLibrary::from_chunks(bytes.len(), feed(&bytes, 1000), 8).is_none(),
+                "other key"
+            );
+            assert!(
+                PreparedLibrary::from_chunks(
+                    bytes.len() - 1,
+                    feed(&bytes[..bytes.len() - 1], 1000),
+                    9
+                )
+                .is_none(),
+                "truncated"
+            );
+            let mut corrupt = bytes.clone();
+            let last = corrupt.len() - 1;
+            corrupt[last] ^= 0xff;
+            assert!(
+                PreparedLibrary::from_chunks(corrupt.len(), feed(&corrupt, 1000), 9).is_none(),
+                "corrupt"
+            );
+        }
+        // A decoded handle holding the encoded recording arms the lazy slot
+        // on install; the joint build decodes and replays it, and a prepared
+        // build never touches it.
+        let recording_bytes = prepared.recording.as_ref().unwrap().to_bytes();
+        let held = Arc::new(
+            PreparedLibrary::from_bytes(&prepared.to_bytes(9).unwrap(), 9)
+                .unwrap()
+                .with_lazy_recording(recording_bytes),
+        );
+        assert!(held.recording.is_none() && held.lazy_recording.is_some());
+        let mut plain = Model::new();
+        held.clone().install(&mut plain).unwrap();
+        assert_eq!(
+            plain.lib_cache_kind(),
+            "lazy",
+            "installing arms the held recording"
+        );
+        plain.add_source("user.sysml", "package U { part a : L::A; }");
+        assert!(
+            ResolvedModel::build(&plain).b.library_facts.is_some(),
+            "prepared build"
+        );
+        assert_eq!(
+            plain.lib_cache_kind(),
+            "lazy",
+            "a prepared build leaves it encoded"
+        );
+        let mut joint = Model::new();
+        held.install(&mut joint).unwrap();
+        joint.add_source("user.sysml", user);
+        assert!(
+            ResolvedModel::build(&joint).b.library_facts.is_none(),
+            "resolved jointly"
+        );
+        assert_eq!(
+            joint.lib_cache_kind(),
+            "use",
+            "the joint build decoded and replayed it"
+        );
+        assert_eq!(graphs(&joint), cold);
+        // A lazy cache slot the directory loader set stays in place.
+        let mut lazy = Model::new();
+        Arc::clone(&prepared).install(&mut lazy).unwrap();
+        lazy.set_lazy_library_cache(std::path::PathBuf::from("/nonexistent/stdlib.libcache"));
+        lazy.add_source("user.sysml", user);
+        assert!(ResolvedModel::build(&lazy).b.library_facts.is_none());
+        assert_eq!(
+            lazy.lib_cache_kind(),
+            "off",
+            "the lazy slot, not the recording, was consulted"
+        );
+        assert_eq!(graphs(&lazy), cold);
+        // A library unit added after installing drops the prepared library
+        // and with it the recording: no sealed-id lowering to throw away.
+        let more = "package More { part def C; }";
+        let mut grown = Model::new();
+        prepared.install(&mut grown).unwrap();
+        grown.add_library_source("more.sysml", more);
+        grown.add_source("user.sysml", user);
+        assert!(ResolvedModel::build(&grown).b.library_facts.is_none());
+        assert_eq!(grown.lib_cache_kind(), "off");
+        let mut both = Model::new();
+        both.add_library_source("lib.sysml", library);
+        both.add_library_source("more.sysml", more);
+        both.add_source("user.sysml", user);
+        assert_eq!(graphs(&grown), graphs(&both));
+    }
     #[test]
     fn disk_syntax_is_lazy_exact_and_shared_without_changing_unit_indices() {
         let sources = [
@@ -551,6 +853,9 @@ mod tests {
             "package U { part b : L::B; } private import U::*; part x : b;",
             "package Q { part def Y; part def Parts; } private import Q::Y; package U { part a : L::A; }",
             "package Q { part def Y { part def Parts; } } private import Q::*; package U { part a : L::A; }",
+            // Imports the imported namespace does not re-export.
+            "package Q { private import L::*; part def Y; } private import Q::*; package U { part a : L::A; }",
+            "package Q { protected import L::*; } private import Q::**; package U { part a : L::A; }",
         ] {
             same_graphs(&complete, ("user.sysml", source), true);
         }
@@ -558,6 +863,7 @@ mod tests {
             // A user namespace re-exporting through its own import, an
             // alias target, and a recursive import reaching a probed name.
             "package Q { public import L::*; } private import Q::*; package U { part a : A; }",
+            "package Q { private import L::*; } private import all Q::*; package U { part a : A; }",
             "alias Q for L; private import Q::*; package U { part a : A; }",
             "package Q { part def Y { part def Parts; } } private import Q::**; package U { part a : L::A; }",
             "package Q { part def Parts; } private import Q::*; package U { part a : L::A; }",
@@ -643,6 +949,42 @@ mod tests {
         std::fs::remove_dir_all(&root).ok();
     }
 
+    #[test]
+    fn directory_cache_separates_graph_formats_in_memory_and_on_disk() {
+        use crate::model::GraphFormat;
+        let root =
+            std::env::temp_dir().join(format!("sysml-graph-format-{}", uuid::Uuid::new_v4()));
+        let dir = root.join("library");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(
+            dir.join("L.kerml"),
+            "standard library package L { feature x = if true ? 1 else 2; }",
+        )
+        .unwrap();
+        let path = root.join("stdlib.libcache");
+        // Keep both models alive to exercise the process-wide shared cache.
+        let mut legacy = Model::new();
+        load_library_with_cache_at(&mut legacy, &dir, Some((91, path.clone()))).unwrap();
+        let mut canonical = Model::with_graph_format(GraphFormat::CanonicalV3);
+        load_library_with_cache_at(&mut canonical, &dir, Some((91, path.clone()))).unwrap();
+        let expected = crate::json::library_to_compact_json(&canonical);
+        assert_ne!(crate::json::library_to_compact_json(&legacy), expected);
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut shared = Model::with_graph_format(format);
+            load_library_with_cache_at(&mut shared, &dir, Some((91, path.clone()))).unwrap();
+            assert_eq!(shared.graph_format(), format);
+        }
+        drop(legacy);
+        drop(canonical);
+        let mut disk = Model::with_graph_format(GraphFormat::CanonicalV3);
+        load_library_with_cache_at(&mut disk, &dir, Some((91, path.clone()))).unwrap();
+        assert_eq!(disk.loaded_library_unit_count(), 0);
+        assert_eq!(crate::json::library_to_compact_json(&disk), expected);
+        assert!(path.with_extension("prepared").exists());
+        assert!(path.with_extension("v3.prepared").exists());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn fallback_builds_replay_the_recorded_resolution_cache() {
         let root =
@@ -666,7 +1008,19 @@ mod tests {
             "a snapshot miss records the resolution cache"
         );
         assert!(recording.with_extension("prepared").exists());
-        assert_eq!(cold.lib_cache_kind(), "lazy");
+        // The handle prepared here keeps the recording in memory, so this
+        // process leaves the file unread: a joint build arms the handle's.
+        assert_eq!(cold.lib_cache_kind(), "off");
+        cold.add_source(
+            "user.sysml",
+            "private import Other::*; package U { part a : L::A; }",
+        );
+        assert!(ResolvedModel::build(&cold).b.library_facts.is_none());
+        assert_eq!(
+            cold.lib_cache_kind(),
+            "use",
+            "the fallback replays the recording the handle keeps"
+        );
         drop(cold);
         let mut warm = Model::new();
         load_library_with_cache_at(&mut warm, &dir, cache()).unwrap();
diff --git a/crates/sysmlv2-model/src/properties.rs b/crates/sysmlv2-model/src/properties.rs
index 7631b18..e9f0cbe 100644
--- a/crates/sysmlv2-model/src/properties.rs
+++ b/crates/sysmlv2-model/src/properties.rs
@@ -42,9 +42,11 @@ impl<'de> Deserialize<'de> for Key {
     }
 }
 fn key(name: &str) -> Key {
-    static KEYS: OnceLock<HashMap<&'static str, Arc<str>>> = OnceLock::new();
+    type Keys =
+        HashMap<&'static str, Arc<str>, std::hash::BuildHasherDefault<crate::layered::IdHasher>>;
+    static KEYS: OnceLock<Keys> = OnceLock::new();
     let keys = KEYS.get_or_init(|| {
-        let mut keys = HashMap::new();
+        let mut keys = Keys::default();
         for (_, props) in crate::schema_props::METACLASS_PROPS {
             for &(name, _) in *props {
                 keys.entry(name).or_insert_with(|| Arc::from(name));
@@ -111,13 +113,68 @@ impl PartialEq for Atom {
         }
     }
 }
+impl From<Value> for Atom {
+    fn from(v: Value) -> Self {
+        Self::from_json(v)
+    }
+}
+/// The spellings of the enumeration-valued properties (visibility,
+/// direction, the usage kinds) and the operators the builder writes most:
+/// one shared string each, instead of a copy per element.
+fn interned_string(s: &str) -> Option<Arc<str>> {
+    const WORDS: &[&str] = &[
+        "public",
+        "private",
+        "protected",
+        "in",
+        "out",
+        "inout",
+        "requirement",
+        "assumption",
+        "objective",
+        "subject",
+        "actor",
+        "stakeholder",
+        ".",
+        "==",
+        "===",
+        "+",
+        "-",
+        "*",
+        "/",
+        "and",
+        "or",
+        "not",
+        "istype",
+        "hastype",
+        "@",
+        "@@",
+        "as",
+        "meta",
+        "if",
+        "[",
+        "#",
+        "..",
+    ];
+    static INTERNED: OnceLock<Vec<Arc<str>>> = OnceLock::new();
+    let i = WORDS.iter().position(|w| *w == s)?;
+    let interned = INTERNED.get_or_init(|| WORDS.iter().map(|w| Arc::from(*w)).collect());
+    Some(Arc::clone(&interned[i]))
+}
 impl Atom {
+    /// A reference to the element with identity `id`.
+    pub(crate) fn reference(id: Uuid) -> Self {
+        Self::Reference(Reference {
+            id,
+            spelling: OnceLock::new(),
+        })
+    }
     pub fn from_json(v: Value) -> Self {
         match v {
             Value::Null => Self::Null,
             Value::Bool(v) => Self::Bool(v),
             Value::Number(v) => Self::Number(v),
-            Value::String(v) => Self::String(v.into()),
+            Value::String(v) => Self::String(interned_string(&v).unwrap_or_else(|| v.into())),
             Value::Array(v) => Self::Array(v.into_iter().map(Self::from_json).collect()),
             Value::Object(v) => {
                 // A lone `@id` is an element reference. Its spelling is not
@@ -252,9 +309,10 @@ impl Properties {
             .ok()
             .map(|i| &self.entries[i].1)
     }
-    pub fn insert(&mut self, k: &str, v: Value) {
+    pub fn insert(&mut self, k: &str, v: impl Into<Atom>) {
+        let v = v.into();
         if let Some(bit) = flag(k) {
-            if let Value::Bool(b) = v {
+            if let Atom::Bool(b) = v {
                 self.present |= bit;
                 if b {
                     self.flags |= bit;
@@ -269,13 +327,40 @@ impl Properties {
             self.present &= !bit;
             self.flags &= !bit;
         }
-        let value = (key(k), Atom::from_json(v));
+        let value = (key(k), v);
+        match self.entries.binary_search_by(|(key, _)| key.name().cmp(k)) {
+            Ok(i) => self.entries.make_mut()[i] = value,
+            Err(i) => self.entries.make_mut().insert(i, value),
+        }
+    }
+    /// Preserve malformed scalar input as literal data. A reference-shaped
+    /// object in a Boolean property is not a semantic reference to remap.
+    pub(crate) fn insert_payload_flag(&mut self, k: &str, value: Value) {
+        fn literal(value: Value) -> Atom {
+            match value {
+                Value::Object(v) => {
+                    Atom::Object(v.into_iter().map(|(k, v)| (key(&k), literal(v))).collect())
+                }
+                Value::Array(v) => Atom::Array(v.into_iter().map(literal).collect()),
+                v => Atom::from_json(v),
+            }
+        }
+        if value.is_boolean() {
+            self.insert(k, value);
+            return;
+        }
+        if let Some(bit) = flag(k) {
+            self.present &= !bit;
+            self.flags &= !bit;
+        }
+        let value = (key(k), literal(value));
         match self.entries.binary_search_by(|(key, _)| key.name().cmp(k)) {
             Ok(i) => self.entries.make_mut()[i] = value,
             Err(i) => self.entries.make_mut().insert(i, value),
         }
     }
-    pub fn append(&mut self, k: &str, value: Value) {
+
+    pub fn append(&mut self, k: &str, value: impl Into<Atom>) {
         let i = match self.entries.binary_search_by(|(key, _)| key.name().cmp(k)) {
             Ok(i) => i,
             Err(i) => {
@@ -286,7 +371,7 @@ impl Properties {
             }
         };
         if let Atom::Array(a) = &mut self.entries.make_mut()[i].1 {
-            a.push(Atom::from_json(value));
+            a.push(value.into());
         }
     }
     pub fn references(&self) -> impl Iterator<Item = (Key, Uuid)> + '_ {
diff --git a/crates/sysmlv2-model/src/quantity.rs b/crates/sysmlv2-model/src/quantity.rs
index 301e245..991ce83 100644
--- a/crates/sysmlv2-model/src/quantity.rs
+++ b/crates/sysmlv2-model/src/quantity.rs
@@ -195,7 +195,18 @@ impl ResolvedModel {
         value
     }
     fn quantity_dims_of_type_uncached(&mut self, ty: ElementRef) -> Option<QuantityDims> {
-        let (mref, _) = self.member_of(ty, &simple_qn("mRef"))?;
+        let mref = match self.member_of(ty, &simple_qn("mRef")) {
+            Some((mref, _)) => mref,
+            // A feature of two quantity types at once — a parameter that
+            // redefines one feature by name and another by position —
+            // inherits two `mRef`s, and the lookup answers neither. The
+            // one its written heritage reaches is the quantity it spells.
+            None => [false, true].into_iter().find_map(|implied| {
+                self.effective_features(ty, implied)
+                    .into_iter()
+                    .find(|&f| self.b.id_name(f.0).as_deref() == Some("mRef"))
+            })?,
+        };
         self.typings(mref)
             .into_iter()
             .find_map(|def| self.unit_def_dims(def))
@@ -297,10 +308,16 @@ impl ResolvedModel {
     fn power_factor(&mut self, f: ElementRef) -> Option<(usize, i64)> {
         let (qm, _) = self.member_of(f, &simple_qn("quantity"))?;
         let (qscope, qexpr) = self.value_expr(qm)?;
-        let quantity = self.expr_element(qscope, &qexpr)?;
+        let origin = self.b.set_identity_origin(qm.0);
+        let quantity = self.expr_element(qscope, &qexpr);
+        self.b.identity_origin_unit = origin;
+        let quantity = quantity?;
         let (em, _) = self.member_of(f, &simple_qn("exponent"))?;
         let (escope, eexpr) = self.value_expr(em)?;
-        let exp = match self.evaluate_in(escope, &eexpr).ok()? {
+        let origin = self.b.set_identity_origin(em.0);
+        let value = self.evaluate_in(escope, &eexpr);
+        self.b.identity_origin_unit = origin;
+        let exp = match value.ok()? {
             Value::Integer(i) => i64::try_from(i).ok()?,
             // A literal `2.0` canonicalizes to the integer arm; the double
             // arm covers a computed approximate integer.
@@ -413,6 +430,7 @@ impl ResolvedModel {
     }
 
     fn ensure_quantity_index(&mut self) {
+        self.sync_semantic_publication();
         if self.quantity_index.is_none() {
             let index = self.build_quantity_index();
             self.quantity_index = Some(index);
@@ -629,6 +647,49 @@ impl ResolvedModel {
 #[cfg(test)]
 mod memo_tests {
     use super::*;
+    #[test]
+    fn factor_and_header_reads_restore_origin_before_error_returns() {
+        use std::collections::HashMap;
+        for value in ["2", "true", "missing"] {
+            let mut model = crate::model::Model::new();
+            model.add_library_source(
+                "lib.kerml",
+                "package Quantities { datatype QuantityPowerFactor; }",
+            );
+            model.add_source("user.kerml",&format!("package P {{ feature Actual={value}; feature '88888888-8888-4888-8888-888888888888'=1; feature L; datatype Unit {{ feature pf:Quantities::QuantityPowerFactor {{ feature quantity=L; feature exponent='88888888-8888-4888-8888-888888888888'; }} }} datatype Amount {{ feature mRef:Unit; }} feature sized['88888888-8888-4888-8888-888888888888']; }}"));
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let actual = r.resolve_qualified("P::Actual").unwrap();
+            let ordinary = r
+                .resolve_qualified("P::'88888888-8888-4888-8888-888888888888'")
+                .unwrap();
+            let id = "88888888-8888-4888-8888-888888888888".parse().unwrap();
+            r.override_ids(&HashMap::from([(r.element_id(actual), id)]));
+            let mut hints: HashMap<_, _> = r
+                .references_to(ordinary)
+                .into_iter()
+                .map(|s| ((r.element_id(s.owner), "memberElement".into()), id))
+                .collect();
+            assert!(r.bind_id_spelled_references_with(&mut hints).contains(&id));
+            let amount = r.resolve_qualified("P::Amount").unwrap();
+            let sized = r.resolve_qualified("P::sized").unwrap();
+            for origin in [None, Some(0)] {
+                r.b.identity_origin_unit = origin;
+                let dims = r.quantity_dims_of_type(amount);
+                assert_eq!(
+                    dims.as_ref().map(|d| d.render(&r)),
+                    (value == "2").then(|| "L^2".to_owned())
+                );
+                assert_eq!(r.b.identity_origin_unit, origin);
+                assert_eq!(
+                    r.declared_multiplicity(sized),
+                    (value == "2").then_some((2.0, 2.0))
+                );
+                assert_eq!(r.b.identity_origin_unit, origin);
+            }
+        }
+    }
+
     #[test]
     fn dimensions_match_uncached_queries_and_replay_complete_import_evidence() {
         let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
diff --git a/crates/sysmlv2-model/src/render.rs b/crates/sysmlv2-model/src/render.rs
deleted file mode 100644
index 02517ff..0000000
--- a/crates/sysmlv2-model/src/render.rs
+++ /dev/null
@@ -1,767 +0,0 @@
-//! The template rendering backend (semantic mode): evaluate
-//! an imported component template — the `Root` a `rendering def` owns —
-//! over a `view` usage's exposed model slice, and return the resulting
-//! DOM tree as values. Nothing is written into the model: inputs bind in
-//! the evaluator's environment, blocks iterate and test through the
-//! translated `kerml` expressions beside their typed source, and
-//! elements, attributes and text project exactly as the construction
-//! layer would present them.
-
-use crate::eval::Value;
-use crate::json::{ElementRef, ResolvedModel};
-use sysmlv2_syntax::ast::{Name, QualifiedName};
-use sysmlv2_syntax::parser::parse_expression;
-use sysmlv2_syntax::span::Span;
-
-/// One rendered node.
-#[derive(Clone, Debug, PartialEq)]
-pub enum RenderNode {
-    Element {
-        name: String,
-        namespace: Option<String>,
-        /// Reified attributes (`localName`, rendered value), in order.
-        attributes: Vec<(String, String)>,
-        /// Reflected properties bound on the usage (feature name, value,
-        /// whether the evaluated value is Boolean).
-        properties: Vec<(String, String, bool)>,
-        children: Vec<RenderNode>,
-    },
-    Text(String),
-    Comment(String),
-    /// Raw markup (`{@html …}`), not escaped.
-    Raw(String),
-    /// A component occurrence result, reserved for a project-aware resolver.
-    Component {
-        name: String,
-        children: Vec<RenderNode>,
-    },
-    /// A block or expression that could not be evaluated (no translation,
-    /// or an evaluation error): rendering degrades to a marker so the
-    /// rest of the view still renders.
-    Error(String),
-}
-
-/// Content-attribute names for the reflected properties whose IDL name
-/// differs from the attribute; every other property lowercases.
-const PROPERTY_ATTRIBUTES: &[(&str, &str)] = &[
-    ("className", "class"),
-    ("htmlFor", "for"),
-    ("httpEquiv", "http-equiv"),
-    ("acceptCharset", "accept-charset"),
-    ("defaultValue", "value"),
-    ("defaultChecked", "checked"),
-    ("defaultSelected", "selected"),
-    ("valueAsNumber", "value"),
-];
-
-/// HTML boolean content attributes serialize by presence/absence. Boolean
-/// IDL properties not in this list (for example `draggable`) are enumerated
-/// attributes and retain their textual true/false value.
-const BOOLEAN_ATTRIBUTES: &[&str] = &[
-    "allowfullscreen",
-    "async",
-    "autofocus",
-    "autoplay",
-    "checked",
-    "controls",
-    "default",
-    "defer",
-    "disabled",
-    "formnovalidate",
-    "hidden",
-    "inert",
-    "ismap",
-    "itemscope",
-    "loop",
-    "multiple",
-    "muted",
-    "nomodule",
-    "novalidate",
-    "open",
-    "playsinline",
-    "readonly",
-    "required",
-    "reversed",
-    "selected",
-];
-
-fn escape_html(s: &str, out: &mut String) {
-    for c in s.chars() {
-        match c {
-            '&' => out.push_str("&amp;"),
-            '<' => out.push_str("&lt;"),
-            '>' => out.push_str("&gt;"),
-            '"' => out.push_str("&quot;"),
-            c => out.push(c),
-        }
-    }
-}
-
-impl RenderNode {
-    pub fn to_json(&self) -> serde_json::Value {
-        match self {
-            RenderNode::Element {
-                name,
-                namespace,
-                attributes,
-                properties,
-                children,
-            } => {
-                let mut o = serde_json::Map::new();
-                o.insert("kind".into(), "element".into());
-                o.insert("name".into(), name.as_str().into());
-                if let Some(ns) = namespace {
-                    o.insert("namespace".into(), ns.as_str().into());
-                }
-                o.insert(
-                    "attributes".into(),
-                    serde_json::Value::Object(
-                        attributes
-                            .iter()
-                            .map(|(k, v)| (k.clone(), v.as_str().into()))
-                            .collect(),
-                    ),
-                );
-                o.insert(
-                    "properties".into(),
-                    serde_json::Value::Object(
-                        properties
-                            .iter()
-                            .map(|(k, v, _)| (k.clone(), v.as_str().into()))
-                            .collect(),
-                    ),
-                );
-                o.insert(
-                    "children".into(),
-                    children.iter().map(RenderNode::to_json).collect(),
-                );
-                serde_json::Value::Object(o)
-            }
-            RenderNode::Text(t) => serde_json::json!({"kind": "text", "data": t}),
-            RenderNode::Comment(t) => serde_json::json!({"kind": "comment", "data": t}),
-            RenderNode::Raw(t) => serde_json::json!({"kind": "raw", "html": t}),
-            RenderNode::Component { name, children } => serde_json::json!({
-                "kind": "component", "name": name,
-                "children": children.iter().map(RenderNode::to_json).collect::<Vec<_>>(),
-            }),
-            RenderNode::Error(message) => serde_json::json!({"kind": "error", "message": message}),
-        }
-    }
-
-    pub fn to_html(&self, out: &mut String) {
-        match self {
-            RenderNode::Element {
-                name,
-                attributes,
-                properties,
-                children,
-                ..
-            } => {
-                out.push('<');
-                out.push_str(name);
-                for (k, v, boolean) in properties {
-                    let attr = PROPERTY_ATTRIBUTES
-                        .iter()
-                        .find(|(p, _)| p == k)
-                        .map(|(_, a)| a.to_string())
-                        .unwrap_or_else(|| k.to_lowercase());
-                    let boolean_attribute = *boolean && BOOLEAN_ATTRIBUTES.contains(&attr.as_str());
-                    if boolean_attribute && v == "true" {
-                        out.push(' ');
-                        out.push_str(&attr);
-                        continue;
-                    }
-                    if boolean_attribute && v == "false" {
-                        continue;
-                    }
-                    out.push(' ');
-                    out.push_str(&attr);
-                    out.push_str("=\"");
-                    escape_html(v, out);
-                    out.push('"');
-                }
-                for (k, v) in attributes {
-                    out.push(' ');
-                    out.push_str(k);
-                    out.push_str("=\"");
-                    escape_html(v, out);
-                    out.push('"');
-                }
-                out.push('>');
-                for c in children {
-                    c.to_html(out);
-                }
-                if !matches!(
-                    name.as_str(),
-                    "area"
-                        | "base"
-                        | "br"
-                        | "col"
-                        | "embed"
-                        | "hr"
-                        | "img"
-                        | "input"
-                        | "link"
-                        | "meta"
-                        | "source"
-                        | "track"
-                        | "wbr"
-                ) {
-                    out.push_str("</");
-                    out.push_str(name);
-                    out.push('>');
-                }
-            }
-            RenderNode::Text(t) => escape_html(t, out),
-            RenderNode::Comment(t) => {
-                out.push_str("<!--");
-                out.push_str(t);
-                out.push_str("-->");
-            }
-            RenderNode::Raw(t) => out.push_str(t),
-            RenderNode::Component { children, .. } => {
-                for c in children {
-                    c.to_html(out);
-                }
-            }
-            RenderNode::Error(message) => {
-                out.push_str("<!-- error: ");
-                out.push_str(&message.replace("--", "- -"));
-                out.push_str(" -->");
-            }
-        }
-    }
-}
-
-/// Serialize rendered nodes as HTML.
-pub fn to_html(nodes: &[RenderNode]) -> String {
-    let mut out = String::new();
-    for n in nodes {
-        n.to_html(&mut out);
-    }
-    out
-}
-
-fn qn(name: &str) -> QualifiedName {
-    QualifiedName {
-        is_global: false,
-        segments: vec![Name {
-            value: name.to_string(),
-            span: Span::default(),
-        }],
-        span: Span::default(),
-    }
-}
-
-/// The template kinds the backend distinguishes, resolved once.
-struct Kinds {
-    node: ElementRef,
-    attr: ElementRef,
-    root: ElementRef,
-    element: ElementRef,
-    /// A plain DOM element (`Web::HTML::Elements::*`): renders like a template element.
-    dom_element: ElementRef,
-    component: ElementRef,
-    text: ElementRef,
-    comment: ElementRef,
-    expression_tag: ElementRef,
-    html_tag: ElementRef,
-    each: ElementRef,
-    if_block: ElementRef,
-    await_block: ElementRef,
-    snippet_block: ElementRef,
-    render_tag: ElementRef,
-    attribute: ElementRef,
-}
-
-/// Is a bound value "true" for an `{#if}` test?
-fn truthy(v: &Value) -> bool {
-    match v {
-        Value::Boolean(b) => *b,
-        Value::Integer(i) => *i != 0,
-        Value::Rational(r) => !r.is_zero(),
-        Value::Real(f) => *f != 0.0,
-        Value::String(s) => !s.is_empty(),
-        Value::Sequence(items) => !items.is_empty(),
-        Value::Indeterminate => false,
-        _ => true,
-    }
-}
-
-impl ResolvedModel {
-    fn kinds(&mut self) -> Result<Kinds, String> {
-        let mut get = |q: &str| {
-            self.resolve_qualified(q).ok_or_else(|| {
-                format!("{q} is not loaded (the Web and Template libraries are required)")
-            })
-        };
-        Ok(Kinds {
-            node: get("Web::DOM::Node")?,
-            attr: get("Web::DOM::Attr")?,
-            root: get("Template::Root")?,
-            element: get("Template::Element")?,
-            dom_element: get("Web::DOM::Element")?,
-            component: get("Template::Component")?,
-            text: get("Web::DOM::Text")?,
-            comment: get("Web::DOM::Comment")?,
-            expression_tag: get("Template::ExpressionTag")?,
-            html_tag: get("Template::HtmlTag")?,
-            each: get("Template::EachBlock")?,
-            if_block: get("Template::IfBlock")?,
-            await_block: get("Svelte::AwaitBlock")?,
-            snippet_block: get("Svelte::SnippetBlock")?,
-            render_tag: get("Svelte::RenderTag")?,
-            attribute: get("Template::Attribute")?,
-        })
-    }
-
-    /// A bound scalar feature of `e` reached by name, as text.
-    fn bound_text(&mut self, e: ElementRef, name: &str) -> Option<String> {
-        match self.evaluate_chain(e, &[&qn(name)]) {
-            Ok(Value::String(s)) => Some(s),
-            Ok(
-                v @ (Value::Integer(_) | Value::Rational(_) | Value::Real(_) | Value::Boolean(_)),
-            ) => Some(self.render_value(&v)),
-            _ => None,
-        }
-    }
-
-    /// Evaluate translated KerML text over `env`, from the root scope.
-    fn eval_kerml(&mut self, text: &str, env: &[(String, Value)]) -> Result<Value, String> {
-        let parsed = parse_expression(text);
-        let expr = parsed.expr.ok_or_else(|| {
-            format!(
-                "kerml `{text}`: {}",
-                parsed
-                    .diagnostics
-                    .first()
-                    .map(|d| d.message.clone())
-                    .unwrap_or_default()
-            )
-        })?;
-        let scope = self.root_scope();
-        crate::eval::evaluate_query_with_env(&mut self.b, scope.0, &expr, env.to_vec())
-            .map_err(|e| format!("kerml `{text}`: {e}"))
-    }
-
-    /// The text a value renders as: strings verbatim, elements by name.
-    fn value_text(&self, v: &Value) -> String {
-        match v {
-            Value::String(s) => s.clone(),
-            Value::Sequence(items) => items
-                .iter()
-                .map(|i| self.value_text(i))
-                .collect::<Vec<_>>()
-                .join(", "),
-            other => self.render_value(other),
-        }
-    }
-
-    /// A part with no typing of its own (only redefinitions): a slot.
-    fn is_slot(&mut self, e: ElementRef) -> bool {
-        let specs = self.b.explicit_specialization_elems(e.0);
-        !specs.is_empty() && specs.iter().all(|(k, _)| *k == "Redefinition")
-    }
-
-    /// The named slot of `e` (`part <n> :>> body { … }`): a slot's name
-    /// is the feature it redefines, not its own short name.
-    fn slot(&mut self, e: ElementRef, name: &str) -> Option<ElementRef> {
-        let members = self.owned_members(e);
-        for m in members {
-            if self.element_type(m) != "PartUsage" || !self.is_slot(m) {
-                continue;
-            }
-            let targets = self.b.redefinition_target_elems(m.0);
-            if targets
-                .iter()
-                .any(|&t| self.b.id_name(t).as_deref() == Some(name))
-            {
-                return Some(m);
-            }
-        }
-        None
-    }
-
-    /// Render the tree a `view` usage presents: its exposed elements bind
-    /// the rendering's inputs. Returns the rendered nodes of the root.
-    ///
-    /// Rendering errors are messages rather than a type throughout this
-    /// module: each one names a specific thing the view's own text is
-    /// missing or has wrong, for a reader to act on, and every caller
-    /// passes it straight to one — a command-line message, a rejected
-    /// call in a host binding.
-    pub fn render_view(&mut self, view: ElementRef) -> Result<Vec<RenderNode>, String> {
-        // Annotations (documentation, comments, textual representations)
-        // are members too, but never a template's subject matter.
-        let exposed: Vec<Value> = self
-            .view_exposed_elements(view)
-            .into_iter()
-            .filter(|&e| {
-                !matches!(
-                    self.element_type(e),
-                    "Documentation" | "Comment" | "TextualRepresentation"
-                )
-            })
-            .map(Value::Element)
-            .collect();
-        let root = self.view_template_root(view)?;
-        self.render_root(root, &Value::Sequence(exposed))
-    }
-
-    /// The `Root` usage of the rendering a view (or its definition) names.
-    fn view_template_root(&mut self, view: ElementRef) -> Result<ElementRef, String> {
-        let kinds = self.kinds()?;
-        // The rendering usage: on the view usage itself, or on its definitions.
-        let mut candidates = vec![view];
-        candidates.extend(self.typings(view));
-        let mut renderings = Vec::new();
-        for c in candidates {
-            let members = self.owned_members(c);
-            for m in members {
-                if self.element_type(m) == "RenderingUsage" {
-                    renderings.push(m);
-                }
-            }
-        }
-        if renderings.is_empty() {
-            return Err("the view names no rendering usage".into());
-        }
-        // A rendering usage (the declared one, or the `render` reference's
-        // target) is typed by the rendering definition owning the root — or,
-        // for a rendering written in plain DOM parts without a template
-        // root, the rendering definition itself is the root: its node parts
-        // render directly.
-        let mut plain_root = None;
-        for r in renderings {
-            let mut owners = vec![r];
-            owners.extend(self.typings(r));
-            for o in owners {
-                let members = self.owned_members(o);
-                for m in members {
-                    if self.element_type(m) == "PartUsage" && self.conforms(m, kinds.root) {
-                        return Ok(m);
-                    }
-                    if plain_root.is_none()
-                        && self.element_type(m) == "PartUsage"
-                        && self.conforms(m, kinds.node)
-                        && !self.conforms(m, kinds.attr)
-                    {
-                        plain_root = Some(o);
-                    }
-                }
-            }
-        }
-        plain_root.ok_or_else(|| "the rendering owns no template root and no node parts".into())
-    }
-
-    /// Render a template root over `exposed` bound to its declared inputs
-    /// (the first input, or `exposed` itself when the environment names
-    /// none).
-    pub fn render_root(
-        &mut self,
-        root: ElementRef,
-        exposed: &Value,
-    ) -> Result<Vec<RenderNode>, String> {
-        let kinds = self.kinds()?;
-        let mut env: Vec<(String, Value)> = vec![("exposed".into(), exposed.clone())];
-        // Inputs: `environment.inputs` — name + optional KerML selection.
-        let inputs = match self.evaluate_chain(root, &[&qn("environment"), &qn("inputs")]) {
-            Ok(v) => v.items(),
-            Err(_) => Vec::new(),
-        };
-        let mut first = true;
-        for input in inputs {
-            let (Value::Element(e) | Value::Unbound(e) | Value::UnboundMember(e)) = input else {
-                continue;
-            };
-            let Some(name) = self.bound_text(e, "name") else {
-                continue;
-            };
-            let value = match self.bound_text(e, "selection") {
-                Some(sel) => self.eval_kerml(&sel, &env)?,
-                None if first => exposed.clone(),
-                None => Value::Sequence(Vec::new()),
-            };
-            first = false;
-            env.push((name, value));
-        }
-        let mut out = Vec::new();
-        self.render_children(root, &kinds, &env, &mut out)?;
-        Ok(out)
-    }
-
-    fn render_children(
-        &mut self,
-        owner: ElementRef,
-        kinds: &Kinds,
-        env: &[(String, Value)],
-        out: &mut Vec<RenderNode>,
-    ) -> Result<(), String> {
-        for m in self.owned_members(owner) {
-            if self.element_type(m) != "PartUsage" {
-                continue;
-            }
-            if self.is_slot(m) {
-                continue; // named slots render on demand (body, fallback, props)
-            }
-            if self.conforms(m, kinds.attr) || !self.conforms(m, kinds.node) {
-                continue; // attributes belong to their element; environments are not nodes
-            }
-            self.render_node(m, kinds, env, out)?;
-        }
-        Ok(())
-    }
-
-    fn render_node(
-        &mut self,
-        e: ElementRef,
-        kinds: &Kinds,
-        env: &[(String, Value)],
-        out: &mut Vec<RenderNode>,
-    ) -> Result<(), String> {
-        if self.conforms(e, kinds.text) {
-            out.push(RenderNode::Text(
-                self.bound_text(e, "data").unwrap_or_default(),
-            ));
-        } else if self.conforms(e, kinds.comment) {
-            out.push(RenderNode::Comment(
-                self.bound_text(e, "data").unwrap_or_default(),
-            ));
-        } else if self.conforms(e, kinds.expression_tag) {
-            out.push(RenderNode::Text(self.expression_text(e, env)?));
-        } else if self.conforms(e, kinds.html_tag) {
-            out.push(RenderNode::Raw(self.expression_text(e, env)?));
-        } else if self.conforms(e, kinds.each) {
-            self.render_each(e, kinds, env, out)?;
-        } else if self.conforms(e, kinds.if_block) {
-            let test = match self.bound_text(e, "kerml") {
-                Some(k) => match self.eval_kerml(&k, env) {
-                    Ok(v) => truthy(&v),
-                    Err(m) => {
-                        out.push(RenderNode::Error(m));
-                        return Ok(());
-                    }
-                },
-                None => {
-                    out.push(RenderNode::Error(format!(
-                        "untranslated test `{}`",
-                        self.bound_text(e, "test").unwrap_or_default()
-                    )));
-                    return Ok(());
-                }
-            };
-            let slot = if test {
-                self.slot(e, "consequent")
-            } else {
-                self.slot(e, "alternate")
-            };
-            if let Some(s) = slot {
-                self.render_children(s, kinds, env, out)?;
-            }
-        } else if self.conforms(e, kinds.component) {
-            let name = self.bound_text(e, "name").unwrap_or_default();
-            out.push(RenderNode::Error(format!(
-                "unresolved component `{name}` (project occurrence resolver required)"
-            )));
-        } else if self.conforms(e, kinds.snippet_block) {
-            // A snippet is a declaration; it renders only through a render tag.
-        } else if self.conforms(e, kinds.render_tag) {
-            out.push(RenderNode::Error(format!(
-                "unsupported render tag `{}`",
-                self.bound_text(e, "expression").unwrap_or_default()
-            )));
-        } else if self.conforms(e, kinds.await_block) {
-            out.push(RenderNode::Error(format!(
-                "unsupported await block `{}`",
-                self.bound_text(e, "expression").unwrap_or_default()
-            )));
-        } else if self.conforms(e, kinds.element) || self.conforms(e, kinds.dom_element) {
-            out.push(self.render_element(e, kinds, env)?);
-        } else {
-            // Fragments, key blocks and other containers: their content.
-            for s in ["body", "consequent"] {
-                if let Some(slot) = self.slot(e, s) {
-                    self.render_children(slot, kinds, env, out)?;
-                    return Ok(());
-                }
-            }
-            self.render_children(e, kinds, env, out)?;
-        }
-        Ok(())
-    }
-
-    /// An expression tag's text: its translated KerML evaluated, else
-    /// its typed source in braces (opaque).
-    fn expression_text(
-        &mut self,
-        e: ElementRef,
-        env: &[(String, Value)],
-    ) -> Result<String, String> {
-        if let Some(k) = self.bound_text(e, "kerml") {
-            // An evaluation error degrades to the opaque source, like an
-            // untranslated expression, rather than failing the view.
-            if let Ok(v) = self.eval_kerml(&k, env) {
-                return Ok(self.value_text(&v));
-            }
-        }
-        Ok(format!(
-            "{{{}}}",
-            self.bound_text(e, "expression").unwrap_or_default()
-        ))
-    }
-
-    fn render_each(
-        &mut self,
-        e: ElementRef,
-        kinds: &Kinds,
-        env: &[(String, Value)],
-        out: &mut Vec<RenderNode>,
-    ) -> Result<(), String> {
-        let Some(k) = self.bound_text(e, "kerml") else {
-            out.push(RenderNode::Error(format!(
-                "untranslated collection `{}`",
-                self.bound_text(e, "expression").unwrap_or_default()
-            )));
-            return Ok(());
-        };
-        let items = match self.eval_kerml(&k, env) {
-            Ok(v) => v.items(),
-            Err(m) => {
-                out.push(RenderNode::Error(m));
-                return Ok(());
-            }
-        };
-        if items.is_empty() {
-            if let Some(fb) = self.slot(e, "fallback") {
-                self.render_children(fb, kinds, env, out)?;
-            }
-            return Ok(());
-        }
-        let context = self.bound_text(e, "kermlContext");
-        let index = self.bound_text(e, "index");
-        let body = self.slot(e, "body");
-        for (i, item) in items.into_iter().enumerate() {
-            let mut inner = env.to_vec();
-            inner.push(("item".into(), item.clone()));
-            if let Some(ctx) = &context {
-                // `name = expr, name = expr`: each expression sees `'item'`.
-                for binding in split_bindings(ctx) {
-                    let (name, expr) = binding
-                        .split_once('=')
-                        .ok_or_else(|| format!("context binding `{binding}`"))?;
-                    let v = self.eval_kerml(expr.trim(), &inner)?;
-                    inner.push((name.trim().trim_matches('\'').to_string(), v));
-                }
-            }
-            if let Some(ix) = &index {
-                inner.push((ix.clone(), Value::Integer(i as i128)));
-            }
-            if let Some(b) = body {
-                self.render_children(b, kinds, &inner, out)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn render_element(
-        &mut self,
-        e: ElementRef,
-        kinds: &Kinds,
-        env: &[(String, Value)],
-    ) -> Result<RenderNode, String> {
-        let name = self.bound_text(e, "localName").unwrap_or_default();
-        let namespace = self.bound_text(e, "namespaceURI");
-        let mut attributes = Vec::new();
-        let mut properties = Vec::new();
-        let members = self.owned_members(e);
-        for m in members {
-            let ty = self.element_type(m);
-            if ty == "PartUsage" && self.conforms(m, kinds.attr) {
-                if !self.conforms(m, kinds.attribute)
-                    && !self.typings(m).is_empty()
-                    && !self.conforms(m, kinds.attr)
-                {
-                    continue;
-                }
-                // Directives and spreads conform to AttributeLike but are not Attributes: skipped.
-                if !self.conforms(m, kinds.attribute) {
-                    continue;
-                }
-                let key = self.bound_text(m, "localName").unwrap_or_default();
-                let value = match self.bound_text(m, "value") {
-                    Some(v) => v,
-                    None => {
-                        // Chunks: text and expression tags in order.
-                        let mut parts = Vec::new();
-                        for c in self.owned_members(m) {
-                            if self.element_type(c) != "PartUsage" {
-                                continue;
-                            }
-                            if self.conforms(c, kinds.text) {
-                                parts.push(self.bound_text(c, "data").unwrap_or_default());
-                            } else if self.conforms(c, kinds.expression_tag) {
-                                parts.push(self.expression_text(c, env)?);
-                            }
-                        }
-                        parts.concat()
-                    }
-                };
-                attributes.push((key, value));
-            } else if (ty == "ReferenceUsage" || ty == "AttributeUsage") && self.has_value(m) {
-                let Some(n) = self.b.id_name(m.0) else {
-                    continue;
-                };
-                if matches!(n.as_str(), "localName" | "namespaceURI") || n.starts_with("kerml") {
-                    continue;
-                }
-                if let Ok(v) = self.evaluate(m) {
-                    let boolean = matches!(v, Value::Boolean(_));
-                    let text = self.value_text(&v);
-                    properties.push((n, text, boolean));
-                }
-            }
-        }
-        let mut children = Vec::new();
-        self.render_children(e, kinds, env, &mut children)?;
-        Ok(RenderNode::Element {
-            name,
-            namespace,
-            attributes,
-            properties,
-            children,
-        })
-    }
-}
-
-/// Split `a = x, b = f(y, z)` at top-level commas.
-fn split_bindings(s: &str) -> Vec<String> {
-    let mut out = Vec::new();
-    let mut depth = 0i32;
-    let mut cur = String::new();
-    let mut in_str = false;
-    for c in s.chars() {
-        match c {
-            '"' => {
-                in_str = !in_str;
-                cur.push(c);
-            }
-            '(' | '[' | '{' if !in_str => {
-                depth += 1;
-                cur.push(c);
-            }
-            ')' | ']' | '}' if !in_str => {
-                depth -= 1;
-                cur.push(c);
-            }
-            ',' if !in_str && depth == 0 => {
-                out.push(cur.trim().to_string());
-                cur.clear();
-            }
-            _ => cur.push(c),
-        }
-    }
-    if !cur.trim().is_empty() {
-        out.push(cur.trim().to_string());
-    }
-    out
-}
diff --git a/crates/sysmlv2-model/src/semantic_catalog.rs b/crates/sysmlv2-model/src/semantic_catalog.rs
new file mode 100644
index 0000000..a699fab
--- /dev/null
+++ b/crates/sysmlv2-model/src/semantic_catalog.rs
@@ -0,0 +1,14132 @@
+//! Generated by `tools/semantic_catalog.py` from the normative 20250201 XMI.
+//! Do not edit; regenerate or use `--check`.
+
+#[derive(Debug)]
+pub struct PropertySpec {
+    pub id: &'static str,
+    pub declaring_metaclass: &'static str,
+    pub name: &'static str,
+    pub target: &'static str,
+    pub derived: bool,
+    pub lower: usize,
+    pub unique: bool,
+    pub ordered: bool,
+    pub enum_values: &'static [&'static str],
+    pub upper: Option<usize>,
+    pub default_json: Option<&'static str>,
+    pub storage_names: &'static [&'static str],
+}
+
+#[rustfmt::skip]
+pub static PROPERTIES: &[PropertySpec] = &[
+    PropertySpec { id: "Core-Classifiers-Classifier-ownedSubclassification", declaring_metaclass: "Classifier", name: "ownedSubclassification", target: "Subclassification", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedSubclassification"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Classifiers-Subclassification-owningClassifier", declaring_metaclass: "Subclassification", name: "owningClassifier", target: "Classifier", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningClassifier", "owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Classifiers-Subclassification-subclassifier", declaring_metaclass: "Subclassification", name: "subclassifier", target: "Classifier", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["subclassifier", "source", "specific"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Classifiers-Subclassification-superclassifier", declaring_metaclass: "Subclassification", name: "superclassifier", target: "Classifier", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["superclassifier", "general", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-CrossSubsetting-crossedFeature", declaring_metaclass: "CrossSubsetting", name: "crossedFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["crossedFeature", "general", "subsettedFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-CrossSubsetting-crossingFeature", declaring_metaclass: "CrossSubsetting", name: "crossingFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["crossingFeature", "owningFeature", "owningType", "source", "specific", "subsettingFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-EndFeatureMembership-ownedMemberFeature", declaring_metaclass: "EndFeatureMembership", name: "ownedMemberFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedMemberFeature", "memberElement", "ownedMemberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-chainingFeature", declaring_metaclass: "Feature", name: "chainingFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["chainingFeature"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-crossFeature", declaring_metaclass: "Feature", name: "crossFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["crossFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-direction", declaring_metaclass: "Feature", name: "direction", target: "FeatureDirectionKind", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["direction"], unique: true, ordered: false, enum_values: &["in", "inout", "out"] },
+    PropertySpec { id: "Core-Features-Feature-endOwningType", declaring_metaclass: "Feature", name: "endOwningType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["endOwningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-featureTarget", declaring_metaclass: "Feature", name: "featureTarget", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["featureTarget"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-featuringType", declaring_metaclass: "Feature", name: "featuringType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["featuringType"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isComposite", declaring_metaclass: "Feature", name: "isComposite", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isComposite"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isConstant", declaring_metaclass: "Feature", name: "isConstant", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isConstant"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isDerived", declaring_metaclass: "Feature", name: "isDerived", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isDerived"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isEnd", declaring_metaclass: "Feature", name: "isEnd", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isEnd"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isOrdered", declaring_metaclass: "Feature", name: "isOrdered", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isOrdered"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isPortion", declaring_metaclass: "Feature", name: "isPortion", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isPortion"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isUnique", declaring_metaclass: "Feature", name: "isUnique", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isUnique"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-isVariable", declaring_metaclass: "Feature", name: "isVariable", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isVariable"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedCrossSubsetting", declaring_metaclass: "Feature", name: "ownedCrossSubsetting", target: "CrossSubsetting", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedCrossSubsetting"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedFeatureChaining", declaring_metaclass: "Feature", name: "ownedFeatureChaining", target: "FeatureChaining", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedFeatureChaining"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedFeatureInverting", declaring_metaclass: "Feature", name: "ownedFeatureInverting", target: "FeatureInverting", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedFeatureInverting"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedRedefinition", declaring_metaclass: "Feature", name: "ownedRedefinition", target: "Redefinition", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedRedefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedReferenceSubsetting", declaring_metaclass: "Feature", name: "ownedReferenceSubsetting", target: "ReferenceSubsetting", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedReferenceSubsetting"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedSubsetting", declaring_metaclass: "Feature", name: "ownedSubsetting", target: "Subsetting", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedSubsetting"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedTypeFeaturing", declaring_metaclass: "Feature", name: "ownedTypeFeaturing", target: "TypeFeaturing", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedTypeFeaturing"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-ownedTyping", declaring_metaclass: "Feature", name: "ownedTyping", target: "FeatureTyping", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedTyping"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-owningFeatureMembership", declaring_metaclass: "Feature", name: "owningFeatureMembership", target: "FeatureMembership", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningFeatureMembership"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-owningType", declaring_metaclass: "Feature", name: "owningType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Feature-type", declaring_metaclass: "Feature", name: "type", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureChaining-chainingFeature", declaring_metaclass: "FeatureChaining", name: "chainingFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["chainingFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureChaining-featureChained", declaring_metaclass: "FeatureChaining", name: "featureChained", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["featureChained", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureInverting-featureInverted", declaring_metaclass: "FeatureInverting", name: "featureInverted", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["featureInverted", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureInverting-invertingFeature", declaring_metaclass: "FeatureInverting", name: "invertingFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["invertingFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureInverting-owningFeature", declaring_metaclass: "FeatureInverting", name: "owningFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureTyping-owningFeature", declaring_metaclass: "FeatureTyping", name: "owningFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningFeature", "owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureTyping-type", declaring_metaclass: "FeatureTyping", name: "type", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["type", "general", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-FeatureTyping-typedFeature", declaring_metaclass: "FeatureTyping", name: "typedFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["typedFeature", "source", "specific"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Redefinition-redefinedFeature", declaring_metaclass: "Redefinition", name: "redefinedFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["redefinedFeature", "general", "subsettedFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Redefinition-redefiningFeature", declaring_metaclass: "Redefinition", name: "redefiningFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["redefiningFeature", "source", "specific", "subsettingFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-ReferenceSubsetting-referencedFeature", declaring_metaclass: "ReferenceSubsetting", name: "referencedFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencedFeature", "general", "subsettedFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-ReferenceSubsetting-referencingFeature", declaring_metaclass: "ReferenceSubsetting", name: "referencingFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencingFeature", "owningFeature", "owningType", "source", "specific", "subsettingFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Subsetting-owningFeature", declaring_metaclass: "Subsetting", name: "owningFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningFeature", "owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Subsetting-subsettedFeature", declaring_metaclass: "Subsetting", name: "subsettedFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["subsettedFeature", "general", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-Subsetting-subsettingFeature", declaring_metaclass: "Subsetting", name: "subsettingFeature", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["subsettingFeature", "source", "specific"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-TypeFeaturing-featureOfType", declaring_metaclass: "TypeFeaturing", name: "featureOfType", target: "Feature", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["featureOfType", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-TypeFeaturing-featuringType", declaring_metaclass: "TypeFeaturing", name: "featuringType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["featuringType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Features-TypeFeaturing-owningFeatureOfType", declaring_metaclass: "TypeFeaturing", name: "owningFeatureOfType", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningFeatureOfType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Conjugation-conjugatedType", declaring_metaclass: "Conjugation", name: "conjugatedType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["conjugatedType", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Conjugation-originalType", declaring_metaclass: "Conjugation", name: "originalType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["originalType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Conjugation-owningType", declaring_metaclass: "Conjugation", name: "owningType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Differencing-differencingType", declaring_metaclass: "Differencing", name: "differencingType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["differencingType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Differencing-typeDifferenced", declaring_metaclass: "Differencing", name: "typeDifferenced", target: "Type", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["typeDifferenced", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Disjoining-disjoiningType", declaring_metaclass: "Disjoining", name: "disjoiningType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["disjoiningType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Disjoining-owningType", declaring_metaclass: "Disjoining", name: "owningType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Disjoining-typeDisjoined", declaring_metaclass: "Disjoining", name: "typeDisjoined", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["typeDisjoined", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-FeatureMembership-ownedMemberFeature", declaring_metaclass: "FeatureMembership", name: "ownedMemberFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedMemberFeature", "memberElement", "ownedMemberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-FeatureMembership-owningType", declaring_metaclass: "FeatureMembership", name: "owningType", target: "Type", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["owningType", "membershipOwningNamespace", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Intersecting-intersectingType", declaring_metaclass: "Intersecting", name: "intersectingType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["intersectingType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Intersecting-typeIntersected", declaring_metaclass: "Intersecting", name: "typeIntersected", target: "Type", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["typeIntersected", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Specialization-general", declaring_metaclass: "Specialization", name: "general", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["general", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Specialization-owningType", declaring_metaclass: "Specialization", name: "owningType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Specialization-specific", declaring_metaclass: "Specialization", name: "specific", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["specific", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-differencingType", declaring_metaclass: "Type", name: "differencingType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["differencingType"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-directedFeature", declaring_metaclass: "Type", name: "directedFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["directedFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-endFeature", declaring_metaclass: "Type", name: "endFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["endFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-feature", declaring_metaclass: "Type", name: "feature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["feature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-featureMembership", declaring_metaclass: "Type", name: "featureMembership", target: "FeatureMembership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["featureMembership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-inheritedFeature", declaring_metaclass: "Type", name: "inheritedFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["inheritedFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-inheritedMembership", declaring_metaclass: "Type", name: "inheritedMembership", target: "Membership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["inheritedMembership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-input", declaring_metaclass: "Type", name: "input", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["input"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-intersectingType", declaring_metaclass: "Type", name: "intersectingType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["intersectingType"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-isAbstract", declaring_metaclass: "Type", name: "isAbstract", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isAbstract"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-isConjugated", declaring_metaclass: "Type", name: "isConjugated", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["isConjugated"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-isSufficient", declaring_metaclass: "Type", name: "isSufficient", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isSufficient"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-multiplicity", declaring_metaclass: "Type", name: "multiplicity", target: "Multiplicity", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["multiplicity"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-output", declaring_metaclass: "Type", name: "output", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["output"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedConjugator", declaring_metaclass: "Type", name: "ownedConjugator", target: "Conjugation", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedConjugator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedDifferencing", declaring_metaclass: "Type", name: "ownedDifferencing", target: "Differencing", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedDifferencing"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedDisjoining", declaring_metaclass: "Type", name: "ownedDisjoining", target: "Disjoining", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedDisjoining"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedEndFeature", declaring_metaclass: "Type", name: "ownedEndFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedEndFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedFeature", declaring_metaclass: "Type", name: "ownedFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedFeatureMembership", declaring_metaclass: "Type", name: "ownedFeatureMembership", target: "FeatureMembership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedFeatureMembership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedIntersecting", declaring_metaclass: "Type", name: "ownedIntersecting", target: "Intersecting", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedIntersecting"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedSpecialization", declaring_metaclass: "Type", name: "ownedSpecialization", target: "Specialization", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedSpecialization"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-ownedUnioning", declaring_metaclass: "Type", name: "ownedUnioning", target: "Unioning", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedUnioning"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Type-unioningType", declaring_metaclass: "Type", name: "unioningType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["unioningType"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Unioning-typeUnioned", declaring_metaclass: "Unioning", name: "typeUnioned", target: "Type", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["typeUnioned", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Core-Types-Unioning-unioningType", declaring_metaclass: "Unioning", name: "unioningType", target: "Type", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["unioningType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Associations-Association-associationEnd", declaring_metaclass: "Association", name: "associationEnd", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["associationEnd", "endFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Associations-Association-relatedType", declaring_metaclass: "Association", name: "relatedType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["relatedType", "relatedElement"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Associations-Association-sourceType", declaring_metaclass: "Association", name: "sourceType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["sourceType", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Associations-Association-targetType", declaring_metaclass: "Association", name: "targetType", target: "Type", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["targetType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Behaviors-Behavior-parameter", declaring_metaclass: "Behavior", name: "parameter", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["parameter", "directedFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Behaviors-Behavior-step", declaring_metaclass: "Behavior", name: "step", target: "Step", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["step"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Behaviors-ParameterMembership-ownedMemberParameter", declaring_metaclass: "ParameterMembership", name: "ownedMemberParameter", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedMemberParameter", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Behaviors-Step-behavior", declaring_metaclass: "Step", name: "behavior", target: "Behavior", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["behavior"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Behaviors-Step-parameter", declaring_metaclass: "Step", name: "parameter", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["parameter", "directedFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-association", declaring_metaclass: "Connector", name: "association", target: "Association", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["association", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-connectorEnd", declaring_metaclass: "Connector", name: "connectorEnd", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["connectorEnd", "endFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-defaultFeaturingType", declaring_metaclass: "Connector", name: "defaultFeaturingType", target: "Type", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["defaultFeaturingType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-relatedFeature", declaring_metaclass: "Connector", name: "relatedFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["relatedFeature", "relatedElement"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-sourceFeature", declaring_metaclass: "Connector", name: "sourceFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["sourceFeature", "source"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Connectors-Connector-targetFeature", declaring_metaclass: "Connector", name: "targetFeature", target: "Feature", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["targetFeature", "target"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-CollectExpression-operator", declaring_metaclass: "CollectExpression", name: "operator", target: "String", derived: false, lower: 1, upper: Some(1), default_json: Some("\"collect\""), storage_names: &["operator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-FeatureChainExpression-operator", declaring_metaclass: "FeatureChainExpression", name: "operator", target: "String", derived: false, lower: 1, upper: Some(1), default_json: Some("\".\""), storage_names: &["operator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-FeatureChainExpression-targetFeature", declaring_metaclass: "FeatureChainExpression", name: "targetFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["targetFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-FeatureReferenceExpression-referent", declaring_metaclass: "FeatureReferenceExpression", name: "referent", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referent"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-IndexExpression-operator", declaring_metaclass: "IndexExpression", name: "operator", target: "String", derived: false, lower: 1, upper: Some(1), default_json: Some("\"#\""), storage_names: &["operator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-InstantiationExpression-argument", declaring_metaclass: "InstantiationExpression", name: "argument", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["argument"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-InstantiationExpression-instantiatedType", declaring_metaclass: "InstantiationExpression", name: "instantiatedType", target: "Type", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["instantiatedType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-LiteralBoolean-value", declaring_metaclass: "LiteralBoolean", name: "value", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["value"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-LiteralInteger-value", declaring_metaclass: "LiteralInteger", name: "value", target: "Integer", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["value"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-LiteralRational-value", declaring_metaclass: "LiteralRational", name: "value", target: "Real", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["value"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-LiteralString-value", declaring_metaclass: "LiteralString", name: "value", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["value"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-MetadataAccessExpression-referencedElement", declaring_metaclass: "MetadataAccessExpression", name: "referencedElement", target: "Element", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-OperatorExpression-operator", declaring_metaclass: "OperatorExpression", name: "operator", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["operator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Expressions-SelectExpression-operator", declaring_metaclass: "SelectExpression", name: "operator", target: "String", derived: false, lower: 1, upper: Some(1), default_json: Some("\"select\""), storage_names: &["operator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-FeatureValues-FeatureValue-featureWithValue", declaring_metaclass: "FeatureValue", name: "featureWithValue", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["featureWithValue"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-FeatureValues-FeatureValue-isDefault", declaring_metaclass: "FeatureValue", name: "isDefault", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isDefault"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-FeatureValues-FeatureValue-isInitial", declaring_metaclass: "FeatureValue", name: "isInitial", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isInitial"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-FeatureValues-FeatureValue-value", declaring_metaclass: "FeatureValue", name: "value", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["value", "memberElement", "ownedMemberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-BooleanExpression-predicate", declaring_metaclass: "BooleanExpression", name: "predicate", target: "Predicate", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["predicate", "behavior", "function"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Expression-function", declaring_metaclass: "Expression", name: "function", target: "Function", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["function", "behavior"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Expression-isModelLevelEvaluable", declaring_metaclass: "Expression", name: "isModelLevelEvaluable", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["isModelLevelEvaluable"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Expression-result", declaring_metaclass: "Expression", name: "result", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["result"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Function-expression", declaring_metaclass: "Function", name: "expression", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["expression"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Function-isModelLevelEvaluable", declaring_metaclass: "Function", name: "isModelLevelEvaluable", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["isModelLevelEvaluable"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Function-result", declaring_metaclass: "Function", name: "result", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["result"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-Invariant-isNegated", declaring_metaclass: "Invariant", name: "isNegated", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isNegated"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Functions-ResultExpressionMembership-ownedResultExpression", declaring_metaclass: "ResultExpressionMembership", name: "ownedResultExpression", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedResultExpression", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-flowEnd", declaring_metaclass: "Flow", name: "flowEnd", target: "FlowEnd", derived: true, lower: 0, upper: Some(2), default_json: None, storage_names: &["flowEnd"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-interaction", declaring_metaclass: "Flow", name: "interaction", target: "Interaction", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["interaction", "association", "behavior", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-payloadFeature", declaring_metaclass: "Flow", name: "payloadFeature", target: "PayloadFeature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["payloadFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-payloadType", declaring_metaclass: "Flow", name: "payloadType", target: "Classifier", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["payloadType"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-sourceOutputFeature", declaring_metaclass: "Flow", name: "sourceOutputFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["sourceOutputFeature"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Interactions-Flow-targetInputFeature", declaring_metaclass: "Flow", name: "targetInputFeature", target: "Feature", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["targetInputFeature"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Metadata-MetadataFeature-metaclass", declaring_metaclass: "MetadataFeature", name: "metaclass", target: "Metaclass", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["metaclass"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Multiplicities-MultiplicityRange-bound", declaring_metaclass: "MultiplicityRange", name: "bound", target: "Expression", derived: true, lower: 1, upper: Some(2), default_json: None, storage_names: &["bound"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Kernel-Multiplicities-MultiplicityRange-lowerBound", declaring_metaclass: "MultiplicityRange", name: "lowerBound", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["lowerBound"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Multiplicities-MultiplicityRange-upperBound", declaring_metaclass: "MultiplicityRange", name: "upperBound", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["upperBound"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Packages-ElementFilterMembership-condition", declaring_metaclass: "ElementFilterMembership", name: "condition", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["condition", "memberElement", "ownedMemberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Packages-LibraryPackage-isStandard", declaring_metaclass: "LibraryPackage", name: "isStandard", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isStandard"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Kernel-Packages-Package-filterCondition", declaring_metaclass: "Package", name: "filterCondition", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["filterCondition"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-AnnotatingElement-annotatedElement", declaring_metaclass: "AnnotatingElement", name: "annotatedElement", target: "Element", derived: true, lower: 1, upper: None, default_json: None, storage_names: &["annotatedElement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-AnnotatingElement-annotation", declaring_metaclass: "AnnotatingElement", name: "annotation", target: "Annotation", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["annotation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-AnnotatingElement-ownedAnnotatingRelationship", declaring_metaclass: "AnnotatingElement", name: "ownedAnnotatingRelationship", target: "Annotation", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAnnotatingRelationship"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-AnnotatingElement-owningAnnotatingRelationship", declaring_metaclass: "AnnotatingElement", name: "owningAnnotatingRelationship", target: "Annotation", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningAnnotatingRelationship"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Annotation-annotatedElement", declaring_metaclass: "Annotation", name: "annotatedElement", target: "Element", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["annotatedElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Annotation-annotatingElement", declaring_metaclass: "Annotation", name: "annotatingElement", target: "AnnotatingElement", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["annotatingElement", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Annotation-ownedAnnotatingElement", declaring_metaclass: "Annotation", name: "ownedAnnotatingElement", target: "AnnotatingElement", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedAnnotatingElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Annotation-owningAnnotatedElement", declaring_metaclass: "Annotation", name: "owningAnnotatedElement", target: "Element", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningAnnotatedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Annotation-owningAnnotatingElement", declaring_metaclass: "Annotation", name: "owningAnnotatingElement", target: "AnnotatingElement", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningAnnotatingElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Comment-body", declaring_metaclass: "Comment", name: "body", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["body"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Comment-locale", declaring_metaclass: "Comment", name: "locale", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["locale"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-Documentation-documentedElement", declaring_metaclass: "Documentation", name: "documentedElement", target: "Element", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["documentedElement", "annotatedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-TextualRepresentation-body", declaring_metaclass: "TextualRepresentation", name: "body", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["body"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-TextualRepresentation-language", declaring_metaclass: "TextualRepresentation", name: "language", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["language"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Annotations-TextualRepresentation-representedElement", declaring_metaclass: "TextualRepresentation", name: "representedElement", target: "Element", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["representedElement", "annotatedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Dependencies-Dependency-client", declaring_metaclass: "Dependency", name: "client", target: "Element", derived: false, lower: 1, upper: None, default_json: None, storage_names: &["client", "source"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Dependencies-Dependency-supplier", declaring_metaclass: "Dependency", name: "supplier", target: "Element", derived: false, lower: 1, upper: None, default_json: None, storage_names: &["supplier", "target"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-aliasIds", declaring_metaclass: "Element", name: "aliasIds", target: "String", derived: false, lower: 0, upper: None, default_json: None, storage_names: &["aliasIds"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-declaredName", declaring_metaclass: "Element", name: "declaredName", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["declaredName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-declaredShortName", declaring_metaclass: "Element", name: "declaredShortName", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["declaredShortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-documentation", declaring_metaclass: "Element", name: "documentation", target: "Documentation", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["documentation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-elementId", declaring_metaclass: "Element", name: "elementId", target: "String", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["elementId"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-isImpliedIncluded", declaring_metaclass: "Element", name: "isImpliedIncluded", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isImpliedIncluded"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-isLibraryElement", declaring_metaclass: "Element", name: "isLibraryElement", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["isLibraryElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-name", declaring_metaclass: "Element", name: "name", target: "String", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["name"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-ownedAnnotation", declaring_metaclass: "Element", name: "ownedAnnotation", target: "Annotation", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAnnotation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-ownedElement", declaring_metaclass: "Element", name: "ownedElement", target: "Element", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedElement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-ownedRelationship", declaring_metaclass: "Element", name: "ownedRelationship", target: "Relationship", derived: false, lower: 0, upper: None, default_json: None, storage_names: &["ownedRelationship"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-owner", declaring_metaclass: "Element", name: "owner", target: "Element", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owner"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-owningMembership", declaring_metaclass: "Element", name: "owningMembership", target: "OwningMembership", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningMembership"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-owningNamespace", declaring_metaclass: "Element", name: "owningNamespace", target: "Namespace", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningNamespace"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-owningRelationship", declaring_metaclass: "Element", name: "owningRelationship", target: "Relationship", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningRelationship"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-qualifiedName", declaring_metaclass: "Element", name: "qualifiedName", target: "String", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["qualifiedName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-shortName", declaring_metaclass: "Element", name: "shortName", target: "String", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["shortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Element-textualRepresentation", declaring_metaclass: "Element", name: "textualRepresentation", target: "TextualRepresentation", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["textualRepresentation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-isImplied", declaring_metaclass: "Relationship", name: "isImplied", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isImplied"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-ownedRelatedElement", declaring_metaclass: "Relationship", name: "ownedRelatedElement", target: "Element", derived: false, lower: 0, upper: None, default_json: None, storage_names: &["ownedRelatedElement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-owningRelatedElement", declaring_metaclass: "Relationship", name: "owningRelatedElement", target: "Element", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningRelatedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-relatedElement", declaring_metaclass: "Relationship", name: "relatedElement", target: "Element", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["relatedElement"], unique: false, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-source", declaring_metaclass: "Relationship", name: "source", target: "Element", derived: false, lower: 0, upper: None, default_json: None, storage_names: &["source"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Elements-Relationship-target", declaring_metaclass: "Relationship", name: "target", target: "Element", derived: false, lower: 0, upper: None, default_json: None, storage_names: &["target"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Import-importOwningNamespace", declaring_metaclass: "Import", name: "importOwningNamespace", target: "Namespace", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["importOwningNamespace", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Import-importedElement", declaring_metaclass: "Import", name: "importedElement", target: "Element", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["importedElement"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Import-isImportAll", declaring_metaclass: "Import", name: "isImportAll", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isImportAll"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Import-isRecursive", declaring_metaclass: "Import", name: "isRecursive", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isRecursive"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Import-visibility", declaring_metaclass: "Import", name: "visibility", target: "VisibilityKind", derived: false, lower: 1, upper: Some(1), default_json: Some("\"private\""), storage_names: &["visibility"], unique: true, ordered: false, enum_values: &["private", "protected", "public"] },
+    PropertySpec { id: "Root-Namespaces-Membership-memberElement", declaring_metaclass: "Membership", name: "memberElement", target: "Element", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["memberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Membership-memberElementId", declaring_metaclass: "Membership", name: "memberElementId", target: "String", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["memberElementId"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Membership-memberName", declaring_metaclass: "Membership", name: "memberName", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["memberName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Membership-memberShortName", declaring_metaclass: "Membership", name: "memberShortName", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["memberShortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Membership-membershipOwningNamespace", declaring_metaclass: "Membership", name: "membershipOwningNamespace", target: "Namespace", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["membershipOwningNamespace", "source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Membership-visibility", declaring_metaclass: "Membership", name: "visibility", target: "VisibilityKind", derived: false, lower: 1, upper: Some(1), default_json: Some("\"public\""), storage_names: &["visibility"], unique: true, ordered: false, enum_values: &["private", "protected", "public"] },
+    PropertySpec { id: "Root-Namespaces-MembershipImport-importedMembership", declaring_metaclass: "MembershipImport", name: "importedMembership", target: "Membership", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["importedMembership", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-importedMembership", declaring_metaclass: "Namespace", name: "importedMembership", target: "Membership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["importedMembership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-member", declaring_metaclass: "Namespace", name: "member", target: "Element", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["member"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-membership", declaring_metaclass: "Namespace", name: "membership", target: "Membership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["membership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-ownedImport", declaring_metaclass: "Namespace", name: "ownedImport", target: "Import", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedImport"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-ownedMember", declaring_metaclass: "Namespace", name: "ownedMember", target: "Element", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedMember"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-Namespace-ownedMembership", declaring_metaclass: "Namespace", name: "ownedMembership", target: "Membership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedMembership"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-NamespaceImport-importedNamespace", declaring_metaclass: "NamespaceImport", name: "importedNamespace", target: "Namespace", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["importedNamespace", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-OwningMembership-ownedMemberElement", declaring_metaclass: "OwningMembership", name: "ownedMemberElement", target: "Element", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedMemberElement", "memberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-OwningMembership-ownedMemberElementId", declaring_metaclass: "OwningMembership", name: "ownedMemberElementId", target: "String", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedMemberElementId", "memberElementId"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-OwningMembership-ownedMemberName", declaring_metaclass: "OwningMembership", name: "ownedMemberName", target: "String", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedMemberName", "memberName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Root-Namespaces-OwningMembership-ownedMemberShortName", declaring_metaclass: "OwningMembership", name: "ownedMemberShortName", target: "String", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["ownedMemberShortName", "memberShortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AcceptActionUsage-payloadArgument", declaring_metaclass: "AcceptActionUsage", name: "payloadArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["payloadArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AcceptActionUsage-payloadParameter", declaring_metaclass: "AcceptActionUsage", name: "payloadParameter", target: "ReferenceUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["payloadParameter"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AcceptActionUsage-receiverArgument", declaring_metaclass: "AcceptActionUsage", name: "receiverArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["receiverArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-ActionDefinition-action", declaring_metaclass: "ActionDefinition", name: "action", target: "ActionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["action"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-ActionUsage-actionDefinition", declaring_metaclass: "ActionUsage", name: "actionDefinition", target: "Behavior", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["actionDefinition", "behavior", "definition", "occurrenceDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AssignmentActionUsage-referent", declaring_metaclass: "AssignmentActionUsage", name: "referent", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referent"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AssignmentActionUsage-targetArgument", declaring_metaclass: "AssignmentActionUsage", name: "targetArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["targetArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-AssignmentActionUsage-valueExpression", declaring_metaclass: "AssignmentActionUsage", name: "valueExpression", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["valueExpression"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-ForLoopActionUsage-loopVariable", declaring_metaclass: "ForLoopActionUsage", name: "loopVariable", target: "ReferenceUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["loopVariable"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-ForLoopActionUsage-seqArgument", declaring_metaclass: "ForLoopActionUsage", name: "seqArgument", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["seqArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-IfActionUsage-elseAction", declaring_metaclass: "IfActionUsage", name: "elseAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["elseAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-IfActionUsage-ifArgument", declaring_metaclass: "IfActionUsage", name: "ifArgument", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ifArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-IfActionUsage-thenAction", declaring_metaclass: "IfActionUsage", name: "thenAction", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["thenAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-LoopActionUsage-bodyAction", declaring_metaclass: "LoopActionUsage", name: "bodyAction", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["bodyAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-PerformActionUsage-performedAction", declaring_metaclass: "PerformActionUsage", name: "performedAction", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["performedAction", "eventOccurrence"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-SendActionUsage-payloadArgument", declaring_metaclass: "SendActionUsage", name: "payloadArgument", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["payloadArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-SendActionUsage-receiverArgument", declaring_metaclass: "SendActionUsage", name: "receiverArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["receiverArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-SendActionUsage-senderArgument", declaring_metaclass: "SendActionUsage", name: "senderArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["senderArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-TerminateActionUsage-terminatedOccurrenceArgument", declaring_metaclass: "TerminateActionUsage", name: "terminatedOccurrenceArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["terminatedOccurrenceArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-TriggerInvocationExpression-kind", declaring_metaclass: "TriggerInvocationExpression", name: "kind", target: "TriggerKind", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["kind"], unique: true, ordered: false, enum_values: &["when", "at", "after"] },
+    PropertySpec { id: "Systems-Actions-WhileLoopActionUsage-untilArgument", declaring_metaclass: "WhileLoopActionUsage", name: "untilArgument", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["untilArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Actions-WhileLoopActionUsage-whileArgument", declaring_metaclass: "WhileLoopActionUsage", name: "whileArgument", target: "Expression", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["whileArgument"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Allocations-AllocationDefinition-allocation", declaring_metaclass: "AllocationDefinition", name: "allocation", target: "AllocationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["allocation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Allocations-AllocationUsage-allocationDefinition", declaring_metaclass: "AllocationUsage", name: "allocationDefinition", target: "AllocationDefinition", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["allocationDefinition", "association", "connectionDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-AnalysisCases-AnalysisCaseDefinition-resultExpression", declaring_metaclass: "AnalysisCaseDefinition", name: "resultExpression", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["resultExpression"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-AnalysisCases-AnalysisCaseUsage-analysisCaseDefinition", declaring_metaclass: "AnalysisCaseUsage", name: "analysisCaseDefinition", target: "AnalysisCaseDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["analysisCaseDefinition", "actionDefinition", "behavior", "calculationDefinition", "caseDefinition", "definition", "function", "occurrenceDefinition", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-AnalysisCases-AnalysisCaseUsage-resultExpression", declaring_metaclass: "AnalysisCaseUsage", name: "resultExpression", target: "Expression", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["resultExpression"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Attributes-AttributeUsage-attributeDefinition", declaring_metaclass: "AttributeUsage", name: "attributeDefinition", target: "DataType", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["attributeDefinition", "definition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Attributes-AttributeUsage-isReference", declaring_metaclass: "AttributeUsage", name: "isReference", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isReference"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Calculations-CalculationDefinition-calculation", declaring_metaclass: "CalculationDefinition", name: "calculation", target: "CalculationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["calculation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Calculations-CalculationUsage-calculationDefinition", declaring_metaclass: "CalculationUsage", name: "calculationDefinition", target: "Function", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["calculationDefinition", "actionDefinition", "behavior", "definition", "function", "occurrenceDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseDefinition-actorParameter", declaring_metaclass: "CaseDefinition", name: "actorParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["actorParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseDefinition-objectiveRequirement", declaring_metaclass: "CaseDefinition", name: "objectiveRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["objectiveRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseDefinition-subjectParameter", declaring_metaclass: "CaseDefinition", name: "subjectParameter", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["subjectParameter"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseUsage-actorParameter", declaring_metaclass: "CaseUsage", name: "actorParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["actorParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseUsage-caseDefinition", declaring_metaclass: "CaseUsage", name: "caseDefinition", target: "CaseDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["caseDefinition", "actionDefinition", "behavior", "calculationDefinition", "definition", "function", "occurrenceDefinition", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseUsage-objectiveRequirement", declaring_metaclass: "CaseUsage", name: "objectiveRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["objectiveRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-CaseUsage-subjectParameter", declaring_metaclass: "CaseUsage", name: "subjectParameter", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["subjectParameter"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Cases-ObjectiveMembership-ownedObjectiveRequirement", declaring_metaclass: "ObjectiveMembership", name: "ownedObjectiveRequirement", target: "RequirementUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedObjectiveRequirement", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Connections-ConnectionDefinition-connectionEnd", declaring_metaclass: "ConnectionDefinition", name: "connectionEnd", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["connectionEnd", "associationEnd", "endFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Connections-ConnectionDefinition-isSufficient", declaring_metaclass: "ConnectionDefinition", name: "isSufficient", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isSufficient"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Connections-ConnectionUsage-connectionDefinition", declaring_metaclass: "ConnectionUsage", name: "connectionDefinition", target: "AssociationStructure", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["connectionDefinition", "association", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Constraints-AssertConstraintUsage-assertedConstraint", declaring_metaclass: "AssertConstraintUsage", name: "assertedConstraint", target: "ConstraintUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["assertedConstraint"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Constraints-ConstraintUsage-constraintDefinition", declaring_metaclass: "ConstraintUsage", name: "constraintDefinition", target: "Predicate", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["constraintDefinition", "behavior", "function", "predicate"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-directedUsage", declaring_metaclass: "Definition", name: "directedUsage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["directedUsage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-isVariation", declaring_metaclass: "Definition", name: "isVariation", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["isVariation"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedAction", declaring_metaclass: "Definition", name: "ownedAction", target: "ActionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAction"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedAllocation", declaring_metaclass: "Definition", name: "ownedAllocation", target: "AllocationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAllocation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedAnalysisCase", declaring_metaclass: "Definition", name: "ownedAnalysisCase", target: "AnalysisCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAnalysisCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedAttribute", declaring_metaclass: "Definition", name: "ownedAttribute", target: "AttributeUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedAttribute"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedCalculation", declaring_metaclass: "Definition", name: "ownedCalculation", target: "CalculationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedCalculation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedCase", declaring_metaclass: "Definition", name: "ownedCase", target: "CaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedConcern", declaring_metaclass: "Definition", name: "ownedConcern", target: "ConcernUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedConcern"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedConnection", declaring_metaclass: "Definition", name: "ownedConnection", target: "ConnectorAsUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedConnection"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedConstraint", declaring_metaclass: "Definition", name: "ownedConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedEnumeration", declaring_metaclass: "Definition", name: "ownedEnumeration", target: "EnumerationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedEnumeration"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedFlow", declaring_metaclass: "Definition", name: "ownedFlow", target: "FlowUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedFlow"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedInterface", declaring_metaclass: "Definition", name: "ownedInterface", target: "InterfaceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedInterface"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedItem", declaring_metaclass: "Definition", name: "ownedItem", target: "ItemUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedItem"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedMetadata", declaring_metaclass: "Definition", name: "ownedMetadata", target: "MetadataUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedMetadata"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedOccurrence", declaring_metaclass: "Definition", name: "ownedOccurrence", target: "OccurrenceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedOccurrence"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedPart", declaring_metaclass: "Definition", name: "ownedPart", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedPart"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedPort", declaring_metaclass: "Definition", name: "ownedPort", target: "PortUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedPort"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedReference", declaring_metaclass: "Definition", name: "ownedReference", target: "ReferenceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedReference"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedRendering", declaring_metaclass: "Definition", name: "ownedRendering", target: "RenderingUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedRendering"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedRequirement", declaring_metaclass: "Definition", name: "ownedRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedState", declaring_metaclass: "Definition", name: "ownedState", target: "StateUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedState"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedTransition", declaring_metaclass: "Definition", name: "ownedTransition", target: "TransitionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedTransition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedUsage", declaring_metaclass: "Definition", name: "ownedUsage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedUsage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedUseCase", declaring_metaclass: "Definition", name: "ownedUseCase", target: "UseCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedUseCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedVerificationCase", declaring_metaclass: "Definition", name: "ownedVerificationCase", target: "VerificationCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedVerificationCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedView", declaring_metaclass: "Definition", name: "ownedView", target: "ViewUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedView"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-ownedViewpoint", declaring_metaclass: "Definition", name: "ownedViewpoint", target: "ViewpointUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["ownedViewpoint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-usage", declaring_metaclass: "Definition", name: "usage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["usage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-variant", declaring_metaclass: "Definition", name: "variant", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["variant"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Definition-variantMembership", declaring_metaclass: "Definition", name: "variantMembership", target: "VariantMembership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["variantMembership"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-ReferenceUsage-isReference", declaring_metaclass: "ReferenceUsage", name: "isReference", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: Some("\"true\""), storage_names: &["isReference"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-definition", declaring_metaclass: "Usage", name: "definition", target: "Classifier", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["definition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-directedUsage", declaring_metaclass: "Usage", name: "directedUsage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["directedUsage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-isReference", declaring_metaclass: "Usage", name: "isReference", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["isReference"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-isVariation", declaring_metaclass: "Usage", name: "isVariation", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["isVariation"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-mayTimeVary", declaring_metaclass: "Usage", name: "mayTimeVary", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["mayTimeVary", "isVariable"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedAction", declaring_metaclass: "Usage", name: "nestedAction", target: "ActionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedAction"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedAllocation", declaring_metaclass: "Usage", name: "nestedAllocation", target: "AllocationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedAllocation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedAnalysisCase", declaring_metaclass: "Usage", name: "nestedAnalysisCase", target: "AnalysisCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedAnalysisCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedAttribute", declaring_metaclass: "Usage", name: "nestedAttribute", target: "AttributeUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedAttribute"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedCalculation", declaring_metaclass: "Usage", name: "nestedCalculation", target: "CalculationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedCalculation"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedCase", declaring_metaclass: "Usage", name: "nestedCase", target: "CaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedConcern", declaring_metaclass: "Usage", name: "nestedConcern", target: "ConcernUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedConcern"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedConnection", declaring_metaclass: "Usage", name: "nestedConnection", target: "ConnectorAsUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedConnection"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedConstraint", declaring_metaclass: "Usage", name: "nestedConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedEnumeration", declaring_metaclass: "Usage", name: "nestedEnumeration", target: "EnumerationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedEnumeration"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedFlow", declaring_metaclass: "Usage", name: "nestedFlow", target: "FlowUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedFlow"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedInterface", declaring_metaclass: "Usage", name: "nestedInterface", target: "InterfaceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedInterface"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedItem", declaring_metaclass: "Usage", name: "nestedItem", target: "ItemUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedItem"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedMetadata", declaring_metaclass: "Usage", name: "nestedMetadata", target: "MetadataUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedMetadata"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedOccurrence", declaring_metaclass: "Usage", name: "nestedOccurrence", target: "OccurrenceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedOccurrence"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedPart", declaring_metaclass: "Usage", name: "nestedPart", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedPart"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedPort", declaring_metaclass: "Usage", name: "nestedPort", target: "PortUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedPort"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedReference", declaring_metaclass: "Usage", name: "nestedReference", target: "ReferenceUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedReference"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedRendering", declaring_metaclass: "Usage", name: "nestedRendering", target: "RenderingUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedRendering"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedRequirement", declaring_metaclass: "Usage", name: "nestedRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedState", declaring_metaclass: "Usage", name: "nestedState", target: "StateUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedState"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedTransition", declaring_metaclass: "Usage", name: "nestedTransition", target: "TransitionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedTransition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedUsage", declaring_metaclass: "Usage", name: "nestedUsage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedUsage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedUseCase", declaring_metaclass: "Usage", name: "nestedUseCase", target: "UseCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedUseCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedVerificationCase", declaring_metaclass: "Usage", name: "nestedVerificationCase", target: "VerificationCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedVerificationCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedView", declaring_metaclass: "Usage", name: "nestedView", target: "ViewUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedView"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-nestedViewpoint", declaring_metaclass: "Usage", name: "nestedViewpoint", target: "ViewpointUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["nestedViewpoint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-owningDefinition", declaring_metaclass: "Usage", name: "owningDefinition", target: "Definition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-owningUsage", declaring_metaclass: "Usage", name: "owningUsage", target: "Usage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["owningUsage"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-usage", declaring_metaclass: "Usage", name: "usage", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["usage"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-variant", declaring_metaclass: "Usage", name: "variant", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["variant"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-Usage-variantMembership", declaring_metaclass: "Usage", name: "variantMembership", target: "VariantMembership", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["variantMembership"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-DefinitionAndUsage-VariantMembership-ownedVariantUsage", declaring_metaclass: "VariantMembership", name: "ownedVariantUsage", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedVariantUsage", "memberElement", "ownedMemberElement", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Enumerations-EnumerationDefinition-enumeratedValue", declaring_metaclass: "EnumerationDefinition", name: "enumeratedValue", target: "EnumerationUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["enumeratedValue", "variant"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Enumerations-EnumerationDefinition-isVariation", declaring_metaclass: "EnumerationDefinition", name: "isVariation", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isVariation"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Enumerations-EnumerationUsage-enumerationDefinition", declaring_metaclass: "EnumerationUsage", name: "enumerationDefinition", target: "EnumerationDefinition", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["enumerationDefinition", "attributeDefinition", "definition", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Flows-FlowDefinition-flowEnd", declaring_metaclass: "FlowDefinition", name: "flowEnd", target: "Usage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["flowEnd", "associationEnd", "endFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Flows-FlowUsage-flowDefinition", declaring_metaclass: "FlowUsage", name: "flowDefinition", target: "Interaction", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["flowDefinition", "actionDefinition", "association", "behavior", "definition", "interaction", "occurrenceDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Interfaces-InterfaceDefinition-interfaceEnd", declaring_metaclass: "InterfaceDefinition", name: "interfaceEnd", target: "PortUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["interfaceEnd", "associationEnd", "connectionEnd", "endFeature"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Interfaces-InterfaceUsage-interfaceDefinition", declaring_metaclass: "InterfaceUsage", name: "interfaceDefinition", target: "InterfaceDefinition", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["interfaceDefinition", "association", "connectionDefinition", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Items-ItemUsage-itemDefinition", declaring_metaclass: "ItemUsage", name: "itemDefinition", target: "Structure", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["itemDefinition"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Metadata-MetadataUsage-metadataDefinition", declaring_metaclass: "MetadataUsage", name: "metadataDefinition", target: "Metaclass", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["metadataDefinition", "itemDefinition", "metaclass"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-EventOccurrenceUsage-eventOccurrence", declaring_metaclass: "EventOccurrenceUsage", name: "eventOccurrence", target: "OccurrenceUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["eventOccurrence"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-EventOccurrenceUsage-isReference", declaring_metaclass: "EventOccurrenceUsage", name: "isReference", target: "Boolean", derived: true, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isReference"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-OccurrenceDefinition-isIndividual", declaring_metaclass: "OccurrenceDefinition", name: "isIndividual", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isIndividual"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-OccurrenceUsage-individualDefinition", declaring_metaclass: "OccurrenceUsage", name: "individualDefinition", target: "OccurrenceDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["individualDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-OccurrenceUsage-isIndividual", declaring_metaclass: "OccurrenceUsage", name: "isIndividual", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isIndividual"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-OccurrenceUsage-occurrenceDefinition", declaring_metaclass: "OccurrenceUsage", name: "occurrenceDefinition", target: "Class", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["occurrenceDefinition", "definition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Occurrences-OccurrenceUsage-portionKind", declaring_metaclass: "OccurrenceUsage", name: "portionKind", target: "PortionKind", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["portionKind"], unique: true, ordered: false, enum_values: &["timeslice", "snapshot"] },
+    PropertySpec { id: "Systems-Parts-PartUsage-partDefinition", declaring_metaclass: "PartUsage", name: "partDefinition", target: "PartDefinition", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["partDefinition"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-ConjugatedPortDefinition-originalPortDefinition", declaring_metaclass: "ConjugatedPortDefinition", name: "originalPortDefinition", target: "PortDefinition", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["originalPortDefinition", "owningNamespace"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-ConjugatedPortDefinition-ownedPortConjugator", declaring_metaclass: "ConjugatedPortDefinition", name: "ownedPortConjugator", target: "PortConjugation", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedPortConjugator", "ownedConjugator"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-ConjugatedPortTyping-conjugatedPortDefinition", declaring_metaclass: "ConjugatedPortTyping", name: "conjugatedPortDefinition", target: "ConjugatedPortDefinition", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["conjugatedPortDefinition", "general", "target", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-ConjugatedPortTyping-portDefinition", declaring_metaclass: "ConjugatedPortTyping", name: "portDefinition", target: "PortDefinition", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["portDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-PortConjugation-conjugatedPortDefinition", declaring_metaclass: "PortConjugation", name: "conjugatedPortDefinition", target: "ConjugatedPortDefinition", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["conjugatedPortDefinition", "owningType"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-PortConjugation-originalPortDefinition", declaring_metaclass: "PortConjugation", name: "originalPortDefinition", target: "PortDefinition", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["originalPortDefinition", "originalType", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-PortDefinition-conjugatedPortDefinition", declaring_metaclass: "PortDefinition", name: "conjugatedPortDefinition", target: "ConjugatedPortDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["conjugatedPortDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Ports-PortUsage-portDefinition", declaring_metaclass: "PortUsage", name: "portDefinition", target: "PortDefinition", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["portDefinition", "definition", "occurrenceDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-ActorMembership-ownedActorParameter", declaring_metaclass: "ActorMembership", name: "ownedActorParameter", target: "PartUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedActorParameter", "memberElement", "ownedMemberElement", "ownedMemberFeature", "ownedMemberParameter", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-ConcernUsage-concernDefinition", declaring_metaclass: "ConcernUsage", name: "concernDefinition", target: "ConcernDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["concernDefinition", "behavior", "constraintDefinition", "function", "predicate", "requirementDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-FramedConcernMembership-kind", declaring_metaclass: "FramedConcernMembership", name: "kind", target: "RequirementConstraintKind", derived: false, lower: 1, upper: Some(1), default_json: Some("\"requirement\""), storage_names: &["kind"], unique: true, ordered: false, enum_values: &["assumption", "requirement"] },
+    PropertySpec { id: "Systems-Requirements-FramedConcernMembership-ownedConcern", declaring_metaclass: "FramedConcernMembership", name: "ownedConcern", target: "ConcernUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedConcern", "memberElement", "ownedConstraint", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-FramedConcernMembership-referencedConcern", declaring_metaclass: "FramedConcernMembership", name: "referencedConcern", target: "ConcernUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencedConcern", "referencedConstraint"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementConstraintMembership-kind", declaring_metaclass: "RequirementConstraintMembership", name: "kind", target: "RequirementConstraintKind", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["kind"], unique: true, ordered: false, enum_values: &["assumption", "requirement"] },
+    PropertySpec { id: "Systems-Requirements-RequirementConstraintMembership-ownedConstraint", declaring_metaclass: "RequirementConstraintMembership", name: "ownedConstraint", target: "ConstraintUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedConstraint", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementConstraintMembership-referencedConstraint", declaring_metaclass: "RequirementConstraintMembership", name: "referencedConstraint", target: "ConstraintUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencedConstraint"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-actorParameter", declaring_metaclass: "RequirementDefinition", name: "actorParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["actorParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-assumedConstraint", declaring_metaclass: "RequirementDefinition", name: "assumedConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["assumedConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-framedConcern", declaring_metaclass: "RequirementDefinition", name: "framedConcern", target: "ConcernUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["framedConcern"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-reqId", declaring_metaclass: "RequirementDefinition", name: "reqId", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["reqId", "declaredShortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-requiredConstraint", declaring_metaclass: "RequirementDefinition", name: "requiredConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["requiredConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-stakeholderParameter", declaring_metaclass: "RequirementDefinition", name: "stakeholderParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["stakeholderParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-subjectParameter", declaring_metaclass: "RequirementDefinition", name: "subjectParameter", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["subjectParameter"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementDefinition-text", declaring_metaclass: "RequirementDefinition", name: "text", target: "String", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["text"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-actorParameter", declaring_metaclass: "RequirementUsage", name: "actorParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["actorParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-assumedConstraint", declaring_metaclass: "RequirementUsage", name: "assumedConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["assumedConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-framedConcern", declaring_metaclass: "RequirementUsage", name: "framedConcern", target: "ConcernUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["framedConcern"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-reqId", declaring_metaclass: "RequirementUsage", name: "reqId", target: "String", derived: false, lower: 0, upper: Some(1), default_json: None, storage_names: &["reqId", "declaredShortName"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-requiredConstraint", declaring_metaclass: "RequirementUsage", name: "requiredConstraint", target: "ConstraintUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["requiredConstraint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-requirementDefinition", declaring_metaclass: "RequirementUsage", name: "requirementDefinition", target: "RequirementDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["requirementDefinition", "behavior", "constraintDefinition", "function", "predicate"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-stakeholderParameter", declaring_metaclass: "RequirementUsage", name: "stakeholderParameter", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["stakeholderParameter"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-subjectParameter", declaring_metaclass: "RequirementUsage", name: "subjectParameter", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["subjectParameter"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-RequirementUsage-text", declaring_metaclass: "RequirementUsage", name: "text", target: "String", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["text"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-SatisfyRequirementUsage-satisfiedRequirement", declaring_metaclass: "SatisfyRequirementUsage", name: "satisfiedRequirement", target: "RequirementUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["satisfiedRequirement", "assertedConstraint"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-SatisfyRequirementUsage-satisfyingFeature", declaring_metaclass: "SatisfyRequirementUsage", name: "satisfyingFeature", target: "Feature", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["satisfyingFeature"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-StakeholderMembership-ownedStakeholderParameter", declaring_metaclass: "StakeholderMembership", name: "ownedStakeholderParameter", target: "PartUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedStakeholderParameter", "memberElement", "ownedMemberElement", "ownedMemberFeature", "ownedMemberParameter", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Requirements-SubjectMembership-ownedSubjectParameter", declaring_metaclass: "SubjectMembership", name: "ownedSubjectParameter", target: "Usage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedSubjectParameter", "memberElement", "ownedMemberElement", "ownedMemberFeature", "ownedMemberParameter", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-ExhibitStateUsage-exhibitedState", declaring_metaclass: "ExhibitStateUsage", name: "exhibitedState", target: "StateUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["exhibitedState", "eventOccurrence", "performedAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateDefinition-doAction", declaring_metaclass: "StateDefinition", name: "doAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["doAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateDefinition-entryAction", declaring_metaclass: "StateDefinition", name: "entryAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["entryAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateDefinition-exitAction", declaring_metaclass: "StateDefinition", name: "exitAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["exitAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateDefinition-isParallel", declaring_metaclass: "StateDefinition", name: "isParallel", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isParallel"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateDefinition-state", declaring_metaclass: "StateDefinition", name: "state", target: "StateUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["state"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateSubactionMembership-action", declaring_metaclass: "StateSubactionMembership", name: "action", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["action", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateSubactionMembership-kind", declaring_metaclass: "StateSubactionMembership", name: "kind", target: "StateSubactionKind", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["kind"], unique: true, ordered: false, enum_values: &["entry", "do", "exit"] },
+    PropertySpec { id: "Systems-States-StateUsage-doAction", declaring_metaclass: "StateUsage", name: "doAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["doAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateUsage-entryAction", declaring_metaclass: "StateUsage", name: "entryAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["entryAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateUsage-exitAction", declaring_metaclass: "StateUsage", name: "exitAction", target: "ActionUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["exitAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateUsage-isParallel", declaring_metaclass: "StateUsage", name: "isParallel", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("false"), storage_names: &["isParallel"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-StateUsage-stateDefinition", declaring_metaclass: "StateUsage", name: "stateDefinition", target: "Behavior", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["stateDefinition", "actionDefinition", "behavior", "definition", "occurrenceDefinition", "type"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionFeatureMembership-kind", declaring_metaclass: "TransitionFeatureMembership", name: "kind", target: "TransitionFeatureKind", derived: false, lower: 1, upper: Some(1), default_json: None, storage_names: &["kind"], unique: true, ordered: false, enum_values: &["trigger", "guard", "effect"] },
+    PropertySpec { id: "Systems-States-TransitionFeatureMembership-transitionFeature", declaring_metaclass: "TransitionFeatureMembership", name: "transitionFeature", target: "Step", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["transitionFeature", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-effectAction", declaring_metaclass: "TransitionUsage", name: "effectAction", target: "ActionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["effectAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-guardExpression", declaring_metaclass: "TransitionUsage", name: "guardExpression", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["guardExpression"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-source", declaring_metaclass: "TransitionUsage", name: "source", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["source"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-succession", declaring_metaclass: "TransitionUsage", name: "succession", target: "Succession", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["succession"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-target", declaring_metaclass: "TransitionUsage", name: "target", target: "ActionUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-States-TransitionUsage-triggerAction", declaring_metaclass: "TransitionUsage", name: "triggerAction", target: "AcceptActionUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["triggerAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-UseCases-IncludeUseCaseUsage-useCaseIncluded", declaring_metaclass: "IncludeUseCaseUsage", name: "useCaseIncluded", target: "UseCaseUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["useCaseIncluded", "eventOccurrence", "performedAction"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-UseCases-UseCaseDefinition-includedUseCase", declaring_metaclass: "UseCaseDefinition", name: "includedUseCase", target: "UseCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["includedUseCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-UseCases-UseCaseUsage-includedUseCase", declaring_metaclass: "UseCaseUsage", name: "includedUseCase", target: "UseCaseUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["includedUseCase"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-UseCases-UseCaseUsage-useCaseDefinition", declaring_metaclass: "UseCaseUsage", name: "useCaseDefinition", target: "UseCaseDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["useCaseDefinition", "actionDefinition", "behavior", "calculationDefinition", "caseDefinition", "definition", "function", "occurrenceDefinition", "type"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-VerificationCases-RequirementVerificationMembership-kind", declaring_metaclass: "RequirementVerificationMembership", name: "kind", target: "RequirementConstraintKind", derived: false, lower: 1, upper: Some(1), default_json: Some("\"requirement\""), storage_names: &["kind"], unique: true, ordered: false, enum_values: &["assumption", "requirement"] },
+    PropertySpec { id: "Systems-VerificationCases-RequirementVerificationMembership-ownedRequirement", declaring_metaclass: "RequirementVerificationMembership", name: "ownedRequirement", target: "RequirementUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedRequirement", "memberElement", "ownedConstraint", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-VerificationCases-RequirementVerificationMembership-verifiedRequirement", declaring_metaclass: "RequirementVerificationMembership", name: "verifiedRequirement", target: "RequirementUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["verifiedRequirement", "referencedConstraint"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-VerificationCases-VerificationCaseDefinition-verifiedRequirement", declaring_metaclass: "VerificationCaseDefinition", name: "verifiedRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["verifiedRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-VerificationCases-VerificationCaseUsage-verificationCaseDefinition", declaring_metaclass: "VerificationCaseUsage", name: "verificationCaseDefinition", target: "VerificationCaseDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["verificationCaseDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-VerificationCases-VerificationCaseUsage-verifiedRequirement", declaring_metaclass: "VerificationCaseUsage", name: "verifiedRequirement", target: "RequirementUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["verifiedRequirement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-Expose-isImportAll", declaring_metaclass: "Expose", name: "isImportAll", target: "Boolean", derived: false, lower: 1, upper: Some(1), default_json: Some("true"), storage_names: &["isImportAll"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-Expose-visibility", declaring_metaclass: "Expose", name: "visibility", target: "VisibilityKind", derived: false, lower: 1, upper: Some(1), default_json: Some("\"protected\""), storage_names: &["visibility"], unique: true, ordered: false, enum_values: &["private", "protected", "public"] },
+    PropertySpec { id: "Systems-Views-RenderingDefinition-rendering", declaring_metaclass: "RenderingDefinition", name: "rendering", target: "RenderingUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["rendering"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-RenderingUsage-renderingDefinition", declaring_metaclass: "RenderingUsage", name: "renderingDefinition", target: "RenderingDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["renderingDefinition", "partDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewDefinition-satisfiedViewpoint", declaring_metaclass: "ViewDefinition", name: "satisfiedViewpoint", target: "ViewpointUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["satisfiedViewpoint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewDefinition-view", declaring_metaclass: "ViewDefinition", name: "view", target: "ViewUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["view"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewDefinition-viewCondition", declaring_metaclass: "ViewDefinition", name: "viewCondition", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["viewCondition"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewDefinition-viewRendering", declaring_metaclass: "ViewDefinition", name: "viewRendering", target: "RenderingUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["viewRendering"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewRenderingMembership-ownedRendering", declaring_metaclass: "ViewRenderingMembership", name: "ownedRendering", target: "RenderingUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["ownedRendering", "memberElement", "ownedMemberElement", "ownedMemberFeature", "target"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewRenderingMembership-referencedRendering", declaring_metaclass: "ViewRenderingMembership", name: "referencedRendering", target: "RenderingUsage", derived: true, lower: 1, upper: Some(1), default_json: None, storage_names: &["referencedRendering"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewUsage-exposedElement", declaring_metaclass: "ViewUsage", name: "exposedElement", target: "Element", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["exposedElement"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewUsage-satisfiedViewpoint", declaring_metaclass: "ViewUsage", name: "satisfiedViewpoint", target: "ViewpointUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["satisfiedViewpoint"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewUsage-viewCondition", declaring_metaclass: "ViewUsage", name: "viewCondition", target: "Expression", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["viewCondition"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewUsage-viewDefinition", declaring_metaclass: "ViewUsage", name: "viewDefinition", target: "ViewDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["viewDefinition", "partDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewUsage-viewRendering", declaring_metaclass: "ViewUsage", name: "viewRendering", target: "RenderingUsage", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["viewRendering"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewpointDefinition-viewpointStakeholder", declaring_metaclass: "ViewpointDefinition", name: "viewpointStakeholder", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["viewpointStakeholder"], unique: true, ordered: true, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewpointUsage-viewpointDefinition", declaring_metaclass: "ViewpointUsage", name: "viewpointDefinition", target: "ViewpointDefinition", derived: true, lower: 0, upper: Some(1), default_json: None, storage_names: &["viewpointDefinition", "behavior", "constraintDefinition", "function", "predicate", "requirementDefinition"], unique: true, ordered: false, enum_values: &[] },
+    PropertySpec { id: "Systems-Views-ViewpointUsage-viewpointStakeholder", declaring_metaclass: "ViewpointUsage", name: "viewpointStakeholder", target: "PartUsage", derived: true, lower: 0, upper: None, default_json: None, storage_names: &["viewpointStakeholder"], unique: true, ordered: true, enum_values: &[] },
+];
+
+/// One visible property of a metaclass: the `PROPERTIES` index of the
+/// declaration its name resolves to, then of the most specific
+/// redefinition (`u16::MAX` when redefinitions are incomparable). Rows
+/// sort by the requested declaration's name, which is their lookup key.
+pub type PropertyRow = (u16, u16);
+pub type ClassProperties = (&'static str, &'static [PropertyRow]);
+#[rustfmt::skip]
+pub static CLASSES: &[ClassProperties] = &[
+    ("AcceptActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (210, 210), // payloadArgument
+        (211, 211), // payloadParameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (212, 212), // receiverArgument
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ActionDefinition", &[
+        (213, 213), // action
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ActorMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 350), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (350, 350), // ownedActorParameter
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 350), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 350), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (97, 350), // ownedMemberParameter
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 350), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("AllocationDefinition", &[
+        (163, 163), // aliasIds
+        (232, 232), // allocation
+        (91, 249), // associationEnd
+        (249, 249), // connectionEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 249), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (250, 250), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("AllocationUsage", &[
+        (163, 163), // aliasIds
+        (233, 233), // allocationDefinition
+        (100, 233), // association
+        (7, 7), // chainingFeature
+        (251, 233), // connectionDefinition
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 341), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 233), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("AnalysisCaseDefinition", &[
+        (213, 213), // action
+        (241, 241), // actorParameter
+        (163, 163), // aliasIds
+        (239, 239), // calculation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (242, 242), // objectiveRequirement
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (234, 234), // resultExpression
+        (179, 179), // shortName
+        (96, 96), // step
+        (243, 243), // subjectParameter
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("AnalysisCaseUsage", &[
+        (214, 235), // actionDefinition
+        (244, 244), // actorParameter
+        (163, 163), // aliasIds
+        (235, 235), // analysisCaseDefinition
+        (98, 235), // behavior
+        (240, 235), // calculationDefinition
+        (245, 235), // caseDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 235), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 235), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (246, 246), // objectiveRequirement
+        (339, 235), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (236, 236), // resultExpression
+        (179, 179), // shortName
+        (247, 247), // subjectParameter
+        (180, 180), // textualRepresentation
+        (31, 235), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("AnnotatingElement", &[
+        (163, 163), // aliasIds
+        (146, 146), // annotatedElement
+        (147, 147), // annotation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("Annotation", &[
+        (163, 163), // aliasIds
+        (150, 150), // annotatedElement
+        (151, 151), // annotatingElement
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (152, 152), // ownedAnnotatingElement
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (153, 153), // owningAnnotatedElement
+        (154, 154), // owningAnnotatingElement
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 151), // source
+        (186, 150), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("AssertConstraintUsage", &[
+        (163, 163), // aliasIds
+        (252, 252), // assertedConstraint
+        (98, 253), // behavior
+        (7, 7), // chainingFeature
+        (253, 253), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 253), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (131, 131), // isNegated
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 253), // predicate
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("AssignmentActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (215, 215), // referent
+        (179, 179), // shortName
+        (216, 216), // targetArgument
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (217, 217), // valueExpression
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Association", &[
+        (163, 163), // aliasIds
+        (91, 91), // associationEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 91), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("AssociationStructure", &[
+        (163, 163), // aliasIds
+        (91, 91), // associationEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 91), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("AttributeDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("AttributeUsage", &[
+        (163, 163), // aliasIds
+        (237, 237), // attributeDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 237), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (238, 238), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 237), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Behavior", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("BindingConnector", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 100), // type
+        (88, 88), // unioningType
+    ]),
+    ("BindingConnectorAsUsage", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 287), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 65535), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("BooleanExpression", &[
+        (163, 163), // aliasIds
+        (98, 124), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 124), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (124, 124), // predicate
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("CalculationDefinition", &[
+        (213, 213), // action
+        (163, 163), // aliasIds
+        (239, 239), // calculation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("CalculationUsage", &[
+        (214, 240), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 240), // behavior
+        (240, 240), // calculationDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 240), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 240), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 240), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 240), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("CaseDefinition", &[
+        (213, 213), // action
+        (241, 241), // actorParameter
+        (163, 163), // aliasIds
+        (239, 239), // calculation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (242, 242), // objectiveRequirement
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (243, 243), // subjectParameter
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("CaseUsage", &[
+        (214, 245), // actionDefinition
+        (244, 244), // actorParameter
+        (163, 163), // aliasIds
+        (98, 245), // behavior
+        (240, 245), // calculationDefinition
+        (245, 245), // caseDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 245), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 245), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (246, 246), // objectiveRequirement
+        (339, 245), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (247, 247), // subjectParameter
+        (180, 180), // textualRepresentation
+        (31, 245), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Class", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("Classifier", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("CollectExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (106, 106), // operator
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("Comment", &[
+        (163, 163), // aliasIds
+        (146, 146), // annotatedElement
+        (147, 147), // annotation
+        (155, 155), // body
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (156, 156), // locale
+        (170, 170), // name
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("ConcernDefinition", &[
+        (358, 358), // actorParameter
+        (163, 163), // aliasIds
+        (359, 359), // assumedConstraint
+        (164, 164), // declaredName
+        (165, 361), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (360, 360), // framedConcern
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (361, 361), // reqId
+        (362, 362), // requiredConstraint
+        (130, 130), // result
+        (179, 179), // shortName
+        (363, 363), // stakeholderParameter
+        (96, 96), // step
+        (364, 364), // subjectParameter
+        (365, 365), // text
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ConcernUsage", &[
+        (366, 366), // actorParameter
+        (163, 163), // aliasIds
+        (367, 367), // assumedConstraint
+        (98, 351), // behavior
+        (7, 7), // chainingFeature
+        (351, 351), // concernDefinition
+        (253, 351), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 369), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (368, 368), // framedConcern
+        (125, 351), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 351), // predicate
+        (178, 178), // qualifiedName
+        (369, 369), // reqId
+        (370, 370), // requiredConstraint
+        (371, 351), // requirementDefinition
+        (127, 127), // result
+        (179, 179), // shortName
+        (372, 372), // stakeholderParameter
+        (373, 373), // subjectParameter
+        (374, 374), // text
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ConjugatedPortDefinition", &[
+        (163, 163), // aliasIds
+        (348, 348), // conjugatedPortDefinition
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (342, 342), // originalPortDefinition
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 343), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (343, 343), // ownedPortConjugator
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 342), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ConjugatedPortTyping", &[
+        (163, 163), // aliasIds
+        (344, 344), // conjugatedPortDefinition
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 344), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (37, 37), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 37), // owningType
+        (345, 345), // portDefinition
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 39), // source
+        (64, 39), // specific
+        (186, 344), // target
+        (180, 180), // textualRepresentation
+        (38, 344), // type
+        (39, 39), // typedFeature
+    ]),
+    ("Conjugation", &[
+        (163, 163), // aliasIds
+        (50, 50), // conjugatedType
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (51, 51), // originalType
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (52, 52), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 50), // source
+        (186, 51), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("ConnectionDefinition", &[
+        (163, 163), // aliasIds
+        (91, 249), // associationEnd
+        (249, 249), // connectionEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 249), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (250, 250), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ConnectionUsage", &[
+        (163, 163), // aliasIds
+        (100, 251), // association
+        (7, 7), // chainingFeature
+        (251, 251), // connectionDefinition
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 341), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 251), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Connector", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 100), // type
+        (88, 88), // unioningType
+    ]),
+    ("ConnectorAsUsage", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 287), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 65535), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ConstraintDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ConstraintUsage", &[
+        (163, 163), // aliasIds
+        (98, 253), // behavior
+        (7, 7), // chainingFeature
+        (253, 253), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 253), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 253), // predicate
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ConstructorExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("ControlNode", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("CrossSubsetting", &[
+        (163, 163), // aliasIds
+        (4, 4), // crossedFeature
+        (5, 5), // crossingFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 4), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (44, 5), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 5), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 5), // source
+        (64, 5), // specific
+        (45, 4), // subsettedFeature
+        (46, 5), // subsettingFeature
+        (186, 4), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("DataType", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("DecisionNode", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Definition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("Dependency", &[
+        (163, 163), // aliasIds
+        (161, 161), // client
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 161), // source
+        (162, 162), // supplier
+        (186, 162), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("Differencing", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (53, 53), // differencingType
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 54), // source
+        (186, 53), // target
+        (180, 180), // textualRepresentation
+        (54, 54), // typeDifferenced
+    ]),
+    ("Disjoining", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (55, 55), // disjoiningType
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (56, 56), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 57), // source
+        (186, 55), // target
+        (180, 180), // textualRepresentation
+        (57, 57), // typeDisjoined
+    ]),
+    ("Documentation", &[
+        (163, 163), // aliasIds
+        (146, 157), // annotatedElement
+        (147, 147), // annotation
+        (155, 155), // body
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (157, 157), // documentedElement
+        (167, 167), // elementId
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (156, 156), // locale
+        (170, 170), // name
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("Element", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("ElementFilterMembership", &[
+        (163, 163), // aliasIds
+        (143, 143), // condition
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 143), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 196), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 143), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 196), // source
+        (186, 143), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("EndFeatureMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 6), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 6), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (6, 6), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 6), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("EnumerationDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (325, 325), // enumeratedValue
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (326, 326), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 325), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("EnumerationUsage", &[
+        (163, 163), // aliasIds
+        (237, 327), // attributeDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 327), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (327, 327), // enumerationDefinition
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (238, 238), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 327), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("EventOccurrenceUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (334, 334), // eventOccurrence
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (335, 335), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ExhibitStateUsage", &[
+        (214, 391), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 391), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 391), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (387, 387), // doAction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (388, 388), // entryAction
+        (334, 379), // eventOccurrence
+        (379, 379), // exhibitedState
+        (389, 389), // exitAction
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (390, 390), // isParallel
+        (18, 18), // isPortion
+        (335, 335), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 391), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (224, 379), // performedAction
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (391, 391), // stateDefinition
+        (180, 180), // textualRepresentation
+        (31, 391), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Expose", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (410, 410), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 186), // target
+        (180, 180), // textualRepresentation
+        (411, 411), // visibility
+    ]),
+    ("Expression", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("Feature", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("FeatureChainExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (107, 107), // operator
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (108, 108), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("FeatureChaining", &[
+        (163, 163), // aliasIds
+        (32, 32), // chainingFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (33, 33), // featureChained
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 33), // source
+        (186, 32), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("FeatureInverting", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (34, 34), // featureInverted
+        (35, 35), // invertingFeature
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (36, 36), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 34), // source
+        (186, 35), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("FeatureMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 58), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 58), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 58), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 58), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("FeatureReferenceExpression", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (109, 109), // referent
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("FeatureTyping", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 38), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (37, 37), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 37), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 39), // source
+        (64, 39), // specific
+        (186, 38), // target
+        (180, 180), // textualRepresentation
+        (38, 38), // type
+        (39, 39), // typedFeature
+    ]),
+    ("FeatureValue", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (120, 120), // featureWithValue
+        (121, 121), // isDefault
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (122, 122), // isInitial
+        (169, 169), // isLibraryElement
+        (192, 123), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 196), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 123), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 196), // source
+        (186, 123), // target
+        (180, 180), // textualRepresentation
+        (123, 123), // value
+        (197, 197), // visibility
+    ]),
+    ("Flow", &[
+        (163, 163), // aliasIds
+        (100, 134), // association
+        (98, 134), // behavior
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (133, 133), // flowEnd
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (134, 134), // interaction
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (135, 135), // payloadFeature
+        (136, 136), // payloadType
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (137, 137), // sourceOutputFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (138, 138), // targetInputFeature
+        (180, 180), // textualRepresentation
+        (31, 134), // type
+        (88, 88), // unioningType
+    ]),
+    ("FlowDefinition", &[
+        (213, 213), // action
+        (163, 163), // aliasIds
+        (91, 328), // associationEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 328), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (328, 328), // flowEnd
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (96, 96), // step
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("FlowEnd", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("FlowUsage", &[
+        (214, 329), // actionDefinition
+        (163, 163), // aliasIds
+        (100, 329), // association
+        (98, 329), // behavior
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 329), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (329, 329), // flowDefinition
+        (133, 133), // flowEnd
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (134, 329), // interaction
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 329), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (135, 135), // payloadFeature
+        (136, 136), // payloadType
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (137, 137), // sourceOutputFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (138, 138), // targetInputFeature
+        (180, 180), // textualRepresentation
+        (31, 329), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ForLoopActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (223, 223), // bodyAction
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (218, 218), // loopVariable
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (219, 219), // seqArgument
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("ForkNode", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("FramedConcernMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (352, 352), // kind
+        (192, 353), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (353, 353), // ownedConcern
+        (356, 353), // ownedConstraint
+        (172, 172), // ownedElement
+        (206, 353), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 353), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (354, 354), // referencedConcern
+        (357, 354), // referencedConstraint
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 353), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("Function", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("IfActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (220, 220), // elseAction
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (221, 221), // ifArgument
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (222, 222), // thenAction
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Import", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (189, 189), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 186), // target
+        (180, 180), // textualRepresentation
+        (191, 191), // visibility
+    ]),
+    ("IncludeUseCaseUsage", &[
+        (214, 403), // actionDefinition
+        (244, 244), // actorParameter
+        (163, 163), // aliasIds
+        (98, 403), // behavior
+        (240, 403), // calculationDefinition
+        (245, 403), // caseDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 403), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (334, 400), // eventOccurrence
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 403), // function
+        (199, 199), // importedMembership
+        (402, 402), // includedUseCase
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (335, 335), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (246, 246), // objectiveRequirement
+        (339, 403), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (224, 400), // performedAction
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (247, 247), // subjectParameter
+        (180, 180), // textualRepresentation
+        (31, 403), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (403, 403), // useCaseDefinition
+        (400, 400), // useCaseIncluded
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("IndexExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (110, 110), // operator
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("InstantiationExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("Interaction", &[
+        (163, 163), // aliasIds
+        (91, 91), // associationEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 91), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (96, 96), // step
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("InterfaceDefinition", &[
+        (163, 163), // aliasIds
+        (91, 330), // associationEnd
+        (249, 330), // connectionEnd
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 330), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (330, 330), // interfaceEnd
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (250, 250), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 92), // relatedElement
+        (92, 92), // relatedType
+        (179, 179), // shortName
+        (185, 93), // source
+        (93, 93), // sourceType
+        (186, 94), // target
+        (94, 94), // targetType
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("InterfaceUsage", &[
+        (163, 163), // aliasIds
+        (100, 331), // association
+        (7, 7), // chainingFeature
+        (251, 331), // connectionDefinition
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (331, 331), // interfaceDefinition
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 341), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 331), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Intersecting", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (60, 60), // intersectingType
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 61), // source
+        (186, 60), // target
+        (180, 180), // textualRepresentation
+        (61, 61), // typeIntersected
+    ]),
+    ("Invariant", &[
+        (163, 163), // aliasIds
+        (98, 124), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 124), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (131, 131), // isNegated
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (124, 124), // predicate
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("InvocationExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("ItemDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("ItemUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("JoinNode", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("LibraryPackage", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (145, 145), // filterCondition
+        (199, 199), // importedMembership
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (144, 144), // isStandard
+        (200, 200), // member
+        (201, 201), // membership
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (202, 202), // ownedImport
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("LiteralBoolean", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+        (113, 113), // value
+    ]),
+    ("LiteralExpression", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("LiteralInfinity", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("LiteralInteger", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+        (114, 114), // value
+    ]),
+    ("LiteralRational", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+        (115, 115), // value
+    ]),
+    ("LiteralString", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+        (116, 116), // value
+    ]),
+    ("LoopActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (223, 223), // bodyAction
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Membership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 192), // memberElement
+        (193, 193), // memberElementId
+        (194, 194), // memberName
+        (195, 195), // memberShortName
+        (196, 196), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 196), // source
+        (186, 192), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("MembershipExpose", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (198, 198), // importedMembership
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (410, 410), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 198), // target
+        (180, 180), // textualRepresentation
+        (411, 411), // visibility
+    ]),
+    ("MembershipImport", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (198, 198), // importedMembership
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (189, 189), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 198), // target
+        (180, 180), // textualRepresentation
+        (191, 191), // visibility
+    ]),
+    ("MergeNode", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Metaclass", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("MetadataAccessExpression", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (117, 117), // referencedElement
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("MetadataDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("MetadataFeature", &[
+        (163, 163), // aliasIds
+        (146, 146), // annotatedElement
+        (147, 147), // annotation
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (139, 139), // metaclass
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("MetadataUsage", &[
+        (163, 163), // aliasIds
+        (146, 146), // annotatedElement
+        (147, 147), // annotation
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 333), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (139, 333), // metaclass
+        (333, 333), // metadataDefinition
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Multiplicity", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("MultiplicityRange", &[
+        (163, 163), // aliasIds
+        (140, 140), // bound
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (141, 141), // lowerBound
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+        (142, 142), // upperBound
+    ]),
+    ("Namespace", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (199, 199), // importedMembership
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (200, 200), // member
+        (201, 201), // membership
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (202, 202), // ownedImport
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("NamespaceExpose", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (205, 205), // importedNamespace
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (410, 410), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 205), // target
+        (180, 180), // textualRepresentation
+        (411, 411), // visibility
+    ]),
+    ("NamespaceImport", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (187, 187), // importOwningNamespace
+        (188, 188), // importedElement
+        (205, 205), // importedNamespace
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (189, 189), // isImportAll
+        (169, 169), // isLibraryElement
+        (190, 190), // isRecursive
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 187), // source
+        (186, 205), // target
+        (180, 180), // textualRepresentation
+        (191, 191), // visibility
+    ]),
+    ("NullExpression", &[
+        (163, 163), // aliasIds
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("ObjectiveMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 248), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 248), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 248), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (248, 248), // ownedObjectiveRequirement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 248), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("OccurrenceDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("OccurrenceUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("OperatorExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (118, 118), // operator
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("OwningMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 206), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 196), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 206), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 196), // source
+        (186, 206), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("Package", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (145, 145), // filterCondition
+        (199, 199), // importedMembership
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (200, 200), // member
+        (201, 201), // membership
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (202, 202), // ownedImport
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("ParameterMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 97), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 97), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 97), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (97, 97), // ownedMemberParameter
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 97), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("PartDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("PartUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 341), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("PayloadFeature", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("PerformActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (334, 224), // eventOccurrence
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (335, 335), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (224, 224), // performedAction
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("PortConjugation", &[
+        (163, 163), // aliasIds
+        (346, 346), // conjugatedPortDefinition
+        (50, 50), // conjugatedType
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (347, 347), // originalPortDefinition
+        (51, 347), // originalType
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (52, 346), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 50), // source
+        (186, 347), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("PortDefinition", &[
+        (163, 163), // aliasIds
+        (348, 348), // conjugatedPortDefinition
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("PortUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 349), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 349), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (349, 349), // portDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 349), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Predicate", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("Redefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 40), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (44, 44), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 44), // owningType
+        (178, 178), // qualifiedName
+        (40, 40), // redefinedFeature
+        (41, 41), // redefiningFeature
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 41), // source
+        (64, 41), // specific
+        (45, 40), // subsettedFeature
+        (46, 41), // subsettingFeature
+        (186, 40), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("ReferenceSubsetting", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 42), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (44, 43), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 43), // owningType
+        (178, 178), // qualifiedName
+        (42, 42), // referencedFeature
+        (43, 43), // referencingFeature
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 43), // source
+        (64, 43), // specific
+        (45, 42), // subsettedFeature
+        (46, 43), // subsettingFeature
+        (186, 42), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("ReferenceUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 287), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (286, 286), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 287), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Relationship", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 185), // source
+        (186, 186), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("RenderingDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (412, 412), // rendering
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("RenderingUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 413), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (413, 413), // renderingDefinition
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("RequirementConstraintMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (355, 355), // kind
+        (192, 356), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (356, 356), // ownedConstraint
+        (172, 172), // ownedElement
+        (206, 356), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 356), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (357, 357), // referencedConstraint
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 356), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("RequirementDefinition", &[
+        (358, 358), // actorParameter
+        (163, 163), // aliasIds
+        (359, 359), // assumedConstraint
+        (164, 164), // declaredName
+        (165, 361), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (360, 360), // framedConcern
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (361, 361), // reqId
+        (362, 362), // requiredConstraint
+        (130, 130), // result
+        (179, 179), // shortName
+        (363, 363), // stakeholderParameter
+        (96, 96), // step
+        (364, 364), // subjectParameter
+        (365, 365), // text
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("RequirementUsage", &[
+        (366, 366), // actorParameter
+        (163, 163), // aliasIds
+        (367, 367), // assumedConstraint
+        (98, 371), // behavior
+        (7, 7), // chainingFeature
+        (253, 371), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 369), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (368, 368), // framedConcern
+        (125, 371), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 371), // predicate
+        (178, 178), // qualifiedName
+        (369, 369), // reqId
+        (370, 370), // requiredConstraint
+        (371, 371), // requirementDefinition
+        (127, 127), // result
+        (179, 179), // shortName
+        (372, 372), // stakeholderParameter
+        (373, 373), // subjectParameter
+        (374, 374), // text
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("RequirementVerificationMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (404, 404), // kind
+        (192, 405), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (356, 405), // ownedConstraint
+        (172, 172), // ownedElement
+        (206, 405), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 405), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (405, 405), // ownedRequirement
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (357, 406), // referencedConstraint
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 405), // target
+        (180, 180), // textualRepresentation
+        (406, 406), // verifiedRequirement
+        (197, 197), // visibility
+    ]),
+    ("ResultExpressionMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 132), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 132), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 132), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (132, 132), // ownedResultExpression
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 132), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("ReturnParameterMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 97), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 97), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 97), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (97, 97), // ownedMemberParameter
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 97), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("SatisfyRequirementUsage", &[
+        (366, 366), // actorParameter
+        (163, 163), // aliasIds
+        (252, 375), // assertedConstraint
+        (367, 367), // assumedConstraint
+        (98, 371), // behavior
+        (7, 7), // chainingFeature
+        (253, 371), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 369), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (368, 368), // framedConcern
+        (125, 371), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (131, 131), // isNegated
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 371), // predicate
+        (178, 178), // qualifiedName
+        (369, 369), // reqId
+        (370, 370), // requiredConstraint
+        (371, 371), // requirementDefinition
+        (127, 127), // result
+        (375, 375), // satisfiedRequirement
+        (376, 376), // satisfyingFeature
+        (179, 179), // shortName
+        (372, 372), // stakeholderParameter
+        (373, 373), // subjectParameter
+        (374, 374), // text
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("SelectExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (119, 119), // operator
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("SendActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (225, 225), // payloadArgument
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (226, 226), // receiverArgument
+        (227, 227), // senderArgument
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Specialization", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 62), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 63), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 64), // source
+        (64, 64), // specific
+        (186, 62), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("StakeholderMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 377), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 377), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 377), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (97, 377), // ownedMemberParameter
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (377, 377), // ownedStakeholderParameter
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 377), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("StateDefinition", &[
+        (213, 213), // action
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (380, 380), // doAction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (381, 381), // entryAction
+        (382, 382), // exitAction
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (383, 383), // isParallel
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (384, 384), // state
+        (96, 96), // step
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("StateSubactionMembership", &[
+        (385, 385), // action
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (386, 386), // kind
+        (192, 385), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 385), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 385), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 385), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("StateUsage", &[
+        (214, 391), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 391), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 391), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (387, 387), // doAction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (388, 388), // entryAction
+        (389, 389), // exitAction
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (390, 390), // isParallel
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 391), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (391, 391), // stateDefinition
+        (180, 180), // textualRepresentation
+        (31, 391), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("Step", &[
+        (163, 163), // aliasIds
+        (98, 98), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("Structure", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (0, 0), // ownedSubclassification
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("Subclassification", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 3), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (1, 1), // owningClassifier
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 1), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 2), // source
+        (64, 2), // specific
+        (2, 2), // subclassifier
+        (3, 3), // superclassifier
+        (186, 3), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("SubjectMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 378), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 378), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 378), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (97, 378), // ownedMemberParameter
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (378, 378), // ownedSubjectParameter
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 378), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("Subsetting", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (62, 45), // general
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (44, 44), // owningFeature
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (63, 44), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 46), // source
+        (64, 46), // specific
+        (45, 45), // subsettedFeature
+        (46, 46), // subsettingFeature
+        (186, 45), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("Succession", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 100), // type
+        (88, 88), // unioningType
+    ]),
+    ("SuccessionAsUsage", &[
+        (163, 163), // aliasIds
+        (100, 100), // association
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 287), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (180, 180), // textualRepresentation
+        (31, 65535), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("SuccessionFlow", &[
+        (163, 163), // aliasIds
+        (100, 134), // association
+        (98, 134), // behavior
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (133, 133), // flowEnd
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (134, 134), // interaction
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (135, 135), // payloadFeature
+        (136, 136), // payloadType
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (137, 137), // sourceOutputFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (138, 138), // targetInputFeature
+        (180, 180), // textualRepresentation
+        (31, 134), // type
+        (88, 88), // unioningType
+    ]),
+    ("SuccessionFlowUsage", &[
+        (214, 329), // actionDefinition
+        (163, 163), // aliasIds
+        (100, 329), // association
+        (98, 329), // behavior
+        (7, 7), // chainingFeature
+        (101, 101), // connectorEnd
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (102, 102), // defaultFeaturingType
+        (287, 329), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 101), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (329, 329), // flowDefinition
+        (133, 133), // flowEnd
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (134, 329), // interaction
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 329), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (135, 135), // payloadFeature
+        (136, 136), // payloadType
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (184, 103), // relatedElement
+        (103, 103), // relatedFeature
+        (179, 179), // shortName
+        (185, 104), // source
+        (104, 104), // sourceFeature
+        (137, 137), // sourceOutputFeature
+        (186, 105), // target
+        (105, 105), // targetFeature
+        (138, 138), // targetInputFeature
+        (180, 180), // textualRepresentation
+        (31, 329), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("TerminateActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (228, 228), // terminatedOccurrenceArgument
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("TextualRepresentation", &[
+        (163, 163), // aliasIds
+        (146, 160), // annotatedElement
+        (147, 147), // annotation
+        (158, 158), // body
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (159, 159), // language
+        (170, 170), // name
+        (148, 148), // ownedAnnotatingRelationship
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (149, 149), // owningAnnotatingRelationship
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (160, 160), // representedElement
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+    ]),
+    ("TransitionFeatureMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (392, 392), // kind
+        (192, 393), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 393), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 393), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 393), // target
+        (180, 180), // textualRepresentation
+        (393, 393), // transitionFeature
+        (197, 197), // visibility
+    ]),
+    ("TransitionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (394, 394), // effectAction
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (395, 395), // guardExpression
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (396, 396), // source
+        (397, 397), // succession
+        (398, 398), // target
+        (180, 180), // textualRepresentation
+        (399, 399), // triggerAction
+        (31, 214), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("TriggerInvocationExpression", &[
+        (163, 163), // aliasIds
+        (111, 111), // argument
+        (98, 125), // behavior
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 125), // function
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (112, 112), // instantiatedType
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 20), // isVariable
+        (229, 229), // kind
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (99, 99), // parameter
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 31), // type
+        (88, 88), // unioningType
+    ]),
+    ("Type", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+    ]),
+    ("TypeFeaturing", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (47, 47), // featureOfType
+        (48, 48), // featuringType
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (49, 49), // owningFeatureOfType
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 47), // source
+        (186, 48), // target
+        (180, 180), // textualRepresentation
+    ]),
+    ("Unioning", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 89), // source
+        (186, 90), // target
+        (180, 180), // textualRepresentation
+        (89, 89), // typeUnioned
+        (90, 90), // unioningType
+    ]),
+    ("Usage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 287), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 287), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("UseCaseDefinition", &[
+        (213, 213), // action
+        (241, 241), // actorParameter
+        (163, 163), // aliasIds
+        (239, 239), // calculation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (401, 401), // includedUseCase
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (242, 242), // objectiveRequirement
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (243, 243), // subjectParameter
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+    ]),
+    ("UseCaseUsage", &[
+        (214, 403), // actionDefinition
+        (244, 244), // actorParameter
+        (163, 163), // aliasIds
+        (98, 403), // behavior
+        (240, 403), // calculationDefinition
+        (245, 403), // caseDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 403), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 403), // function
+        (199, 199), // importedMembership
+        (402, 402), // includedUseCase
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (246, 246), // objectiveRequirement
+        (339, 403), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (247, 247), // subjectParameter
+        (180, 180), // textualRepresentation
+        (31, 403), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (403, 403), // useCaseDefinition
+        (322, 322), // variant
+        (323, 323), // variantMembership
+    ]),
+    ("VariantMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 324), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 196), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 324), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (324, 324), // ownedVariantUsage
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 196), // source
+        (186, 324), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("VerificationCaseDefinition", &[
+        (213, 213), // action
+        (241, 241), // actorParameter
+        (163, 163), // aliasIds
+        (239, 239), // calculation
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (242, 242), // objectiveRequirement
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (130, 130), // result
+        (179, 179), // shortName
+        (96, 96), // step
+        (243, 243), // subjectParameter
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+        (407, 407), // verifiedRequirement
+    ]),
+    ("VerificationCaseUsage", &[
+        (214, 245), // actionDefinition
+        (244, 244), // actorParameter
+        (163, 163), // aliasIds
+        (98, 245), // behavior
+        (240, 245), // calculationDefinition
+        (245, 245), // caseDefinition
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 245), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (125, 245), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (246, 246), // objectiveRequirement
+        (339, 245), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (127, 127), // result
+        (179, 179), // shortName
+        (247, 247), // subjectParameter
+        (180, 180), // textualRepresentation
+        (31, 245), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+        (408, 408), // verificationCaseDefinition
+        (409, 409), // verifiedRequirement
+    ]),
+    ("ViewDefinition", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (178, 178), // qualifiedName
+        (414, 414), // satisfiedViewpoint
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+        (415, 415), // view
+        (416, 416), // viewCondition
+        (417, 417), // viewRendering
+    ]),
+    ("ViewRenderingMembership", &[
+        (163, 163), // aliasIds
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (181, 181), // isImplied
+        (168, 168), // isImpliedIncluded
+        (169, 169), // isLibraryElement
+        (192, 418), // memberElement
+        (193, 207), // memberElementId
+        (194, 208), // memberName
+        (195, 209), // memberShortName
+        (196, 59), // membershipOwningNamespace
+        (170, 170), // name
+        (171, 171), // ownedAnnotation
+        (172, 172), // ownedElement
+        (206, 418), // ownedMemberElement
+        (207, 207), // ownedMemberElementId
+        (58, 418), // ownedMemberFeature
+        (208, 208), // ownedMemberName
+        (209, 209), // ownedMemberShortName
+        (182, 182), // ownedRelatedElement
+        (173, 173), // ownedRelationship
+        (418, 418), // ownedRendering
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (183, 183), // owningRelatedElement
+        (177, 177), // owningRelationship
+        (59, 59), // owningType
+        (178, 178), // qualifiedName
+        (419, 419), // referencedRendering
+        (184, 184), // relatedElement
+        (179, 179), // shortName
+        (185, 59), // source
+        (186, 418), // target
+        (180, 180), // textualRepresentation
+        (197, 197), // visibility
+    ]),
+    ("ViewUsage", &[
+        (163, 163), // aliasIds
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 66), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (420, 420), // exposedElement
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (332, 332), // itemDefinition
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (341, 423), // partDefinition
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (421, 421), // satisfiedViewpoint
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+        (422, 422), // viewCondition
+        (423, 423), // viewDefinition
+        (424, 424), // viewRendering
+    ]),
+    ("ViewpointDefinition", &[
+        (358, 358), // actorParameter
+        (163, 163), // aliasIds
+        (359, 359), // assumedConstraint
+        (164, 164), // declaredName
+        (165, 361), // declaredShortName
+        (65, 65), // differencingType
+        (66, 95), // directedFeature
+        (254, 254), // directedUsage
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (128, 128), // expression
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (360, 360), // framedConcern
+        (199, 199), // importedMembership
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (75, 75), // isConjugated
+        (168, 168), // isImpliedIncluded
+        (336, 336), // isIndividual
+        (169, 169), // isLibraryElement
+        (129, 129), // isModelLevelEvaluable
+        (76, 76), // isSufficient
+        (255, 255), // isVariation
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (78, 78), // output
+        (256, 256), // ownedAction
+        (257, 257), // ownedAllocation
+        (258, 258), // ownedAnalysisCase
+        (171, 171), // ownedAnnotation
+        (259, 259), // ownedAttribute
+        (260, 260), // ownedCalculation
+        (261, 261), // ownedCase
+        (262, 262), // ownedConcern
+        (79, 79), // ownedConjugator
+        (263, 263), // ownedConnection
+        (264, 264), // ownedConstraint
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (265, 265), // ownedEnumeration
+        (83, 83), // ownedFeature
+        (84, 84), // ownedFeatureMembership
+        (266, 266), // ownedFlow
+        (202, 202), // ownedImport
+        (267, 267), // ownedInterface
+        (85, 85), // ownedIntersecting
+        (268, 268), // ownedItem
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (269, 269), // ownedMetadata
+        (270, 270), // ownedOccurrence
+        (271, 271), // ownedPart
+        (272, 272), // ownedPort
+        (273, 273), // ownedReference
+        (173, 173), // ownedRelationship
+        (274, 274), // ownedRendering
+        (275, 275), // ownedRequirement
+        (86, 86), // ownedSpecialization
+        (276, 276), // ownedState
+        (0, 0), // ownedSubclassification
+        (277, 277), // ownedTransition
+        (87, 87), // ownedUnioning
+        (278, 278), // ownedUsage
+        (279, 279), // ownedUseCase
+        (280, 280), // ownedVerificationCase
+        (281, 281), // ownedView
+        (282, 282), // ownedViewpoint
+        (174, 174), // owner
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (95, 95), // parameter
+        (178, 178), // qualifiedName
+        (361, 361), // reqId
+        (362, 362), // requiredConstraint
+        (130, 130), // result
+        (179, 179), // shortName
+        (363, 363), // stakeholderParameter
+        (96, 96), // step
+        (364, 364), // subjectParameter
+        (365, 365), // text
+        (180, 180), // textualRepresentation
+        (88, 88), // unioningType
+        (283, 283), // usage
+        (284, 284), // variant
+        (285, 285), // variantMembership
+        (425, 425), // viewpointStakeholder
+    ]),
+    ("ViewpointUsage", &[
+        (366, 366), // actorParameter
+        (163, 163), // aliasIds
+        (367, 367), // assumedConstraint
+        (98, 426), // behavior
+        (7, 7), // chainingFeature
+        (253, 426), // constraintDefinition
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 369), // declaredShortName
+        (287, 339), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (368, 368), // framedConcern
+        (125, 426), // function
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (126, 126), // isModelLevelEvaluable
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 339), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (124, 426), // predicate
+        (178, 178), // qualifiedName
+        (369, 369), // reqId
+        (370, 370), // requiredConstraint
+        (371, 426), // requirementDefinition
+        (127, 127), // result
+        (179, 179), // shortName
+        (372, 372), // stakeholderParameter
+        (373, 373), // subjectParameter
+        (374, 374), // text
+        (180, 180), // textualRepresentation
+        (31, 339), // type
+        (88, 88), // unioningType
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+        (426, 426), // viewpointDefinition
+        (427, 427), // viewpointStakeholder
+    ]),
+    ("WhileLoopActionUsage", &[
+        (214, 214), // actionDefinition
+        (163, 163), // aliasIds
+        (98, 214), // behavior
+        (223, 223), // bodyAction
+        (7, 7), // chainingFeature
+        (8, 8), // crossFeature
+        (164, 164), // declaredName
+        (165, 165), // declaredShortName
+        (287, 214), // definition
+        (65, 65), // differencingType
+        (66, 99), // directedFeature
+        (288, 288), // directedUsage
+        (9, 9), // direction
+        (166, 166), // documentation
+        (167, 167), // elementId
+        (67, 67), // endFeature
+        (10, 10), // endOwningType
+        (68, 68), // feature
+        (69, 69), // featureMembership
+        (11, 11), // featureTarget
+        (12, 12), // featuringType
+        (199, 199), // importedMembership
+        (337, 337), // individualDefinition
+        (70, 70), // inheritedFeature
+        (71, 71), // inheritedMembership
+        (72, 72), // input
+        (73, 73), // intersectingType
+        (74, 74), // isAbstract
+        (13, 13), // isComposite
+        (75, 75), // isConjugated
+        (14, 14), // isConstant
+        (15, 15), // isDerived
+        (16, 16), // isEnd
+        (168, 168), // isImpliedIncluded
+        (338, 338), // isIndividual
+        (169, 169), // isLibraryElement
+        (17, 17), // isOrdered
+        (18, 18), // isPortion
+        (289, 289), // isReference
+        (76, 76), // isSufficient
+        (19, 19), // isUnique
+        (20, 291), // isVariable
+        (290, 290), // isVariation
+        (291, 291), // mayTimeVary
+        (200, 200), // member
+        (201, 201), // membership
+        (77, 77), // multiplicity
+        (170, 170), // name
+        (292, 292), // nestedAction
+        (293, 293), // nestedAllocation
+        (294, 294), // nestedAnalysisCase
+        (295, 295), // nestedAttribute
+        (296, 296), // nestedCalculation
+        (297, 297), // nestedCase
+        (298, 298), // nestedConcern
+        (299, 299), // nestedConnection
+        (300, 300), // nestedConstraint
+        (301, 301), // nestedEnumeration
+        (302, 302), // nestedFlow
+        (303, 303), // nestedInterface
+        (304, 304), // nestedItem
+        (305, 305), // nestedMetadata
+        (306, 306), // nestedOccurrence
+        (307, 307), // nestedPart
+        (308, 308), // nestedPort
+        (309, 309), // nestedReference
+        (310, 310), // nestedRendering
+        (311, 311), // nestedRequirement
+        (312, 312), // nestedState
+        (313, 313), // nestedTransition
+        (314, 314), // nestedUsage
+        (315, 315), // nestedUseCase
+        (316, 316), // nestedVerificationCase
+        (317, 317), // nestedView
+        (318, 318), // nestedViewpoint
+        (339, 214), // occurrenceDefinition
+        (78, 78), // output
+        (171, 171), // ownedAnnotation
+        (79, 79), // ownedConjugator
+        (21, 21), // ownedCrossSubsetting
+        (80, 80), // ownedDifferencing
+        (81, 81), // ownedDisjoining
+        (172, 172), // ownedElement
+        (82, 82), // ownedEndFeature
+        (83, 83), // ownedFeature
+        (22, 22), // ownedFeatureChaining
+        (23, 23), // ownedFeatureInverting
+        (84, 84), // ownedFeatureMembership
+        (202, 202), // ownedImport
+        (85, 85), // ownedIntersecting
+        (203, 203), // ownedMember
+        (204, 204), // ownedMembership
+        (24, 24), // ownedRedefinition
+        (25, 25), // ownedReferenceSubsetting
+        (173, 173), // ownedRelationship
+        (86, 86), // ownedSpecialization
+        (26, 26), // ownedSubsetting
+        (27, 27), // ownedTypeFeaturing
+        (28, 28), // ownedTyping
+        (87, 87), // ownedUnioning
+        (174, 174), // owner
+        (319, 319), // owningDefinition
+        (29, 29), // owningFeatureMembership
+        (175, 175), // owningMembership
+        (176, 176), // owningNamespace
+        (177, 177), // owningRelationship
+        (30, 30), // owningType
+        (320, 320), // owningUsage
+        (99, 99), // parameter
+        (340, 340), // portionKind
+        (178, 178), // qualifiedName
+        (179, 179), // shortName
+        (180, 180), // textualRepresentation
+        (31, 214), // type
+        (88, 88), // unioningType
+        (230, 230), // untilArgument
+        (321, 321), // usage
+        (322, 322), // variant
+        (323, 323), // variantMembership
+        (231, 231), // whileArgument
+    ]),
+];
+
+#[rustfmt::skip]
+pub fn properties(metaclass: &str) -> Option<&'static [PropertyRow]> {
+    CLASSES.binary_search_by_key(&metaclass, |(name, _)| *name).ok().map(|i| CLASSES[i].1)
+}
+
+#[rustfmt::skip]
+pub fn property(metaclass: &str, name: &str) -> Option<(&'static PropertySpec, Option<&'static PropertySpec>)> {
+    let props = properties(metaclass)?;
+    props.binary_search_by_key(&name, |&(requested, _)| PROPERTIES[requested as usize].name).ok().map(|i| (&PROPERTIES[props[i].0 as usize], PROPERTIES.get(props[i].1 as usize)))
+}
diff --git a/crates/sysmlv2-parser/Cargo.toml b/crates/sysmlv2-parser/Cargo.toml
index 8130f5b..b98d489 100644
--- a/crates/sysmlv2-parser/Cargo.toml
+++ b/crates/sysmlv2-parser/Cargo.toml
@@ -9,7 +9,7 @@ edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
 repository.workspace = true
-# The vendored spec grammars and OMG corpus (EPL-2.0 / LGPL) at the
+# The vendored spec grammars and OMG corpus (EPL-2.0) at the
 # workspace root are reference material for development and testing only —
 # the published crate ships the library sources alone.
 include = [
@@ -22,8 +22,8 @@ default = ["json"]
 json = ["dep:sysmlv2-model", "dep:serde_json"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1", optional = true }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0", optional = true }
 # for tests/examples that build serde_json values directly
 serde_json = { workspace = true, optional = true }
 
diff --git a/crates/sysmlv2-parser/examples/bench.rs b/crates/sysmlv2-parser/examples/bench.rs
index b49941f..967faee 100644
--- a/crates/sysmlv2-parser/examples/bench.rs
+++ b/crates/sysmlv2-parser/examples/bench.rs
@@ -122,7 +122,7 @@ fn main() {
         user.sort();
         for f in &user {
             let src = fs::read_to_string(f).unwrap();
-            model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+            model.add_source(sysmlv2_testkit::relative_source_name(root, f), &src);
         }
         let _ = sysmlv2_parser::json::model_to_compact_json(&model);
         model_time = model_time.min(t.elapsed().as_secs_f64());
diff --git a/crates/sysmlv2-parser/examples/derived_correspondence.rs b/crates/sysmlv2-parser/examples/derived_correspondence.rs
index 0ac9fb1..965a90b 100644
--- a/crates/sysmlv2-parser/examples/derived_correspondence.rs
+++ b/crates/sysmlv2-parser/examples/derived_correspondence.rs
@@ -3,7 +3,7 @@
 //! abstract syntax owns or derives it, the derivation layer's fidelity at
 //! the passthrough level and under the closure policy, the interchange
 //! shape, and — for derived rows — the XMI's type and multiplicity. The
-//! table a per-language SDK generator consumes (plan §33i); a consumer
+//! table a per-language SDK generator consumes; a consumer
 //! keys on `fidelity`, never on corpus fill rate.
 //!
 //! Usage: `cargo run --example derived_correspondence` from the workspace
diff --git a/crates/sysmlv2-parser/examples/evalstats.rs b/crates/sysmlv2-parser/examples/evalstats.rs
index b988cf8..a1dbb55 100644
--- a/crates/sysmlv2-parser/examples/evalstats.rs
+++ b/crates/sysmlv2-parser/examples/evalstats.rs
@@ -9,7 +9,10 @@ fn main() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let mut r = ResolvedModel::build(&model);
     let features = r.features_with_values();
diff --git a/crates/sysmlv2-parser/examples/fullcheck.rs b/crates/sysmlv2-parser/examples/fullcheck.rs
index e2b2c38..725de0c 100644
--- a/crates/sysmlv2-parser/examples/fullcheck.rs
+++ b/crates/sysmlv2-parser/examples/fullcheck.rs
@@ -36,7 +36,7 @@ fn main() {
     files.sort();
     for f in &files {
         let src = fs::read_to_string(f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(sysmlv2_testkit::relative_source_name(root, f), &src);
     }
     let full = model_to_full_json(&model);
     let elements = full.as_array().unwrap();
diff --git a/crates/sysmlv2-parser/examples/implied_reachability_bench.rs b/crates/sysmlv2-parser/examples/implied_reachability_bench.rs
new file mode 100644
index 0000000..e115d0e
--- /dev/null
+++ b/crates/sysmlv2-parser/examples/implied_reachability_bench.rs
@@ -0,0 +1,64 @@
+use std::{collections::HashMap, time::Instant};
+use sysmlv2_parser::{json::ResolvedModel, model::Model};
+fn main() {
+    for count in [1000, 5000] {
+        for reverse in [false, true] {
+            let mut declarations = vec!["part def T0;".to_string()];
+            for i in 1..count {
+                declarations.push(format!("part def T{i} :> T{};", i - 1));
+            }
+            if reverse {
+                declarations.reverse();
+            }
+            let source = format!("package P {{ {} }}", declarations.join("\n"));
+            let mut model = Model::new();
+            model.add_source("bench.sysml", &source);
+            let mut r = ResolvedModel::build(&model);
+            let mut names = HashMap::new();
+            names.insert(
+                uuid::Uuid::new_v4().to_string(),
+                vec!["Parts".into(), "Part".into()],
+            );
+            r.set_library_names(&names);
+            let owner = r.resolve_qualified("P::T0").unwrap();
+            let start = Instant::now();
+            let edges = r.implied_relationships(owner);
+            assert_eq!(edges.len(), 1);
+            println!(
+                "chain count={count} reverse={reverse} inference={:?}",
+                start.elapsed()
+            );
+        }
+    }
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    model.add_source(
+        "export.sysml",
+        &format!(
+            "package P {{ part def Base; {} }}",
+            (0..200)
+                .map(|i| format!("part def T{i} :> Base; part x{i}: T{i};"))
+                .collect::<Vec<_>>()
+                .join("\n")
+        ),
+    );
+    for _ in 0..3 {
+        let mut resolved = ResolvedModel::build(&model);
+        let owner = resolved.resolve_qualified("P::Base").unwrap();
+        let start = Instant::now();
+        resolved.implied_relationships(owner);
+        println!(
+            "loaded library 200 definitions/usages inference={:?}",
+            start.elapsed()
+        );
+        let start = Instant::now();
+        let json = sysmlv2_parser::full::model_to_full_json(&model);
+        println!(
+            "loaded library 200 definitions/usages export={:?} elements={}",
+            start.elapsed(),
+            json.as_array().map_or(0, Vec::len)
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/examples/modelcheck.rs b/crates/sysmlv2-parser/examples/modelcheck.rs
index 8d09cb4..7f8e934 100644
--- a/crates/sysmlv2-parser/examples/modelcheck.rs
+++ b/crates/sysmlv2-parser/examples/modelcheck.rs
@@ -30,7 +30,7 @@ fn main() {
     let n = files.len();
     for f in &files {
         let src = fs::read_to_string(f).unwrap();
-        let name = f.file_name().unwrap().to_string_lossy().into_owned();
+        let name = sysmlv2_testkit::relative_source_name(root, f);
         model.add_source(name, &src);
     }
     let v = model_to_compact_json(&model);
diff --git a/crates/sysmlv2-parser/examples/modelcheck2.rs b/crates/sysmlv2-parser/examples/modelcheck2.rs
index 4fd4092..5d81aa9 100644
--- a/crates/sysmlv2-parser/examples/modelcheck2.rs
+++ b/crates/sysmlv2-parser/examples/modelcheck2.rs
@@ -47,7 +47,7 @@ fn main() {
     files.sort();
     for f in &files {
         let src = fs::read_to_string(f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(sysmlv2_testkit::relative_source_name(root, f), &src);
     }
     let v = model_to_compact_json(&model);
     let mut refs = Vec::new();
diff --git a/crates/sysmlv2-parser/examples/refreport.rs b/crates/sysmlv2-parser/examples/refreport.rs
index 89485a5..ed56332 100644
--- a/crates/sysmlv2-parser/examples/refreport.rs
+++ b/crates/sysmlv2-parser/examples/refreport.rs
@@ -28,7 +28,7 @@ fn main() {
     files.sort();
     for f in &files {
         let src = fs::read_to_string(f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(sysmlv2_testkit::relative_source_name(root, f), &src);
     }
     let diags = validate_model(&model);
     let mut unresolved = 0;
diff --git a/crates/sysmlv2-parser/examples/semstats.rs b/crates/sysmlv2-parser/examples/semstats.rs
index 6fa70d8..5516d65 100644
--- a/crates/sysmlv2-parser/examples/semstats.rs
+++ b/crates/sysmlv2-parser/examples/semstats.rs
@@ -9,7 +9,10 @@ fn main() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let diags = validate_semantics(&model);
     for (u, d) in &diags {
diff --git a/crates/sysmlv2-parser/examples/verifystats.rs b/crates/sysmlv2-parser/examples/verifystats.rs
index e3e8c4d..38aa6f2 100644
--- a/crates/sysmlv2-parser/examples/verifystats.rs
+++ b/crates/sysmlv2-parser/examples/verifystats.rs
@@ -9,7 +9,10 @@ fn main() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let checks = check_constraints(&model);
     let (mut sat, mut vio, mut und) = (0, 0, 0);
diff --git a/crates/sysmlv2-parser/src/lib.rs b/crates/sysmlv2-parser/src/lib.rs
index 924bf4f..5b4018f 100644
--- a/crates/sysmlv2-parser/src/lib.rs
+++ b/crates/sysmlv2-parser/src/lib.rs
@@ -17,8 +17,8 @@ pub use sysmlv2_syntax::{ast, diag, lexer, name, parser, print, span, token, vis
 
 #[cfg(feature = "json")]
 pub use sysmlv2_model::{
-    ambient, eval, full, ids, json, libcache, lift, loader, model, prepared, quantity, rational,
-    render,
+    ambient, eval, full, ids, json, libcache, lift, loader, migration, model, prepared, quantity,
+    rational,
 };
 
 /// Post-parse validation: body-context legality (syntax-level) and — with
diff --git a/crates/sysmlv2-parser/tests/annotation_precision.rs b/crates/sysmlv2-parser/tests/annotation_precision.rs
new file mode 100644
index 0000000..5501517
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/annotation_precision.rs
@@ -0,0 +1,45 @@
+//! Parser integration controls for nonmetadata Annotation source precision.
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    check::{ConstraintVerdict, check_constraints},
+    model::Model,
+};
+#[test]
+fn unresolved_comment_target_does_not_hide_unrelated_value_receiver() {
+    for extra in [
+        "",
+        "comment about Missing /*text*/",
+        "metaclass M; @M about Missing;",
+    ] {
+        let mut model = Model::new();
+        assert!(
+            model
+                .add_source(
+                    "constraint.sysml",
+                    "part def Tire { attribute depth default 6; constraint legal {depth >= 3} }"
+                )
+                .diagnostics
+                .is_empty()
+        );
+        assert!(
+            model
+                .add_source("annotation.kerml", extra)
+                .diagnostics
+                .is_empty()
+        );
+        let checks = check_constraints(&model);
+        let check = checks
+            .iter()
+            .find(|c| c.name.as_deref() == Some("legal"))
+            .unwrap();
+        if extra.starts_with("metaclass") {
+            assert!(
+                matches!(check.verdict, ConstraintVerdict::Undecided(_)),
+                "{:?}",
+                check.verdict
+            );
+        } else {
+            assert_eq!(check.verdict, ConstraintVerdict::Satisfied);
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/binary_connection_bases.rs b/crates/sysmlv2-parser/tests/binary_connection_bases.rs
new file mode 100644
index 0000000..4012f75
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/binary_connection_bases.rs
@@ -0,0 +1,184 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{
+    json::{Reference, ResolvedModel},
+    model::{GraphFormat, Model},
+};
+
+const LIB: &str = "standard library package Connections {
+ connection def Connection;
+ connection def BinaryConnection :> Connection { end source; end target; }
+}";
+
+#[test]
+fn two_owned_connection_ends_resolve_their_binary_redefinitions() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model.add_library_source("connections.sysml", LIB);
+        model.add_source(
+            "pairs.sysml",
+            "package P { connection def Pair { end left :>> source; end right :>> target; } }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        assert!(
+            r.unresolved_references().is_empty(),
+            "{:?}",
+            r.unresolved_references()
+        );
+        let binary = r
+            .resolve_qualified("Connections::BinaryConnection")
+            .unwrap();
+        let pair = r.resolve_qualified("P::Pair").unwrap();
+        assert!(r.conforms_with_implied(pair, binary));
+        for (end, target) in [("left", "source"), ("right", "target")] {
+            let local = r.resolve_qualified(&format!("P::Pair::{end}")).unwrap();
+            let inherited = r
+                .resolve_qualified(&format!("Connections::BinaryConnection::{target}"))
+                .unwrap();
+            let redef = r
+                .owned_relationships(local)
+                .into_iter()
+                .find(|&rel| r.element_type(rel) == "Redefinition")
+                .unwrap();
+            assert_eq!(
+                r.relationship_ends(redef).1,
+                vec![Reference::Element(inherited)]
+            );
+        }
+    }
+}
+
+#[test]
+fn owned_end_count_controls_binary_definition_heritage() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model.add_library_source("connections.sysml", LIB);
+        model.add_source(
+            "counts.sysml",
+            "package P {
+            connection def Empty;
+            connection def Unary { end a; }
+            connection def Ternary { end a; end b; end c; }
+            connection def Ordinary { ref a; ref b; }
+            connection def Pair { end a; end b; }
+            connection def Inherited :> Pair;
+        }",
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let binary = r
+            .resolve_qualified("Connections::BinaryConnection")
+            .unwrap();
+        for name in ["Empty", "Unary", "Ternary", "Ordinary"] {
+            let element = r.resolve_qualified(&format!("P::{name}")).unwrap();
+            assert!(!r.conforms_with_implied(element, binary), "{name}");
+            assert!(
+                r.resolve_qualified(&format!("P::{name}::source")).is_none(),
+                "{name}"
+            );
+        }
+        let inherited = r.resolve_qualified("P::Inherited").unwrap();
+        assert!(r.conforms_with_implied(inherited, binary));
+        assert!(
+            !r.implied_relationships(inherited)
+                .into_iter()
+                .any(|rel| r.relationship_ends(rel).1 == vec![Reference::Element(binary)])
+        );
+    }
+}
+
+#[test]
+fn noncanonical_binary_definition_names_do_not_supply_lookup_heritage() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for (library, user_library) in [
+            (
+                "standard library package Connections { connection def Connection; class BinaryConnection { feature source; feature target; } }",
+                false,
+            ),
+            (LIB, true),
+            (
+                "standard library package Connections { connection def Connection; }",
+                false,
+            ),
+        ] {
+            let mut model = Model::with_graph_format(format);
+            if user_library {
+                model.add_source("connections.sysml", library);
+            } else {
+                model.add_library_source("connections.sysml", library);
+            }
+            model.add_source(
+                "pair.sysml",
+                "connection def Pair { end left :>> source; end right :>> target; }",
+            );
+            assert!(!model.has_errors());
+            let r = ResolvedModel::build(&model);
+            let names: Vec<_> = r
+                .unresolved_references()
+                .into_iter()
+                .map(|site| site.spelling)
+                .collect();
+            assert!(names.iter().any(|n| n == "source"), "{names:?}");
+            assert!(names.iter().any(|n| n == "target"), "{names:?}");
+        }
+    }
+}
+
+#[test]
+fn binary_library_end_redefinitions_agree_across_preparation_and_graph_formats() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        let cold = ResolvedModel::build(&model);
+        let expected = cold.unresolved_count();
+        let prepared = model.prepare_library().unwrap();
+        let decoded = std::sync::Arc::new(
+            sysmlv2_parser::prepared::PreparedLibrary::from_bytes(
+                &prepared.to_bytes(1).unwrap(),
+                1,
+            )
+            .unwrap(),
+        );
+        let mut resolved = vec![cold];
+        for library in [prepared, decoded] {
+            let mut installed = Model::with_graph_format(format);
+            library.install(&mut installed).unwrap();
+            installed.add_source(
+                "user.sysml",
+                "package VerificationFixture { connection def Pair { end a; end b; } }",
+            );
+            resolved.push(ResolvedModel::build(&installed));
+        }
+        for mut r in resolved {
+            assert_eq!(r.unresolved_count(), expected);
+            let binary = r
+                .resolve_qualified("Connections::BinaryConnection")
+                .unwrap();
+            let concrete = r
+                .resolve_qualified("CausationConnections::Causation")
+                .unwrap();
+            assert!(r.conforms_with_implied(concrete, binary));
+            for (end, target) in [("theCause", "source"), ("theEffect", "target")] {
+                let local = r
+                    .resolve_qualified(&format!("CausationConnections::Causation::{end}"))
+                    .unwrap();
+                let inherited = r
+                    .resolve_qualified(&format!("Connections::BinaryConnection::{target}"))
+                    .unwrap();
+                let redef = r
+                    .owned_relationships(local)
+                    .into_iter()
+                    .find(|&rel| r.element_type(rel) == "Redefinition")
+                    .unwrap();
+                assert_eq!(
+                    r.relationship_ends(redef).1,
+                    vec![Reference::Element(inherited)]
+                );
+            }
+        }
+        eprintln!("{format:?}: unresolved library sites {expected}");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/cardinality_body.rs b/crates/sysmlv2-parser/tests/cardinality_body.rs
new file mode 100644
index 0000000..c3620cf
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/cardinality_body.rs
@@ -0,0 +1,667 @@
+//! Body and named multiplicity domains retain exact bounds and stored identity.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    eval::Value, json::ResolvedModel, libcache::LibraryCache, model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    let mut base = Model::new();
+    let unit = base.add_library_source("bounds.kerml", library);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(31).unwrap(), 31).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("bounds.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source("user.kerml", user);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            assert!(!model.has_errors());
+            ResolvedModel::build(&model)
+        })
+        .collect()
+}
+
+fn bounds(r: &mut ResolvedModel, name: &str, expected: Option<(i128, Option<i128>)>) {
+    let e = r.resolve_qualified(name).unwrap();
+    assert_eq!(r.effective_cardinality(e), expected, "{name}");
+}
+
+#[test]
+fn body_ranges_match_header_bounds_without_rounding() {
+    for mut r in models(
+        "",
+        "package P {
+        feature exact { multiplicity [4]; }
+        feature interval { multiplicity [2..5]; }
+        feature empty { multiplicity [0]; }
+        feature any { multiplicity [*]; }
+        feature anyRange { multiplicity [0..*]; }
+        feature big { multiplicity [9223372036854775809]; }
+        feature overflow { multiplicity [170141183460469231731687303715884105728]; }
+        feature reversed { multiplicity [5..2]; }
+        feature real { multiplicity [2.5]; }
+        feature missing { multiplicity [absent]; }
+        feature negative = -1;
+        feature invalidNegative { multiplicity [negative]; }
+        feature infinity = *;
+        feature invalidLower { multiplicity [infinity..5]; }
+        feature duplicateBody { multiplicity [1]; multiplicity [2]; }
+        feature base[2];
+        feature local subsets base { multiplicity [4]; }
+        feature duplicate[1] { multiplicity [2]; }
+        feature answer = size(exact);
+        feature emptyAnswer = isEmpty(empty);
+        feature nonemptyAnswer = notEmpty(interval);
+        feature badIndex = exact#(5);
+    }",
+    ) {
+        for (name, expected) in [
+            ("exact", Some((4, Some(4)))),
+            ("interval", Some((2, Some(5)))),
+            ("empty", Some((0, Some(0)))),
+            ("any", Some((0, None))),
+            ("anyRange", Some((0, None))),
+            (
+                "big",
+                Some((9223372036854775809, Some(9223372036854775809))),
+            ),
+            ("overflow", None),
+            ("reversed", None),
+            ("real", None),
+            ("missing", None),
+            ("invalidNegative", None),
+            ("invalidLower", None),
+            ("duplicateBody", None),
+            ("local", Some((4, Some(4)))),
+            ("duplicate", None),
+        ] {
+            bounds(&mut r, &format!("P::{name}"), expected);
+        }
+        for (name, expected) in [
+            ("answer", Value::Integer(4)),
+            ("emptyAnswer", Value::Boolean(true)),
+            ("nonemptyAnswer", Value::Boolean(true)),
+        ] {
+            let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+            assert_eq!(r.evaluate(e), Ok(expected));
+        }
+        let e = r.resolve_qualified("P::badIndex").unwrap();
+        assert!(matches!(
+            r.evaluate(e),
+            Err(sysmlv2_parser::eval::EvalError::Type(_))
+        ));
+    }
+}
+
+#[test]
+fn named_domains_follow_aliases_and_do_not_become_feature_cardinalities() {
+    for mut r in models(
+        "package A {
+        multiplicity four[4];
+        alias rangeAlias for four;
+        multiplicity chain subsets rangeAlias;
+        feature base { multiplicity subsets chain; }
+    }",
+        "package B {
+        feature direct { multiplicity subsets A::four; }
+        feature indirect { multiplicity subsets A::chain; }
+        feature inherited subsets A::base;
+        feature unrelated { alias named for A::four; }
+    }",
+    ) {
+        for _ in 0..2 {
+            for name in ["B::direct", "B::indirect", "B::inherited", "A::base"] {
+                bounds(&mut r, name, Some((4, Some(4))));
+            }
+            for name in ["A::four", "B::unrelated"] {
+                bounds(&mut r, name, Some((0, None)));
+            }
+        }
+        bounds(&mut r, "A::chain", None);
+        // Force the UUID lookup index before changing both kinds of endpoint.
+        let a = r.resolve_qualified("A::four").unwrap();
+        let b = r.resolve_qualified("A::chain").unwrap();
+        r.override_ids(&std::collections::HashMap::from([
+            (
+                r.element_id(a),
+                "11111111-1111-4111-8111-111111111111".parse().unwrap(),
+            ),
+            (
+                r.element_id(b),
+                "22222222-2222-4222-8222-222222222222".parse().unwrap(),
+            ),
+        ]));
+        bounds(&mut r, "B::direct", Some((4, Some(4))));
+        bounds(&mut r, "B::indirect", Some((4, Some(4))));
+    }
+}
+
+#[test]
+fn unresolved_cycles_and_non_multiplicity_targets_stay_unknown() {
+    for mut r in models(
+        "package A {
+        multiplicity bare subsets missing;
+        multiplicity a subsets b;
+        multiplicity b subsets a;
+        feature ordinary[4];
+    }",
+        "package B {
+        feature noDomain { multiplicity subsets A::bare; }
+        feature cyclic { multiplicity subsets A::a; }
+        feature absent { multiplicity subsets A::missing; }
+        feature wrongKind { multiplicity subsets A::ordinary; }
+    }",
+    ) {
+        for _ in 0..2 {
+            for name in ["noDomain", "cyclic", "absent", "wrongKind"] {
+                bounds(&mut r, &format!("B::{name}"), None);
+            }
+        }
+    }
+}
+
+#[test]
+fn graph_bounds_use_recorded_lexical_identity_and_restore_lambda_environment() {
+    for mut r in models(
+        "package A {
+        feature n = 4;
+        alias count for n;
+        multiplicity four[count];
+        feature base { multiplicity [count]; }
+    }",
+        "package B {
+        feature n = 2;
+        feature narrowed subsets A::base;
+        feature named { multiplicity subsets A::four; }
+        feature answer = (2, 3)->collect { in n; size(A::base) + n };
+    }",
+    ) {
+        bounds(&mut r, "B::narrowed", Some((4, Some(4))));
+        bounds(&mut r, "B::named", Some((4, Some(4))));
+        let e = r.resolve_qualified("B::answer").unwrap();
+        assert_eq!(
+            r.evaluate(e),
+            Ok(Value::Sequence(vec![Value::Integer(6), Value::Integer(7)]))
+        );
+        let n = r.resolve_qualified("A::n").unwrap();
+        r.override_ids(&std::collections::HashMap::from([(
+            r.element_id(n),
+            "33333333-3333-4333-8333-333333333333".parse().unwrap(),
+        )]));
+        bounds(&mut r, "B::narrowed", Some((4, Some(4))));
+        bounds(&mut r, "B::named", Some((4, Some(4))));
+    }
+}
+
+#[test]
+fn graph_bounds_select_valuations_independently_of_spelling() {
+    for mut r in models(
+        "package A { class Base {
+        feature n = 4;
+        feature simple { multiplicity [n]; }
+        feature qualified { multiplicity [Base::n]; }
+        alias countAlias for n;
+        feature aliased { multiplicity [countAlias]; }
+    } }",
+        "package B { class Child specializes A::Base {
+        feature redefines n = 6;
+        feature redefines simple;
+        feature redefines qualified;
+        feature redefines aliased;
+    } }",
+    ) {
+        bounds(&mut r, "A::Base::simple", Some((4, Some(4))));
+        bounds(&mut r, "A::Base::qualified", Some((4, Some(4))));
+        bounds(&mut r, "B::Child::simple", Some((6, Some(6))));
+        bounds(&mut r, "B::Child::qualified", Some((6, Some(6))));
+        bounds(&mut r, "B::Child::aliased", Some((6, Some(6))));
+    }
+}
+
+#[test]
+fn bound_value_and_domain_cycles_terminate() {
+    for mut r in models(
+        "",
+        "package P {
+        feature n = size(f);
+        multiplicity recursive[n];
+        feature f { multiplicity subsets recursive; }
+        feature valid { multiplicity [3]; }
+    }",
+    ) {
+        for _ in 0..2 {
+            bounds(&mut r, "P::f", None);
+            bounds(&mut r, "P::valid", Some((3, Some(3))));
+        }
+    }
+}
+
+#[test]
+fn body_cardinality_preserves_unknown_receivers_and_call_arguments() {
+    for mut r in models(
+        "",
+        "package P {
+        class Rack { feature count default = 4;
+            feature slots { multiplicity [count]; }
+            feature fixed { multiplicity [4]; }
+        }
+        function Inputs { in unit : Rack[1]; }
+        feature unknownCount = size(Inputs::unit.slots);
+        feature fixedCount = size(Inputs::unit.fixed);
+        function Count { in n default = 4;
+            feature p { multiplicity [n]; } return result = size(p);
+        }
+        feature called = Count(2);
+    }",
+    ) {
+        for (name, expected) in [
+            ("unknownCount", Value::Indeterminate),
+            ("fixedCount", Value::Integer(4)),
+            ("called", Value::Indeterminate),
+        ] {
+            let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+            assert_eq!(r.evaluate(e), Ok(expected), "{name}");
+        }
+    }
+}
+
+#[test]
+fn contextual_named_domains_keep_receiver_identity() {
+    for mut r in models(
+        "package A { class Base {
+            feature n = 4;
+            multiplicity dynamic[n];
+            multiplicity pinned[$::A::Base::n];
+            feature slots { multiplicity subsets dynamic; }
+            feature fixed { multiplicity subsets pinned; }
+            alias <short> 'bound alias' for n;
+            feature viaAlias { multiplicity ['bound alias']; }
+            feature viaShort { multiplicity [short]; }
+        } }",
+        "package B {
+            class Child specializes A::Base { feature redefines n = 6;
+                feature redefines slots; feature redefines fixed;
+                feature redefines viaAlias; feature redefines viaShort;
+            }
+            class Other specializes A::Base { feature redefines n = 9;
+                feature redefines slots; feature redefines fixed;
+            }
+            class Shadow specializes A::Base { feature n = 7;
+                feature redefines slots;
+                feature 'bound alias' = 8; feature redefines viaAlias;
+            }
+            class Formula specializes A::Base { feature redefines n = 2+3;
+                feature redefines slots;
+            }
+        }",
+    ) {
+        for _ in 0..2 {
+            for (name, expected) in [
+                ("B::Child::slots", Some((6, Some(6)))),
+                ("B::Other::slots", Some((9, Some(9)))),
+                ("A::Base::slots", Some((4, Some(4)))),
+                ("B::Child::fixed", Some((6, Some(6)))),
+                ("B::Other::fixed", Some((9, Some(9)))),
+                ("B::Child::viaAlias", Some((6, Some(6)))),
+                ("B::Child::viaShort", Some((6, Some(6)))),
+                ("B::Shadow::slots", None),
+                ("B::Shadow::viaAlias", None),
+                ("B::Formula::slots", Some((5, Some(5)))),
+            ] {
+                bounds(&mut r, name, expected);
+                let e = r.resolve_qualified(name).unwrap();
+                r.implied_relationships(e);
+            }
+        }
+        let n = r.resolve_qualified("A::Base::n").unwrap();
+        r.override_ids(&std::collections::HashMap::from([(
+            r.element_id(n),
+            "55555555-5555-4555-8555-555555555555".parse().unwrap(),
+        )]));
+        bounds(&mut r, "B::Child::slots", Some((6, Some(6))));
+        bounds(&mut r, "B::Child::fixed", Some((6, Some(6))));
+    }
+}
+
+#[test]
+fn contextual_graph_references_preserve_lexical_names_and_rebind_formula_dependencies() {
+    for mut r in models(
+        "package A { feature external = 4;
+            class Base { feature n = 3; feature formula = n + 1;
+                feature lexical { multiplicity [external]; }
+                feature dependent { multiplicity [formula]; }
+            }
+        }",
+        "package B { class Child specializes A::Base {
+            feature external = 9; feature redefines n = 6;
+            feature redefines lexical; feature redefines dependent;
+        } }",
+    ) {
+        bounds(&mut r, "B::Child::lexical", Some((4, Some(4))));
+        bounds(&mut r, "A::Base::dependent", Some((4, Some(4))));
+        bounds(&mut r, "B::Child::dependent", Some((7, Some(7))));
+    }
+}
+
+#[test]
+fn identity_bound_referent_selects_redefinitions_after_id_changes() {
+    let id = "66666666-6666-4666-8666-666666666666";
+    let mut model = Model::new();
+    let unit = model.add_source(
+        "ids.kerml",
+        &format!(
+            "package P {{
+        class Base {{ feature n = 4;
+            feature slots {{ multiplicity ['{id}']; }}
+        }}
+        class Child specializes Base {{ feature redefines n = 6; feature redefines slots; }}
+    }}"
+        ),
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    let n = r.resolve_qualified("P::Base::n").unwrap();
+    r.override_ids(&std::collections::HashMap::from([(
+        r.element_id(n),
+        id.parse().unwrap(),
+    )]));
+    assert!(
+        r.bind_id_spelled_references()
+            .contains(&id.parse().unwrap())
+    );
+    bounds(&mut r, "P::Child::slots", Some((6, Some(6))));
+    r.override_ids(&std::collections::HashMap::from([(
+        id.parse().unwrap(),
+        "77777777-7777-4777-8777-777777777777".parse().unwrap(),
+    )]));
+    bounds(&mut r, "P::Child::slots", Some((6, Some(6))));
+}
+
+#[test]
+fn bound_identity_is_scoped_to_its_source_unit() {
+    let id = "88888888-8888-4888-8888-888888888888";
+    let mut model = Model::new();
+    for package in ["A", "B"] {
+        let source = format!(
+            "package {package} {{ class Base {{
+            feature source = 4; feature '{id}' = 8;
+            feature slots {{ multiplicity ['{id}']; }}
+        }} class Child specializes Base {{
+            feature redefines '{id}' = 9; feature redefines slots;
+        }} }}"
+        );
+        let unit = model.add_source(format!("{package}.kerml"), &source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    }
+    let mut r = ResolvedModel::build(&model);
+    let source = r.resolve_qualified("A::Base::source").unwrap();
+    r.override_ids(&std::collections::HashMap::from([(
+        r.element_id(source),
+        id.parse().unwrap(),
+    )]));
+    let slots = r.resolve_qualified("A::Base::slots").unwrap();
+    let multiplicity = r.owned_members(slots)[0];
+    let expression = r.owned_members(multiplicity)[0];
+    let membership = r.owned_relationships(expression)[0];
+    let mut hints = std::collections::HashMap::from([(
+        (r.element_id(membership), "memberElement".into()),
+        id.parse().unwrap(),
+    )]);
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&id.parse().unwrap())
+    );
+    for _ in 0..2 {
+        bounds(&mut r, "A::Child::slots", Some((4, Some(4))));
+        bounds(&mut r, "B::Child::slots", Some((9, Some(9))));
+    }
+}
+
+#[test]
+fn contextual_bounds_do_not_hydrate_prepared_syntax() {
+    let mut base = Model::new();
+    base.add_library_source(
+        "base.kerml",
+        "package A { class Base {
+        feature n = 4; feature formula = n + 1; multiplicity dynamic[formula];
+        feature slots { multiplicity subsets dynamic; }
+    } }",
+    );
+    let bytes = base.prepare_library().unwrap().to_bytes(31).unwrap();
+    let library = Arc::new(PreparedLibrary::from_bytes(&bytes, 31).unwrap());
+    let mut model = Model::new();
+    library.install(&mut model).unwrap();
+    model.add_source(
+        "user.kerml",
+        "package B { class Child specializes A::Base {
+        feature redefines n = 6; feature redefines slots;
+    } }",
+    );
+    assert_eq!(model.loaded_library_unit_count(), 0);
+    let mut r = ResolvedModel::build(&model);
+    for _ in 0..2 {
+        bounds(&mut r, "B::Child::slots", Some((7, Some(7))));
+    }
+    assert_eq!(model.loaded_library_unit_count(), 0);
+}
+
+#[test]
+fn identity_selection_requires_unique_redefinitions_and_complete_heritage() {
+    for mut r in models("package A { class Base { feature n = 4;
+        feature slots { multiplicity [n]; }
+    } }", "package B {
+        class Renamed specializes A::Base { feature other redefines n = 6; feature redefines slots; }
+        class Shadow specializes A::Base { feature n = 7; feature redefines slots; }
+        class Subset specializes A::Base { feature other subsets n = 7; feature redefines slots; }
+        class Left specializes A::Base { feature left redefines n = 6; }
+        class Right specializes A::Base { feature right redefines n = 6; }
+        class Ambiguous specializes Left, Right { feature redefines slots; }
+        class Middle specializes Renamed;
+        class Diamond specializes Renamed, Middle { feature redefines slots; }
+        class Incomplete specializes Renamed, absent { feature redefines slots; }
+        class IncompleteChild specializes Incomplete { feature redefines slots; }
+        class CycleA specializes A::Base, CycleB { feature redefines slots; }
+        class CycleB specializes CycleA;
+        class Two specializes A::Base { feature one redefines n = 6;
+            feature two redefines n = 6; feature redefines slots; }
+        class Bad specializes A::Base { feature other redefines missing = 7; feature redefines slots; }
+    }") {
+        bounds(&mut r, "B::Renamed::slots", Some((6, Some(6))));
+        bounds(&mut r, "B::Shadow::slots", Some((4, Some(4))));
+        bounds(&mut r, "B::Subset::slots", Some((4, Some(4))));
+        bounds(&mut r, "B::Diamond::slots", Some((6, Some(6))));
+        for name in ["B::Ambiguous::slots", "B::Incomplete::slots", "B::Bad::slots", "B::IncompleteChild::slots", "B::CycleA::slots", "B::Two::slots"] {
+            bounds(&mut r, name, None);
+        }
+    }
+}
+
+#[test]
+fn reference_selection_checks_local_uniqueness_and_unrelated_receivers() {
+    for mut r in models(
+        "package A { feature constant = 4;
+            class Base { feature n = 4; }
+            class Root; class Local specializes Root { feature n = 4; feature other redefines Local::n = 6;
+                feature header[n]; feature body { multiplicity [n]; }
+            }
+            class Formula { feature n = 3; feature sum = n + 1;
+                feature header[sum]; feature body { multiplicity [sum]; }
+            }
+        }",
+        "package B { class Other {
+            feature header[A::Base::n]; feature body { multiplicity [A::Base::n]; }
+            feature constant[A::constant];
+        } }",
+    ) {
+        let original = r.resolve_qualified("A::Local::n").unwrap();
+        let other = r.resolve_qualified("A::Local::other").unwrap();
+        assert_eq!(r.redefinition_targets(other), vec![original]);
+        for name in [
+            "A::Local::header",
+            "A::Local::body",
+            "B::Other::header",
+            "B::Other::body",
+        ] {
+            bounds(&mut r, name, None);
+        }
+        for name in [
+            "A::Formula::header",
+            "A::Formula::body",
+            "B::Other::constant",
+        ] {
+            bounds(&mut r, name, Some((4, Some(4))));
+        }
+    }
+}
+
+#[test]
+fn complete_imported_candidate_providers_are_admitted_but_missing_and_filtered_are_unknown() {
+    for mut r in models(
+        "package A { package Source { feature extra = 7; }
+            class Missing { public import absent::*; feature n = 4;
+                feature slots { multiplicity [n]; }
+            }
+            class Imported { public import Source::*; feature n = 4;
+                feature slots { multiplicity [n]; }
+            }
+            class Filtered { filter true; feature n = 4;
+                feature slots { multiplicity [n]; }
+            }
+        }",
+        "package B {
+            class Child specializes A::Missing { feature other redefines n = 6; feature redefines slots; }
+            class Known specializes A::Imported { feature other redefines n = 6; feature redefines slots; }
+        }",
+    ) {
+        bounds(&mut r, "A::Imported::slots", Some((4, Some(4))));
+        bounds(&mut r, "B::Known::slots", Some((6, Some(6))));
+        for name in ["A::Missing::slots", "B::Child::slots", "A::Filtered::slots"] {
+            bounds(&mut r, name, None);
+        }
+    }
+}
+
+#[test]
+fn complete_provider_proofs_preserve_imported_feature_membership_and_visibility() {
+    for mut r in models(
+        "package A {
+            class Base { feature n default = 4; feature formula = n + 1;
+                feature slots { multiplicity [formula]; }
+            }
+            class Provider specializes Base { feature other redefines n = 8; }
+            class Public specializes Base { public import Provider::*; feature redefines slots; }
+            class Protected specializes Base { protected import Provider::*; feature redefines slots; }
+            class Private specializes Base { private import Provider::*; feature redefines slots; }
+            class OtherProvider specializes Base { feature rival redefines n = 10; }
+            class Both specializes Base { public import Provider::*; public import OtherProvider::*; }
+            class Member specializes Base { public import Provider::other; }
+            class Alias specializes Base { alias selected for Provider::other; }
+            class SharedLeft specializes Base { public import Provider::other; }
+            class SharedRight specializes Base { public import Provider::other; }
+        }",
+        "package B {
+            class PublicChild specializes A::Public { feature redefines slots; }
+            class ProtectedChild specializes A::Protected { feature redefines slots; }
+            class PrivateChild specializes A::Private { feature redefines slots; }
+            class BothChild specializes A::Both { feature redefines slots; }
+            class MemberChild specializes A::Member { feature redefines slots; }
+            class AliasChild specializes A::Alias { feature redefines slots; }
+            class Diamond specializes A::SharedLeft, A::SharedRight { feature redefines slots; }
+        }",
+    ) {
+        for _ in 0..2 {
+            bounds(&mut r, "A::Public::slots", Some((5, Some(5))));
+            bounds(&mut r, "B::PublicChild::slots", Some((9, Some(9))));
+            bounds(&mut r, "B::ProtectedChild::slots", Some((9, Some(9))));
+            bounds(&mut r, "B::PrivateChild::slots", Some((5, Some(5))));
+            bounds(&mut r, "B::BothChild::slots", None);
+            bounds(&mut r, "B::MemberChild::slots", Some((9, Some(9))));
+            bounds(&mut r, "B::AliasChild::slots", None);
+            bounds(&mut r, "B::Diamond::slots", Some((9, Some(9))));
+        }
+    }
+}
+
+#[test]
+fn provider_proof_rejects_transitive_gaps_but_exact_member_imports_remain_local() {
+    for mut r in models(
+        "package A {
+            package Good { feature extra = 7; }
+            package Bad { public import absent::*; feature extra = 7; }
+            package Transitive { public import Bad::*; }
+            package CycleA { public import CycleB::*; }
+            package CycleB { public import CycleA::*; }
+            class Base { feature n = 4; feature slots { multiplicity [n]; } }
+        }",
+        "package B {
+            class Known specializes A::Base { public import A::Good::*; feature redefines slots; }
+            class Exact specializes A::Base { public import A::Bad::extra; feature redefines slots; }
+            class Alias specializes A::Base { alias selected for A::Bad::extra; feature redefines slots; }
+            class Missing specializes A::Base { public import absent::*; feature redefines slots; }
+            class Transitive specializes A::Base { public import A::Transitive::*; feature redefines slots; }
+            class Recursive specializes A::Base { public import A::Good::*::**; feature redefines slots; }
+            class Cycle specializes A::Base { public import A::CycleA::*; feature redefines slots; }
+            class MissingMember specializes A::Base { public import A::Good::absent; feature redefines slots; }
+            class MissingAlias specializes A::Base { alias selected for A::Good::absent; feature redefines slots; }
+            feature recovered = if size(Missing::slots) == 4 and false ? 0
+                else size(Known::slots) + size(Exact::slots);
+        }",
+    ) {
+        for _ in 0..2 {
+            for name in ["Missing", "Transitive", "Recursive", "Cycle", "MissingMember", "MissingAlias"] {
+                bounds(&mut r, &format!("B::{name}::slots"), None);
+            }
+            for name in ["Known", "Exact", "Alias"] {
+                bounds(&mut r, &format!("B::{name}::slots"), Some((4, Some(4))));
+            }
+            let recovered = r.resolve_qualified("B::recovered").unwrap();
+            assert_eq!(r.evaluate(recovered), Ok(Value::Integer(8)));
+        }
+    }
+}
+
+#[test]
+fn lexical_resolution_stays_separate_from_receiver_provider_completeness() {
+    for (imports, expected) in [
+        ("public import Good::*;", Some((5, Some(5)))),
+        (
+            "public import Good::*; public import absent::*;",
+            Some((5, Some(5))),
+        ),
+        ("public import Good::*; public import Other::*;", None),
+    ] {
+        let library = format!(
+            "package A {{ package Good {{ feature n = 4; }}
+            package Other {{ feature n = 6; }}
+            package Formulas {{ {imports} feature count = n + 1;
+                class Base {{ feature slots {{ multiplicity [count]; }} }}
+            }}
+        }}"
+        );
+        for mut r in models(
+            &library,
+            "package B { class Child specializes A::Formulas::Base { feature redefines slots; } }",
+        ) {
+            bounds(&mut r, "B::Child::slots", expected);
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/cardinality_context.rs b/crates/sysmlv2-parser/tests/cardinality_context.rs
new file mode 100644
index 0000000..ed0322b
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/cardinality_context.rs
@@ -0,0 +1,422 @@
+//! Inherited bounds preserve lexical identity while honoring actual overrides.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    eval::Value, json::ResolvedModel, libcache::LibraryCache, model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    let mut base = Model::new();
+    let unit = base.add_library_source("bounds.sysml", library);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(31).unwrap(), 31).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("bounds.sysml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source("user.sysml", user);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            assert!(!model.has_errors());
+            ResolvedModel::build(&model)
+        })
+        .collect()
+}
+
+fn exact(r: &mut ResolvedModel, name: &str, count: i128) {
+    let e = r
+        .resolve_qualified(name)
+        .unwrap_or_else(|| panic!("missing {name}"));
+    assert_eq!(
+        r.effective_cardinality(e),
+        Some((count, Some(count))),
+        "{name}"
+    );
+}
+
+#[test]
+fn subsetting_bounds_do_not_capture_unrelated_package_names() {
+    for mut r in models(
+        "package A { attribute n = 4; part base[n]; }",
+        "package B { attribute n = 2; part subset :> A::base; }",
+    ) {
+        for _ in 0..2 {
+            exact(&mut r, "B::subset", 4);
+            exact(&mut r, "A::base", 4);
+        }
+    }
+}
+
+#[test]
+fn inherited_bounds_do_not_capture_a_new_member_over_a_lexical_name() {
+    for mut r in models(
+        "package A { attribute n = 4; part def Base { part slots[n]; } }",
+        "package B { part def Child :> A::Base {
+            attribute n = 2; part :>> slots;
+        } }",
+    ) {
+        for _ in 0..2 {
+            exact(&mut r, "B::Child::slots", 4);
+            exact(&mut r, "A::Base::slots", 4);
+        }
+    }
+}
+
+#[test]
+fn inherited_bounds_follow_actual_member_redefinitions() {
+    for mut r in models(
+        "package A { part def Base { attribute n = 4; part slots[n]; } }",
+        "package B {
+            part def Child :> A::Base { attribute :>> n = 6; part :>> slots; }
+            part instance : Child[1] { attribute :>> n = 7; part :>> slots; }
+        }",
+    ) {
+        for _ in 0..2 {
+            exact(&mut r, "B::instance::slots", 7);
+            exact(&mut r, "B::Child::slots", 6);
+            exact(&mut r, "A::Base::slots", 4);
+        }
+    }
+}
+
+#[test]
+fn contextual_constant_formulas_resolve_but_unrelated_shadows_stay_unknown() {
+    for mut r in models(
+        "package A { part def Base { attribute n = 4; part slots[n]; } }",
+        "package B {
+            part def SameName :> A::Base { attribute n = 2; part :>> slots; }
+            part def Formula :> A::Base { attribute :>> n = 2 + 3; part :>> slots; }
+        }",
+    ) {
+        exact(&mut r, "B::Formula::slots", 5);
+        let e = r.resolve_qualified("B::SameName::slots").unwrap();
+        assert_eq!(r.effective_cardinality(e), None);
+    }
+}
+
+#[test]
+fn calculation_arguments_do_not_fall_back_to_parameter_defaults_in_bounds() {
+    for mut r in models(
+        "package A { attribute n = 4; part base[n]; }",
+        "calc def Count { in n default = 4; part p[n]; return result = size(p); }
+        attribute answer = Count(2);",
+    ) {
+        let answer = r.resolve_qualified("answer").unwrap();
+        assert_eq!(r.evaluate(answer), Ok(Value::Indeterminate));
+    }
+}
+
+#[test]
+fn lambda_parameter_names_do_not_capture_external_bound_names() {
+    for mut r in models(
+        "package A { attribute n = 4; part base[n]; }",
+        "attribute answer = (2, 3)->collect { in n; size(A::base) };",
+    ) {
+        let answer = r.resolve_qualified("answer").unwrap();
+        assert_eq!(
+            r.evaluate(answer),
+            Ok(Value::Sequence(vec![Value::Integer(4), Value::Integer(4)]))
+        );
+    }
+}
+#[test]
+fn parameter_bounds_follow_supported_positional_redefinitions() {
+    for mut r in models(
+        "package A {
+            requirement def Base { subject original[2]; }
+            calc def Calc { in original[3]; return result; }
+        }",
+        "package B {
+            requirement def Child :> A::Base { subject renamed; }
+            requirement def Explicit :> A::Base { subject renamed[1]; }
+            calc def ChildCalc :> A::Calc { in renamed; return result; }
+            calc def StructuralCalc :> A::Calc { in attribute renamed; return result; }
+            requirement def Broken :> A::Base, absent { subject renamed; }
+        }",
+    ) {
+        for materialize in [false, true] {
+            for name in [
+                "B::Child::renamed",
+                "B::Explicit::renamed",
+                "B::ChildCalc::renamed",
+                "B::Broken::renamed",
+            ] {
+                if materialize {
+                    let e = r
+                        .resolve_qualified(name)
+                        .unwrap_or_else(|| panic!("missing {name}"));
+                    r.implied_relationships(e);
+                }
+            }
+            exact(&mut r, "B::Child::renamed", 2);
+            exact(&mut r, "B::Explicit::renamed", 1);
+            exact(&mut r, "B::ChildCalc::renamed", 3);
+            exact(&mut r, "B::StructuralCalc::renamed", 1);
+            let broken = r.resolve_qualified("B::Broken::renamed").unwrap();
+            assert_eq!(r.effective_cardinality(broken), None);
+        }
+    }
+}
+
+#[test]
+fn bound_formulas_rebind_dependencies_by_identity_in_the_receiver() {
+    for mut r in models(
+        "package A { attribute external = 2;
+            part def Base {
+                attribute n default = 3;
+                alias alternate for n;
+                attribute subtotal = alternate + external;
+                attribute total = subtotal * 2;
+                part slots[total];
+                attribute directCount = n + 1; part direct[directCount];
+                attribute chosen = if n > 4 ? n else 4; part conditional[chosen];
+            }
+        }",
+        "package B {
+            part def Child :> A::Base { attribute :>> n = 6;
+                attribute external = 100;
+                part :>> slots; part :>> direct; part :>> conditional;
+            }
+            part def Renamed :> A::Base { attribute other :>> n = 8;
+                part :>> slots; part :>> direct;
+            }
+            part def Formula :> A::Base { attribute :>> n = 2 + 3;
+                part :>> slots; part :>> direct;
+            }
+            part def Redefined :> A::Base { attribute :>> n = 7;
+                attribute :>> total = subtotal + 1; part :>> slots;
+            }
+        }",
+    ) {
+        for _ in 0..2 {
+            for (name, count) in [
+                ("B::Child::slots", 16),
+                ("B::Child::direct", 7),
+                ("B::Child::conditional", 6),
+                ("B::Renamed::slots", 20),
+                ("B::Renamed::direct", 9),
+                ("B::Formula::slots", 14),
+                ("B::Formula::direct", 6),
+                ("B::Redefined::slots", 10),
+                ("A::Base::slots", 10),
+                ("A::Base::direct", 4),
+                ("A::Base::conditional", 4),
+            ] {
+                exact(&mut r, name, count);
+            }
+        }
+    }
+}
+
+#[test]
+fn bound_formula_dependencies_reject_cycles_ambiguity_and_unsupported_navigation() {
+    for mut r in models(
+        "package A { part def Base {
+            attribute n default = 3; attribute formula = n + 1;
+            part slots[formula]; attribute directCount = n + 1; part direct[directCount];
+        } }",
+        "package B {
+            part def Cycle :> A::Base { attribute :>> n = A::Base::formula;
+                part :>> slots; part :>> direct;
+            }
+            part def Shadow :> A::Base { attribute n = 9; part :>> slots; }
+            part def Left :> A::Base { attribute left :>> n = 5; }
+            part def Right :> A::Base { attribute right :>> n = 5; }
+            part def Ambiguous :> Left, Right { part :>> slots; }
+            part def Missing :> A::Base, absent { part :>> slots; }
+            part def Calls :> A::Base { attribute :>> n = size((1, 2)); part :>> slots; }
+            part def Chain :> A::Base { part p { attribute x = 2; }
+                attribute :>> n = p.x; part :>> slots;
+            }
+        }",
+    ) {
+        for _ in 0..2 {
+            for name in [
+                "B::Cycle::slots",
+                "B::Cycle::direct",
+                "B::Shadow::slots",
+                "B::Ambiguous::slots",
+                "B::Missing::slots",
+                "B::Calls::slots",
+                "B::Chain::slots",
+            ] {
+                let e = r
+                    .resolve_qualified(name)
+                    .unwrap_or_else(|| panic!("missing {name}"));
+                assert_eq!(r.effective_cardinality(e), None, "{name}");
+            }
+            exact(&mut r, "A::Base::slots", 4);
+        }
+    }
+}
+
+#[test]
+fn bound_formula_dependency_depth_is_bounded() {
+    let mut library = String::from("package A { part def Base { attribute v0 = 1;");
+    for i in 1..80 {
+        library.push_str(&format!("attribute v{i} = v{} + 1;", i - 1));
+    }
+    library.push_str("part slots[v79]; } }");
+    for mut r in models(&library, "part def Child :> A::Base { part :>> slots; }") {
+        let e = r.resolve_qualified("Child::slots").unwrap();
+        assert_eq!(r.effective_cardinality(e), None);
+    }
+}
+
+#[test]
+fn local_bound_calls_remain_supported_without_escaping_contextual_guards() {
+    for mut r in models(
+        "package A { part def Base {
+            attribute n = size((1, 2, 3));
+            attribute formula = n + 1;
+            part slots[n]; part dependent[formula]; attribute directCount = n + 1; part direct[directCount];
+        } }",
+        "package B { part def Child :> A::Base { part :>> slots; part :>> dependent;
+            attribute local = size((1, 2)); attribute :>> n = local + 1;
+            part :>> direct;
+        } }",
+    ) {
+        for _ in 0..2 {
+            exact(&mut r, "A::Base::slots", 3);
+            exact(&mut r, "A::Base::dependent", 4);
+            exact(&mut r, "A::Base::direct", 4);
+            for name in ["B::Child::slots", "B::Child::dependent", "B::Child::direct"] {
+                let e = r.resolve_qualified(name).unwrap_or_else(|| panic!("missing {name}"));
+                assert_eq!(r.effective_cardinality(e), None, "{name}");
+            }
+        }
+    }
+}
+
+#[test]
+fn composed_bounds_preserve_unknown_defaults_and_restore_the_evaluator_context() {
+    for mut r in models(
+        "package A { part def Base { attribute n default = 3;
+            attribute formula = A::Base::n + 1; part slots[formula];
+        } }",
+        "package B { part def Child :> A::Base { attribute other :>> n default = 6;
+            part :>> slots;
+        }
+        requirement def R { subject unknown : Child[1]; }
+        attribute unknownCount = size(R::unknown.slots);
+        attribute probe = if size(R::unknown.slots) == 7 and false ? 999
+            else size(A::Base::slots) + size(Child::slots);
+        }",
+    ) {
+        let unknown = r.resolve_qualified("B::unknownCount").unwrap();
+        assert_eq!(r.evaluate(unknown), Ok(Value::Indeterminate));
+        let e = r.resolve_qualified("B::probe").unwrap();
+        assert_eq!(r.evaluate(e), Ok(Value::Integer(11)));
+    }
+}
+
+#[test]
+fn contextual_bound_formulas_require_exact_nonnegative_integer_results() {
+    for mut r in models(
+        "package A { part def Base {
+            attribute n = 2;
+            attribute negative = -n;
+            attribute fractional = n / 2;
+            attribute invalid = n / 0;
+            attribute overflow = 170141183460469231731687303715884105727 + n;
+            attribute exactLarge = 9223372036854775808 + n;
+            attribute zero = n - n;
+            attribute chosen = if n > 1 and false ? absent else +n;
+            part neg[negative]; part fraction[fractional]; part bad[invalid];
+            part huge[overflow]; part big[exactLarge]; part empty[zero]; part choice[chosen];
+        } }",
+        "package B { part def Child :> A::Base { attribute :>> n = 3;
+            part :>> neg; part :>> fraction; part :>> bad; part :>> huge;
+            part :>> big; part :>> empty; part :>> choice;
+        } }",
+    ) {
+        for name in ["neg", "fraction", "bad", "huge"] {
+            let e = r.resolve_qualified(&format!("B::Child::{name}")).unwrap();
+            assert_eq!(r.effective_cardinality(e), None, "{name}");
+        }
+        exact(&mut r, "B::Child::big", 9223372036854775811);
+        exact(&mut r, "B::Child::empty", 0);
+        exact(&mut r, "B::Child::choice", 3);
+    }
+}
+
+#[test]
+fn formula_depth_budget_covers_combined_syntax_and_dependency_nesting() {
+    let mut library = String::from("package A { part def Base { attribute v0 = 1;");
+    for i in 1..12 {
+        library.push_str(&format!(
+            "attribute v{i} = v{}{};",
+            i - 1,
+            " + 0".repeat(12)
+        ));
+    }
+    library.push_str("part small[v2]; part deep[v11]; } }");
+    for mut r in models(
+        &library,
+        "part def Child :> A::Base { part :>> small; part :>> deep; }",
+    ) {
+        exact(&mut r, "Child::small", 1);
+        let e = r.resolve_qualified("Child::deep").unwrap();
+        assert_eq!(r.effective_cardinality(e), None);
+    }
+}
+
+#[test]
+fn package_formula_dependencies_keep_the_receiver_without_capturing_package_names() {
+    for mut r in models(
+        "package A { attribute lexical = 2;
+            attribute bridge = Base::n + lexical;
+            attribute bridgeCall = size((1, 2, 3));
+            part def Base { attribute n default = 3;
+                attribute formula = bridge * 2;
+                attribute unsafeFormula = bridgeCall + n;
+                part slots[formula]; part blocked[unsafeFormula];
+            }
+        }",
+        "package B { part def Child :> A::Base {
+            attribute other :>> n = 6; attribute lexical = 100;
+            part :>> slots; part :>> blocked;
+        } }",
+    ) {
+        exact(&mut r, "B::Child::slots", 16);
+        exact(&mut r, "A::Base::slots", 10);
+        for name in ["A::Base::blocked", "B::Child::blocked"] {
+            let e = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.effective_cardinality(e), None, "{name}");
+        }
+    }
+}
+
+#[test]
+fn annotated_provider_completeness_remains_conservative() {
+    for mut r in models(
+        "package A { metadata def Marker;
+            part def Base { attribute n = 4; part slots[n]; }
+        }",
+        "#A::Marker part def Annotated :> A::Base { part :>> slots; }
+        part def Child :> Annotated { part :>> slots; }",
+    ) {
+        for name in ["Annotated::slots", "Child::slots"] {
+            let e = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.effective_cardinality(e), None, "{name}");
+        }
+        exact(&mut r, "A::Base::slots", 4);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/cardinality_subject.rs b/crates/sysmlv2-parser/tests/cardinality_subject.rs
new file mode 100644
index 0000000..7bfe1db
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/cardinality_subject.rs
@@ -0,0 +1,163 @@
+//! Subject parameters preserve inherited subject identity through intermediate types.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    let mut base = Model::new();
+    base.add_library_source("subjects.sysml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(32).unwrap(), 32).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("subjects.sysml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            m.add_source("user.sysml", user);
+            assert!(!m.has_errors());
+            ResolvedModel::build(&m)
+        })
+        .collect()
+}
+
+fn card(r: &mut ResolvedModel, name: &str) -> Option<(i128, Option<i128>)> {
+    let e = r.resolve_qualified(name).unwrap();
+    r.effective_cardinality(e)
+}
+
+#[test]
+fn subjects_redefine_inherited_subjects_through_requirement_and_case_bases() {
+    for mut r in models(
+        "package L {
+            requirement def R { subject original[1]; }
+            requirement def RM :> R;
+            case def C { subject original[2..4]; }
+            case def CM :> C;
+        }",
+        "package P {
+            requirement def Child :> L::RM { subject renamed; }
+            requirement reqUse : Child { subject subjectAgain; }
+            analysis def CaseChild :> L::CM { subject renamed; }
+            analysis caseUse : CaseChild { subject subjectAgain; }
+        }",
+    ) {
+        let child = r.resolve_qualified("P::Child").unwrap();
+        let renamed = r.resolve_qualified("P::Child::renamed").unwrap();
+        let original = r.resolve_qualified("L::R::original").unwrap();
+        let inherited = r.inherited_features(child, true);
+        assert!(!inherited.contains(&original));
+        assert!(r.effective_features(child, true).contains(&renamed));
+        let edges: Vec<_> = r
+            .implied_relationships(renamed)
+            .into_iter()
+            .filter(|&edge| r.element_type(edge) == "Redefinition")
+            .collect();
+        assert_eq!(edges.len(), 1);
+        assert_eq!(
+            r.element_properties(edges[0])["redefinedFeature"]["@id"],
+            r.element_id(original).to_string()
+        );
+        assert_eq!(
+            r.element_properties(edges[0])["redefiningFeature"]["@id"],
+            r.element_id(renamed).to_string()
+        );
+        assert!(!r.inherited_features(child, true).contains(&original));
+        for _ in 0..2 {
+            assert_eq!(card(&mut r, "P::Child::renamed"), Some((1, Some(1))));
+            assert_eq!(card(&mut r, "P::reqUse::subjectAgain"), Some((1, Some(1))));
+            assert_eq!(card(&mut r, "P::CaseChild::renamed"), Some((2, Some(4))));
+            assert_eq!(card(&mut r, "P::caseUse::subjectAgain"), Some((2, Some(4))));
+        }
+    }
+}
+
+#[test]
+fn cross_family_subjects_pair_by_position_only() {
+    // No subject-family edge across families; the ordinary positional
+    // pairing still reaches the parameter `Mid` inherits at that place.
+    for mut r in models(
+        "package L {
+            requirement def R { subject original[1]; }
+            requirement def Mid :> R;
+        }",
+        "package P { case def Child :> L::Mid { subject renamed; } }",
+    ) {
+        assert_eq!(card(&mut r, "P::Child::renamed"), Some((1, Some(1))));
+        let e = r.resolve_qualified("P::Child::renamed").unwrap();
+        let original = r.resolve_qualified("L::R::original").unwrap();
+        let edges: Vec<_> = r
+            .implied_relationships(e)
+            .into_iter()
+            .filter(|&edge| r.element_type(edge) == "Redefinition")
+            .collect();
+        assert_eq!(edges.len(), 1);
+        assert_eq!(
+            r.element_properties(edges[0])["redefinedFeature"]["@id"],
+            r.element_id(original).to_string()
+        );
+    }
+}
+
+#[test]
+fn explicit_subject_bounds_override_inheritance_and_distinct_bases_intersect() {
+    for mut r in models(
+        "package L {
+            requirement def R { subject original[1..5]; }
+            requirement def S { subject another[2..4]; }
+        }",
+        "package P {
+            requirement def Child :> L::R, L::S { subject renamed; }
+            requirement def Local :> L::R { subject renamed[3]; }
+        }",
+    ) {
+        assert_eq!(card(&mut r, "P::Child::renamed"), Some((2, Some(4))));
+        assert_eq!(card(&mut r, "P::Local::renamed"), Some((3, Some(3))));
+    }
+}
+
+#[test]
+fn ambiguous_or_incomplete_subject_heritage_does_not_guess() {
+    for mut r in models(
+        "package L {
+            requirement def R { subject subjectA[1]; }
+            requirement def S { subject subjectB[2]; }
+            requirement def Ambiguous :> R, S;
+        }",
+        "package P {
+            requirement def Child :> L::Ambiguous { subject renamed; }
+            requirement def Missing :> NotFound { subject renamed; }
+        }",
+    ) {
+        assert_eq!(card(&mut r, "P::Child::renamed"), None);
+        assert_eq!(card(&mut r, "P::Missing::renamed"), None);
+    }
+}
+
+#[test]
+fn ordinary_behavior_parameters_pair_through_an_inheriting_general() {
+    // `Mid`'s parameters are the ones it inherits after its own (none), so
+    // `renamed` takes over `original` and its bounds.
+    for mut r in models(
+        "package L { action def A { in original[1]; } action def Mid :> A; }",
+        "package P { action def Child :> L::Mid { in renamed; } }",
+    ) {
+        assert_eq!(card(&mut r, "P::Child::renamed"), Some((1, Some(1))));
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/certified_type_properties.rs b/crates/sysmlv2-parser/tests/certified_type_properties.rs
new file mode 100644
index 0000000..72e3832
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/certified_type_properties.rs
@@ -0,0 +1,265 @@
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{
+        ClosurePolicy, DerivedValue, Derives, FeatureTypeIssue, PropertyError, Reference,
+        ResolvedModel, conditional_property_capability, derives,
+    },
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+const LIB: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn models() -> Vec<(Model, ResolvedModel)> {
+    models_with_library(LIB)
+}
+fn models_with_library(library: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("certified-library.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(83).unwrap(), 83).unwrap());
+    (0..4).map(|mode|{let mut m=Model::new();match mode {2=>Arc::clone(&prepared).install(&mut m).unwrap(),3=>Arc::clone(&decoded).install(&mut m).unwrap(),_=>{m.add_library_source("certified-library.kerml",library);if mode==1{m.set_library_cache(cache.clone());}}};assert!(m.add_source("certified-user.kerml","function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations; expr implicit:F; feature x:Base::Anything subsets Base::things;").diagnostics.is_empty());let r=ResolvedModel::build(&m);(m,r)}).collect()
+}
+#[test]
+fn conditional_generic_properties_replay_preserve_ids_policy_and_compatibility() {
+    for (m, mut r) in models() {
+        let e = r.resolve_qualified("e").unwrap();
+        let f = r.resolve_qualified("F").unwrap();
+        let implicit = r.resolve_qualified("implicit").unwrap();
+        let x = r.resolve_qualified("x").unwrap();
+        let anything = r.resolve_qualified("Base::Anything").unwrap();
+        let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let rows = r.elements().count();
+        let loaded = m.loaded_library_unit_count();
+        assert_eq!(derives("Expression", "function"), Derives::Passthrough);
+        assert!(conditional_property_capability("Kernel-Functions-Expression-function").is_some());
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            let legacy = r.derived(e, "type");
+            if policy
+                == (ClosurePolicy::Closure {
+                    include_implied: true,
+                })
+            {
+                for _ in 0..2 {
+                    let expected = serde_json::json!({"@id":r.element_id(f).to_string()});
+                    assert_eq!(r.property(e, "function"), Ok(expected.clone()));
+                    assert_eq!(
+                        r.property(e, "behavior"),
+                        Ok(serde_json::json!([expected.clone()]))
+                    );
+                    assert_eq!(r.property(e, "type"), Ok(serde_json::json!([expected])));
+                    assert_eq!(
+                        r.derived_exact(e, "function"),
+                        Ok(DerivedValue::Reference(Reference::Element(f)))
+                    );
+                    assert_eq!(
+                        r.derived_exact(e, "behavior"),
+                        Ok(DerivedValue::References(vec![Reference::Element(f)]))
+                    );
+                    assert_eq!(
+                        r.property(x, "type"),
+                        Ok(serde_json::json!([{"@id":r.element_id(anything).to_string()}]))
+                    );
+                    assert_eq!(
+                        r.property(implicit, "function"),
+                        Ok(serde_json::json!({"@id":r.element_id(f).to_string()}))
+                    );
+                }
+            } else {
+                assert_eq!(r.property(e, "function"), Err(PropertyError::Approximate));
+                assert_eq!(r.derived_exact(e, "type"), Err(PropertyError::Approximate));
+            }
+            assert_eq!(r.derived(e, "type"), legacy);
+            assert_eq!(r.closure_policy(), policy);
+        }
+        assert_eq!(
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>(),
+            ids
+        );
+        assert_eq!(r.elements().count(), rows);
+        assert_eq!(m.loaded_library_unit_count(), loaded);
+        let replacement = uuid::Uuid::new_v4();
+        r.override_ids(&HashMap::from([(r.element_id(f), replacement)]));
+        assert_eq!(
+            r.property(e, "function"),
+            Ok(serde_json::json!({"@id":replacement.to_string()}))
+        );
+        assert_eq!(
+            r.property(implicit, "function"),
+            Ok(serde_json::json!({"@id":replacement.to_string()}))
+        );
+    }
+}
+#[test]
+fn actual_library_generic_certification_uses_the_same_report_identity() {
+    let library = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("../../spec-refs/SysML-v2-Release/sysml.library");
+    if !library.exists() {
+        eprintln!("standard library unavailable");
+        return;
+    }
+    let mut m = Model::new();
+    m.load_library_dir(&library).unwrap();
+    assert!(m.add_source("certified-actual.kerml","function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;").diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&m);
+    let e = r.resolve_qualified("e").unwrap();
+    let f = r.resolve_qualified("F").unwrap();
+    let report = r.feature_type_report(e);
+    assert_eq!(report.function, Ok(Some(f)));
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    assert_eq!(
+        r.property(e, "function"),
+        Ok(serde_json::json!({"@id":r.element_id(f).to_string()}))
+    );
+    assert_eq!(
+        r.derived_exact(e, "type"),
+        Ok(DerivedValue::References(vec![Reference::Element(f)]))
+    );
+}
+
+#[test]
+fn inverse_typing_is_available_to_generic_facades_without_changing_legacy_output() {
+    let mut m = Model::new();
+    assert!(
+        m.add_library_source("inverse-library.kerml", LIB)
+            .diagnostics
+            .is_empty()
+    );
+    assert!(m.add_source("inverse-user.kerml","function F specializes Performances::Evaluation; feature x subsets Performances::evaluations; typing x typed by F;").diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&m);
+    let x = r.resolve_qualified("x").unwrap();
+    let f = r.resolve_qualified("F").unwrap();
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let old = match r.derived(x, "type") {
+        sysmlv2_parser::json::Derived::Value(value) => value,
+        other => panic!("{other:?}"),
+    };
+    assert!(
+        !old.elements().contains(&f),
+        "legacy owned-only reader misses standalone typing"
+    );
+    assert_eq!(
+        r.derived_exact(x, "type"),
+        Ok(DerivedValue::References(vec![Reference::Element(f)]))
+    );
+    assert_eq!(
+        r.property(x, "type"),
+        Ok(serde_json::json!([{"@id":r.element_id(f).to_string()}]))
+    );
+    assert_eq!(
+        r.derived(x, "type"),
+        sysmlv2_parser::json::Derived::Value(old)
+    );
+    assert_eq!(
+        r.derived_exact(x, "type"),
+        Ok(DerivedValue::References(vec![Reference::Element(f)]))
+    );
+}
+
+#[test]
+fn implied_step_ancestry_supplies_omitted_authored_subsetting_across_replay() {
+    let library = LIB.replace(
+        "expr evaluations:Evaluation subsets performances;",
+        "expr evaluations:Evaluation;",
+    );
+    assert_ne!(library, LIB);
+    for (_, mut r) in models_with_library(&library) {
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let f = r.resolve_qualified("F").unwrap();
+        for path in ["e", "implicit"] {
+            let e = r.resolve_qualified(path).unwrap();
+            assert_eq!(r.feature_type_report(e).function, Ok(Some(f)));
+            assert_eq!(
+                r.property(e, "function"),
+                Ok(serde_json::json!({"@id":r.element_id(f).to_string()}))
+            );
+        }
+    }
+}
+
+#[test]
+fn missing_required_ancestry_stays_incomplete_across_replay() {
+    // A missing canonical Step Feature cannot be repaired by implied ancestry.
+    // Remove its authored reference too, retaining a well-formed stored graph
+    // whose only missing requirement is the implied specialization family.
+    let library = LIB
+        .replace(
+            "step performances:Performance subsets Occurrences::occurrences;",
+            "",
+        )
+        .replace(
+            "expr evaluations:Evaluation subsets performances;",
+            "expr evaluations:Evaluation;",
+        );
+    assert_ne!(library, LIB);
+    for (model, mut r) in models_with_library(&library) {
+        let e = r.resolve_qualified("implicit").unwrap();
+        assert!(r.resolve_qualified("Performances::evaluations").is_some());
+        assert!(r.resolve_qualified("Performances::performances").is_none());
+        assert!(r.resolve_qualified("Performances::Performance").is_some());
+        let ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let loaded = model.loaded_library_unit_count();
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let legacy = r.derived(e, "type");
+        for _ in 0..2 {
+            assert_eq!(
+                r.feature_type_report(e).function,
+                Err(FeatureTypeIssue::MissingRequiredFamilies)
+            );
+            assert_eq!(
+                r.property(e, "function"),
+                Err(PropertyError::IncompleteTypeProjection(
+                    FeatureTypeIssue::MissingRequiredFamilies
+                ))
+            );
+            let errors = r.to_full_json_strict().unwrap_err();
+            assert!(
+                errors
+                    .issues
+                    .iter()
+                    .any(|issue| issue.element_id == r.element_id(e)
+                        && issue.property == "function"
+                        && issue.reason
+                            == PropertyError::IncompleteTypeProjection(
+                                FeatureTypeIssue::MissingRequiredFamilies
+                            ))
+            );
+            assert_eq!(r.derived(e, "type"), legacy);
+        }
+        assert_eq!(
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>(),
+            ids
+        );
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/check.rs b/crates/sysmlv2-parser/tests/check.rs
index fc7623e..c8851fd 100644
--- a/crates/sysmlv2-parser/tests/check.rs
+++ b/crates/sysmlv2-parser/tests/check.rs
@@ -588,6 +588,29 @@ fn expose_makes_members_referencable() {
     );
 }
 
+/// The ambient libraries that load with the standard library claim no
+/// generic root names: user packages named `Web` and `Template` are their
+/// own, and references through them resolve.
+#[test]
+fn user_roots_named_web_and_template_are_not_shadowed() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .expect("library");
+    sysmlv2_parser::ambient::add_to(&mut model);
+    model.add_source(
+        "t.sysml",
+        "package Template {\n    part def Invoice;\n}\npackage Web {\n    part def Storefront;\n}\n\
+         package Uses {\n    part inv : Template::Invoice;\n    part shop : Web::Storefront;\n}\n",
+    );
+    assert!(!model.has_errors(), "test source must parse cleanly");
+    let msgs: Vec<String> = validate_model(&model)
+        .into_iter()
+        .map(|(_, d)| d.message)
+        .collect();
+    assert!(msgs.is_empty(), "{msgs:#?}");
+}
+
 /// Corpus ratchet: referential findings over the full corpus + library.
 /// Visibility enforcement exposes references that previously leaked
 /// through private memberships, and ambiguity is now counted separately
@@ -716,6 +739,12 @@ fn referential_root_shadows_library_root() {
 /// -> (63, 24, 2, 2) once named documentation and comment elements
 /// became members their namespace binds, so `comment about cmt` reaches
 /// a `comment cmt /* … */` sibling.
+/// -> (25, 24, 2, 2) once declared connector ends bind in their owner
+/// scope and nested references retain the connected feature's context.
+/// -> (22, 20, 2, 2) once anonymous reference-only requirement usages stop
+/// colliding with declared requirement names: three requirement-root references
+/// and one nested feature cease to be ambiguous, resolving three downstream
+/// requirement-chain references as well.
 #[test]
 fn corpus_referential_ratchet() {
     let root = sysmlv2_testkit::corpus_root();
@@ -726,7 +755,10 @@ fn corpus_referential_ratchet() {
     let files = sysmlv2_testkit::user_files();
     for f in &files {
         let src = fs::read_to_string(f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let diags = validate_model(&model);
     let unresolved = diags
@@ -747,7 +779,7 @@ fn corpus_referential_ratchet() {
         .count();
     assert_eq!(
         (unresolved, ambiguous, aliases, cycles),
-        (63, 24, 2, 2),
+        (22, 20, 2, 2),
         "referential ratchet moved — improvements should only lower these"
     );
 }
@@ -981,7 +1013,10 @@ fn corpus_semantic_constraints_clean() {
         .expect("library");
     for f in sysmlv2_testkit::user_files() {
         let src = fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let diags = sysmlv2_parser::check::validate_semantics(&model);
     // The single long-standing exception here was a
@@ -1001,8 +1036,8 @@ fn corpus_semantic_constraints_clean() {
     assert_eq!(
         msgs,
         [
-            "Turbojet Stage Analysis.sysml — expression combines incompatible quantity dimensions `L^6` and `Θ`",
-            "VehicleGeometryAndCoordinateFrames.sysml — expression combines incompatible quantity dimensions `1` and `L`",
+            "sysml/src/examples/Analysis Examples/Turbojet Stage Analysis.sysml — expression combines incompatible quantity dimensions `L^6` and `Θ`",
+            "sysml/src/examples/Geometry Examples/VehicleGeometryAndCoordinateFrames.sysml — expression combines incompatible quantity dimensions `1` and `L`",
         ],
         "unexpected semantic findings on the corpus"
     );
@@ -1019,6 +1054,25 @@ fn verdicts(src: &str) -> Vec<(Option<String>, sysmlv2_parser::check::Constraint
         .collect()
 }
 
+#[test]
+fn uncertain_chained_index_constraints_stay_undecided() {
+    use sysmlv2_parser::check::ConstraintVerdict::*;
+    let checks = verdicts(
+        "package P {
+            part def A {
+                attribute xs[4] ordered;
+                attribute flag[1];
+                attribute items[0..*] ordered = if flag ? xs else xs;
+            }
+            part def B { attribute items[1] = 99; }
+            part a : A[1]; part b : B[1];
+            assert constraint selected { (a, b).items#(2) == 99 }
+        }",
+    );
+    assert_eq!(checks.len(), 1);
+    assert!(matches!(checks[0].1, Undecided(_)), "{checks:?}");
+}
+
 #[test]
 fn constraint_verdicts() {
     use sysmlv2_parser::check::ConstraintVerdict::*;
@@ -1083,12 +1137,12 @@ fn defaults_read_through_an_unbound_subject_are_undecided() {
                  part cartridge : Cartridge;
              }
              requirement def FitForService {
-                 subject unit : Filter;
+                 subject unit : Filter[1];
                  require constraint fromDefault { unit.ratedHours >= 250 }
                  require constraint fromFixed { unit.portCount == 6 }
                  require constraint throughChain { unit.cartridge.micron <= 1 }
              }
-             part installed : Filter;
+             part installed : Filter[1];
              assert constraint onAUsage { installed.ratedHours == 40 }
          }",
     );
@@ -1111,7 +1165,7 @@ fn unknown_receivers_do_not_commit_to_type_defaults() {
     let vs = verdicts(
         "package P {
             part def Choice { attribute enabled default = false; }
-            part installed : Choice;
+            part installed : Choice[1];
             attribute externalDefault default = true;
             calc def Identity { in x; return y = x; }
             calc def Read { in x : Choice; return y = x.enabled; }
@@ -1130,7 +1184,7 @@ fn unknown_receivers_do_not_commit_to_type_defaults() {
                 part concrete : Choice = installed;
             }
             requirement def Eligibility {
-                subject unit : Device;
+                subject unit : Device[1];
                 ref part requested : Choice;
                 ref part aliasUnit : Device = unit;
                 require constraint referenceDefault { requested.enabled }
@@ -1200,7 +1254,7 @@ fn unknown_receiver_methods_follow_redefined_defaults() {
                 }}
                 part def Specialized :> Base {{ {declaration} {value}; }}
                 requirement def R {{
-                    subject unit : Specialized;
+                    subject unit : Specialized[1];
                     require constraint direct {{ unit.ready }}
                     require constraint method {{ unit.enabled }}
                 }}
@@ -1228,7 +1282,7 @@ fn unknown_receivers_do_not_taint_imported_concrete_values() {
         "package Globals {
             attribute flag default = true;
             part def Child { attribute flag default = true; }
-            part installed : Child;
+            part installed : Child[1];
         }
         package P {
             part def Device {
@@ -1237,7 +1291,7 @@ fn unknown_receivers_do_not_taint_imported_concrete_values() {
                 attribute nested = installed.flag;
             }
             requirement def R {
-                subject unit : Device;
+                subject unit : Device[1];
                 require constraint scalar { unit.scalar }
                 require constraint nested { unit.nested }
             }
@@ -1261,7 +1315,11 @@ fn corpus_constraint_verdicts_ratchet() {
         .expect("library");
     for f in sysmlv2_testkit::user_files() {
         let src = fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        // Distinct source paths can share a basename; keep their identity seeds distinct.
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let checks = sysmlv2_parser::check::check_constraints(&model);
     let count = |v: fn(&sysmlv2_parser::check::ConstraintVerdict) -> bool| {
@@ -1284,8 +1342,14 @@ fn corpus_constraint_verdicts_ratchet() {
         // fabricated size of 1 emptied the range and made the forAll
         // vacuously true — never-actually-checked constraints now read
         // honestly undecided.
-        (4, 0, 119),
-        "constraint-verdict ratchet moved — violated must stay 0;          satisfied should only grow via evaluator improvements"
+        // 4 → 3 when a scenario's redefined samples inherited [0..*].
+        // Its size-dependent range was previously empty only because
+        // the collection placeholder was miscounted as one sample.
+        // 3 → 1 when subject bindings stopped treating package-owned
+        // collections as singleton receivers. Recovering these verdicts
+        // requires binding/cardinality inference, not a blanket default.
+        (1, 0, 122),
+        "constraint-verdict ratchet moved — violated must stay 0; changes require an explained improvement or soundness correction"
     );
 }
 
@@ -1844,3 +1908,181 @@ fn target_successions_must_be_adjacent_to_their_anchor() {
         "{diagnostics:#?}"
     );
 }
+
+#[test]
+fn multiplicity_validation_preserves_exact_large_endpoints() {
+    for (lo, hi) in [
+        ("9007199254740993", "9007199254740992"),
+        (
+            "170141183460469231731687303715884105729",
+            "170141183460469231731687303715884105728",
+        ),
+    ] {
+        let bad = sem_warnings(&format!("part p[{lo}..{hi}];"));
+        assert_eq!(
+            bad,
+            [format!(
+                "Error: multiplicity lower bound {lo} exceeds upper bound {hi}"
+            )]
+        );
+        for range in [
+            format!("{hi}..{lo}"),
+            format!("{lo}..{lo}"),
+            format!("{lo}..*"),
+        ] {
+            let good = sem_warnings(&format!("part p[{range}];"));
+            assert!(good.is_empty(), "{range}: {good:?}");
+        }
+    }
+    let huge = format!("1{}", "0".repeat(400));
+    let bigger = format!("2{}", "0".repeat(400));
+    let bad = sem_warnings(&format!("part p[{bigger}..{huge}];"));
+    assert_eq!(
+        bad,
+        [format!(
+            "Error: multiplicity lower bound {bigger} exceeds upper bound {huge}"
+        )]
+    );
+    assert!(sem_warnings(&format!("part p[{huge}..*];")).is_empty());
+    let negative = sem_warnings(&format!("attribute n = -{huge}; part p[n];"));
+    assert_eq!(negative, ["Error: multiplicity upper bound is negative"]);
+    let tiny = sem_warnings("attribute n = -1e-400; part p[n];");
+    assert!(
+        tiny.iter().any(|m| m.contains("Natural number")),
+        "{tiny:?}"
+    );
+    assert!(tiny.iter().any(|m| m.contains("negative")), "{tiny:?}");
+}
+
+#[test]
+fn multiplicity_conformance_uses_exact_valid_intervals() {
+    for (small, large) in [
+        (
+            "9007199254740992".to_string(),
+            "9007199254740993".to_string(),
+        ),
+        (
+            "170141183460469231731687303715884105728".to_string(),
+            "170141183460469231731687303715884105729".to_string(),
+        ),
+        (
+            format!("1{}", "0".repeat(400)),
+            format!("2{}", "0".repeat(400)),
+        ),
+    ] {
+        for (kind, base, child) in [
+            (":>>", format!("{large}..*"), format!("{small}..*")),
+            (":>>", format!("0..{small}"), format!("0..{large}")),
+            (":>", format!("0..{small}"), format!("0..{large}")),
+            (":>", format!("0..{large}"), "*".into()),
+        ] {
+            let findings = sem_warnings(&format!(
+                "part def A {{ part x[{base}]; }} part def B :> A {{ part y[{child}] {kind} x; }}"
+            ));
+            assert_eq!(findings.len(), 1, "{base} {kind} {child}: {findings:?}");
+            assert!(findings[0].starts_with("Warning:"), "{findings:?}");
+            assert!(findings[0].contains(&large), "{findings:?}");
+        }
+        for (base, child) in [
+            (format!("{large}..*"), format!("0..{small}")),
+            ("*".into(), large),
+        ] {
+            let findings = sem_warnings(&format!(
+                "part def A {{ part x[{base}]; }} part def B :> A {{ part y[{child}] :> x; }}"
+            ));
+            assert!(findings.is_empty(), "{base} :> {child}: {findings:?}");
+        }
+    }
+    for invalid in ["3..2", "1.5", "true", "*..2"] {
+        let findings = sem_warnings(&format!(
+            "part def A {{ part x[1]; }} part def B :> A {{ part y[{invalid}] :>> x; }}"
+        ));
+        assert!(!findings.is_empty());
+        assert!(
+            findings.iter().all(|m| !m.contains("is not within")),
+            "{invalid}: {findings:?}"
+        );
+    }
+    for invalid in ["3..2", "1.5", "true", "*..2"] {
+        let findings = sem_warnings(&format!(
+            "part def A {{ part x[{invalid}]; }} part def B :> A {{ part y[1] :>> x; }}"
+        ));
+        assert!(!findings.is_empty());
+        assert!(
+            findings.iter().all(|m| !m.contains("is not within")),
+            "base {invalid}: {findings:?}"
+        );
+    }
+    let unknown =
+        sem_warnings("attribute n; part def A { part x[1]; } part def B :> A { part y[n] :>> x; }");
+    assert!(unknown.is_empty(), "{unknown:?}");
+}
+
+#[test]
+fn exact_multiplicity_findings_preserve_replay_and_source_provenance() {
+    use std::sync::Arc;
+    use sysmlv2_parser::{
+        check, json::ResolvedModel, libcache::LibraryCache, prepared::PreparedLibrary,
+    };
+    let library = "package Bounds { attribute n = 9007199254740992;
+        part def Base { part x[0..n]; } }";
+    let user = "part bad[9007199254740993..Bounds::n];
+        part def Child :> Bounds::Base { part y[0..9007199254740993] :> x; }";
+    let mut base = Model::new();
+    base.add_library_source("bounds.sysml", library);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(37).unwrap(), 37).unwrap());
+    let mut expected = None;
+    for mode in 0..4 {
+        let mut model = Model::new();
+        match mode {
+            2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+            3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+            _ => {
+                model.add_library_source("bounds.sysml", library);
+                if mode == 1 {
+                    model.set_library_cache(cache.clone());
+                }
+            }
+        }
+        model.add_source("user.sysml", user);
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                .into_iter()
+                .map(|(unit, d)| {
+                    assert!(!model.is_library_unit(unit));
+                    (
+                        model.unit(unit).name.clone(),
+                        d.span.start,
+                        d.span.end,
+                        format!("{:?}", d.severity),
+                        d.message,
+                    )
+                })
+                .collect();
+            assert_eq!(findings.len(), 2, "{mode}: {findings:?}");
+            assert!(
+                findings[0]
+                    .4
+                    .contains("9007199254740993 exceeds upper bound 9007199254740992")
+            );
+            assert!(
+                findings[1]
+                    .4
+                    .contains("subsetting multiplicity upper bound 9007199254740993")
+            );
+            if let Some(expected) = &expected {
+                assert_eq!(&findings, expected, "mode {mode}");
+            } else {
+                expected = Some(findings);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_authored_prerequisites.rs b/crates/sysmlv2-parser/tests/checked_authored_prerequisites.rs
new file mode 100644
index 0000000..3175404
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_authored_prerequisites.rs
@@ -0,0 +1,303 @@
+//! Strict-ancestor authored positional chains reuse completed prerequisite plans.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+fn inherited(r: &mut ResolvedModel, owner: ElementRef) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|v| match v {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership"),
+        })
+        .collect())
+}
+fn edges(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let e = r.resolve_qualified(name).unwrap();
+    let rows = r
+        .implied_relationships(e)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>();
+    rows.into_iter()
+        .map(|e| {
+            (
+                r.element_id(e).to_string(),
+                r.property(e, "redefinedFeature").unwrap()["@id"]
+                    .as_str()
+                    .unwrap()
+                    .to_owned(),
+            )
+        })
+        .collect()
+}
+fn id(r: &mut ResolvedModel, name: &str) -> String {
+    let e = r.resolve_qualified(name).unwrap();
+    r.element_id(e).to_string()
+}
+fn membership(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let e = r.resolve_qualified(name).unwrap();
+    let value = r.property(e, "owningRelationship").unwrap();
+    r.element_by_id(value["@id"].as_str().unwrap()).unwrap()
+}
+fn authored_edges(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let e = r.resolve_qualified(name).unwrap();
+    let rows = r
+        .owned_relationships(e)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>();
+    rows.into_iter()
+        .filter_map(|e| {
+            if r.property(e, "isImplied").ok().and_then(|v| v.as_bool()) == Some(true) {
+                return None;
+            }
+            Some((
+                r.element_id(e).to_string(),
+                r.property(e, "redefinedFeature").unwrap()["@id"]
+                    .as_str()
+                    .unwrap()
+                    .to_owned(),
+            ))
+        })
+        .collect()
+}
+#[test]
+fn canonical_authored_prerequisites_preserve_actual_library_suppression_and_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(93).unwrap(), 93).unwrap());
+        for early_foreign in [true, false] {
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.load_library_dir(&library).unwrap();
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                // These are conformant role-preserving authored chains. In
+                // particular, an ordinary non-end redefining an end would fail
+                // validateRedefinitionEndConformance and is not used as a
+                // positive conformance fixture here.
+                let foreign="
+                    class MidEnd specializes BaseEnd {end feature midEnd;}
+                    class LeftEnd specializes MidEnd {end feature leftEnd redefines MidEnd::midEnd;}
+                    class RightEnd specializes MidEnd {end feature rightEnd redefines MidEnd::midEnd;}
+                    class ForeignEnd specializes LeftEnd,RightEnd {end feature selectedEnd redefines LeftEnd::leftEnd,RightEnd::rightEnd; class Unrelated;}
+                    behavior MidInput specializes BaseInput {in midInput;}
+                    behavior ForeignInput specializes MidInput {in selectedInput redefines MidInput::midInput;}
+                    function MidResult specializes BaseResult {return midResult;}
+                    function ForeignResult specializes MidResult {return selectedResult redefines MidResult::midResult;}
+                    package Aliases {alias selectedEndAlias for ForeignEnd::selectedEnd; alias selectedInputAlias for ForeignInput::selectedInput;}
+                ";
+                let consumers = "
+                    class EndProvider {public import Aliases::selectedEndAlias;}
+                    class EndChild specializes EndProvider,BaseEnd;
+                    class EndGrand specializes EndChild {end feature ownEnd;}
+                    behavior InputProvider {public import Aliases::selectedInputAlias;}
+                    behavior InputChild specializes InputProvider,BaseInput;
+                    behavior InputGrand specializes InputChild {in ownInput;}
+                    function ResultProvider {public import ForeignResult::selectedResult;}
+                    function ResultBridge specializes ResultProvider;
+                    function ResultGrand specializes ResultBridge {return ownResult;}
+                ";
+                let negative="
+                    class OtherEnd {end feature outside;}
+                    class CrossOwner {end feature selected redefines OtherEnd::outside;}
+                    class CrossProvider {public import CrossOwner::selected;}
+                    class CrossChild specializes CrossProvider;
+                    class SameOwner {end feature selected redefines SameOwner::other; end feature other;}
+                    class SameProvider {public import SameOwner::selected;}
+                    class SameChild specializes SameProvider;
+                    class CycleOne {end feature selected redefines CycleTwo::other;}
+                    class CycleTwo {end feature other redefines CycleOne::selected;}
+                    class CycleProvider {public import CycleOne::selected;}
+                    class CycleChild specializes CycleProvider;
+                ";
+                let source = format!(
+                    "class BaseEnd {{end feature baseEnd;}} behavior BaseInput {{in baseInput;}} function BaseResult {{return baseResult;}} {} {} {negative}",
+                    if early_foreign { foreign } else { consumers },
+                    if early_foreign { consumers } else { foreign }
+                );
+                let unit = model.add_source("checked-authored-prerequisites.kerml", &source);
+                assert!(
+                    unit.diagnostics.is_empty(),
+                    "{format:?} early={early_foreign} mode={mode}: {:?}",
+                    unit.diagnostics
+                );
+                let mut r = ResolvedModel::build(&model);
+                let result_grand = r.resolve_qualified("ResultGrand").unwrap();
+                let cold = inherited(&mut r, result_grand);
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(cold.unwrap(), vec![], "early={early_foreign} mode={mode}");
+                } else {
+                    assert!(matches!(cold, Err(OperationError::Incomplete { .. })));
+                }
+                let mut identities = Vec::<Vec<String>>::new();
+                // The intermediate owners contribute the implied suffix. Each
+                // later authored edge already fulfils its positional obligation.
+                for (source, target) in [
+                    ("MidEnd::midEnd", "BaseEnd::baseEnd"),
+                    ("MidInput::midInput", "BaseInput::baseInput"),
+                    ("MidResult::midResult", "BaseResult::baseResult"),
+                ] {
+                    let generated = edges(&mut r, source);
+                    assert_eq!(generated.len(), 1);
+                    assert_eq!(generated[0].1, id(&mut r, target));
+                    identities.push(generated.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                }
+                for (source, targets) in [
+                    ("LeftEnd::leftEnd", vec!["MidEnd::midEnd"]),
+                    ("RightEnd::rightEnd", vec!["MidEnd::midEnd"]),
+                    (
+                        "ForeignEnd::selectedEnd",
+                        vec!["LeftEnd::leftEnd", "RightEnd::rightEnd"],
+                    ),
+                    ("ForeignInput::selectedInput", vec!["MidInput::midInput"]),
+                    (
+                        "ForeignResult::selectedResult",
+                        vec!["MidResult::midResult"],
+                    ),
+                ] {
+                    let authored = authored_edges(&mut r, source);
+                    assert_eq!(
+                        authored
+                            .iter()
+                            .map(|(_, target)| target.clone())
+                            .collect::<Vec<_>>(),
+                        targets
+                            .into_iter()
+                            .map(|name| id(&mut r, name))
+                            .collect::<Vec<_>>()
+                    );
+                    assert!(
+                        edges(&mut r, source).is_empty(),
+                        "authored edge must prevent duplicate implied edge: {source}"
+                    );
+                    identities.push(authored.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                }
+                let result_edges = edges(&mut r, "ResultGrand::ownResult");
+                let aliases = r.resolve_qualified("Aliases").unwrap();
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(result_edges.len(), 1);
+                    assert_eq!(
+                        result_edges[0].1,
+                        id(&mut r, "ForeignResult::selectedResult")
+                    );
+                    for (owner, alias, excluded) in [
+                        (
+                            "EndChild",
+                            "selectedEndAlias",
+                            vec!["ForeignEnd::selectedEnd", "BaseEnd::baseEnd"],
+                        ),
+                        (
+                            "EndGrand",
+                            "selectedEndAlias",
+                            vec!["ForeignEnd::selectedEnd", "BaseEnd::baseEnd"],
+                        ),
+                        (
+                            "InputChild",
+                            "selectedInputAlias",
+                            vec!["ForeignInput::selectedInput", "BaseInput::baseInput"],
+                        ),
+                        (
+                            "InputGrand",
+                            "selectedInputAlias",
+                            vec!["ForeignInput::selectedInput", "BaseInput::baseInput"],
+                        ),
+                    ] {
+                        let owner = r.resolve_qualified(owner).unwrap();
+                        let selected = r
+                            .owned_relationships(aliases)
+                            .into_iter()
+                            .find(|&m| r.membership_member_name(m).as_deref() == Some(alias))
+                            .unwrap();
+                        let actual = inherited(&mut r, owner).unwrap();
+                        assert_eq!(actual, vec![selected]);
+                        identities.push(
+                            actual
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                        let features = r.type_feature_report(owner).projections.unwrap();
+                        for name in excluded {
+                            let e = r.resolve_qualified(name).unwrap();
+                            assert!(!features.features.contains(&e));
+                        }
+                        let unrelated = membership(&mut r, "ForeignEnd::Unrelated");
+                        assert!(
+                            !features.inherited_memberships.contains(&unrelated),
+                            "prerequisite owners cannot add inheritance"
+                        );
+                    }
+                    assert!(edges(&mut r, "EndGrand::ownEnd").is_empty());
+                    assert!(edges(&mut r, "InputGrand::ownInput").is_empty());
+                    let own_result = r.resolve_qualified("ResultGrand::ownResult").unwrap();
+                    assert_eq!(
+                        r.function_result_report(result_grand).result,
+                        Ok(Some(own_result))
+                    );
+                } else {
+                    for owner in ["EndChild", "EndGrand", "InputChild", "InputGrand"] {
+                        let e = r.resolve_qualified(owner).unwrap();
+                        assert!(matches!(
+                            inherited(&mut r, e),
+                            Err(OperationError::Incomplete { .. })
+                        ));
+                    }
+                }
+                for owner in ["CrossChild", "SameChild", "CycleChild"] {
+                    let e = r.resolve_qualified(owner).unwrap();
+                    assert!(
+                        matches!(inherited(&mut r, e), Err(OperationError::Incomplete { .. })),
+                        "unsupported {owner} {format:?} early={early_foreign} mode={mode}"
+                    );
+                }
+                identities.push(result_edges.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                if let Some(expected) = &expected {
+                    assert_eq!(
+                        &identities, expected,
+                        "{format:?} early={early_foreign} mode={mode}"
+                    );
+                } else {
+                    expected = Some(identities);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_cardinality.rs b/crates/sysmlv2-parser/tests/checked_cardinality.rs
new file mode 100644
index 0000000..85fe1c0
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_cardinality.rs
@@ -0,0 +1,179 @@
+//! Exact checked cardinality and collection questions across library replay modes.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    eval::Value,
+    json::{CardinalityBounds, CardinalityIssue, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+#[test]
+fn checked_collection_bounds_preserve_actual_library_and_prepared_results() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(91).unwrap(), 91).unwrap());
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(format);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.load_library_dir(&library).unwrap();
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source("checked-bounds.kerml", "feature a[2..5]; feature b[3..7]; feature c subsets a,b; feature zero[0]; feature fixed[3]; feature n=3; feature referenceBound[n]; feature formulaBound[(1+2)]; multiplicity huge[9223372036854775809]; feature named { multiplicity subsets huge; }");
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let unit = model.add_source("checked-default.sysml", "part def P { part singleton; port portSingleton; attribute attrSingleton; ref explicit[4]; }");
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let unit = model.add_source("contextual-bounds.kerml", "class BoundsParent { feature count=4; feature entries[count]; multiplicity limits[count]; feature namedEntries { multiplicity subsets limits; } } class BoundsChild specializes BoundsParent { feature count redefines BoundsParent::count=6; feature entries redefines BoundsParent::entries; feature namedEntries redefines BoundsParent::namedEntries; }");
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let c = r.resolve_qualified("c").unwrap();
+            if format == GraphFormat::CanonicalV3 {
+                r.implied_relationships(c);
+            }
+            for (name, expected) in [
+                ("BoundsParent::entries", 4),
+                ("BoundsParent::namedEntries", 4),
+                ("BoundsChild::entries", 6),
+                ("BoundsChild::namedEntries", 6),
+            ] {
+                let e = r.resolve_qualified(name).unwrap();
+                let report = r.cardinality_report(e);
+                assert_eq!(
+                    report
+                        .bounds
+                        .unwrap_or_else(|issue| panic!(
+                            "{name} {format:?} replay {mode}, {} steps: {issue:?}",
+                            report.steps
+                        ))
+                        .size(),
+                    Some(expected),
+                    "{name} {format:?} replay {mode}"
+                );
+            }
+            let fixed = r.resolve_qualified("fixed").unwrap();
+            let zero = r.resolve_qualified("zero").unwrap();
+            assert_eq!(
+                r.cardinality_report(c).bounds,
+                Ok(CardinalityBounds {
+                    lower: 3,
+                    upper: Some(5)
+                }),
+                "{format:?} mode {mode}"
+            );
+            for name in ["P::singleton", "P::portSingleton", "P::attrSingleton"] {
+                let e = r.resolve_qualified(name).unwrap();
+                let report = r.cardinality_report(e);
+                assert_eq!(
+                    report.bounds.unwrap().size(),
+                    Some(1),
+                    "{name} {format:?} {mode}"
+                );
+                assert_eq!(report.implicit_singletons, vec![e]);
+            }
+            let sequence = Value::Sequence(vec![
+                Value::Unbound(fixed),
+                Value::Sequence(vec![Value::Unbound(zero), Value::Integer(7)]),
+                Value::Element(fixed),
+            ]);
+            let bounds = r.collection_cardinality_report(&sequence).bounds.unwrap();
+            assert_eq!(bounds.size(), Some(5));
+            assert_eq!(bounds.is_empty(), Some(false));
+            assert_eq!(bounds.contains_index(5), Some(true));
+            assert_eq!(bounds.contains_index(6), Some(false));
+            assert_eq!(
+                r.collection_cardinality_report(&Value::UnboundMember(fixed))
+                    .bounds,
+                Err(CardinalityIssue::IncompleteProvider)
+            );
+            let dependent = r.resolve_qualified("referenceBound").unwrap();
+            assert_eq!(
+                r.collection_cardinality_report(&Value::UnboundMember(dependent))
+                    .bounds,
+                Err(CardinalityIssue::IncompleteProvider)
+            );
+            for name in ["referenceBound", "formulaBound"] {
+                let e = r.resolve_qualified(name).unwrap();
+                let report = r.cardinality_report(e);
+                if name == "formulaBound" && format == GraphFormat::LegacyV2 {
+                    assert_eq!(report.bounds, Err(CardinalityIssue::UnsupportedBound));
+                } else {
+                    assert_eq!(
+                        report
+                            .bounds
+                            .unwrap_or_else(|issue| panic!(
+                                "{name} {format:?} mode {mode}: {issue:?}"
+                            ))
+                            .size(),
+                        Some(3),
+                        "{name} {format:?} {mode}"
+                    );
+                }
+            }
+            let named = r.resolve_qualified("named").unwrap();
+            assert_eq!(
+                r.cardinality_report(named).bounds.unwrap().size(),
+                Some(9223372036854775809)
+            );
+            r.implied_relationships(named);
+            assert_eq!(
+                r.cardinality_report(named).bounds.unwrap().size(),
+                Some(9223372036854775809)
+            );
+            assert_eq!(
+                r.cardinality_report(c).bounds,
+                Ok(CardinalityBounds {
+                    lower: 3,
+                    upper: Some(5)
+                })
+            );
+        }
+    }
+}
+
+#[test]
+fn unknown_receiver_members_do_not_fabricate_outer_collection_cardinality() {
+    let mut model = Model::new();
+    let unit = model.add_source("receiver-cardinality.kerml", "class C { feature items[3]; } feature empty[0]:C; feature many[0..*]:C; feature a=empty.items; feature b=many.items;");
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    let items = r.resolve_qualified("C::items").unwrap();
+    assert_eq!(
+        r.collection_cardinality_report(&Value::UnboundMember(items))
+            .bounds,
+        Err(CardinalityIssue::IncompleteProvider)
+    );
+    let empty = r.resolve_qualified("a").unwrap();
+    let value = r.evaluate(empty).unwrap();
+    assert_eq!(
+        r.collection_cardinality_report(&value)
+            .bounds
+            .unwrap()
+            .size(),
+        Some(0)
+    );
+    let many = r.resolve_qualified("b").unwrap();
+    let value = r.evaluate(many).unwrap();
+    assert_eq!(
+        r.collection_cardinality_report(&value).bounds,
+        Err(CardinalityIssue::IncompleteProvider)
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/checked_constructors.rs b/crates/sysmlv2-parser/tests/checked_constructors.rs
new file mode 100644
index 0000000..55a71ce
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_constructors.rs
@@ -0,0 +1,203 @@
+//! Constructor obligations over the real standard library and replay paths.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ModelLevelEvaluability, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+#[test]
+fn checked_constructor_obligations_preserve_actual_library_replay_results() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    let mut base = Model::with_graph_format(GraphFormat::CanonicalV3);
+    base.load_library_dir(&library).unwrap();
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(149).unwrap(), 149).unwrap());
+    let mut expected = None;
+    for mode in 0..4 {
+        let mut model = Model::with_graph_format(GraphFormat::CanonicalV3);
+        match mode {
+            2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+            3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+            _ => {
+                model.load_library_dir(&library).unwrap();
+                if mode == 1 {
+                    model.set_library_cache(cache.clone());
+                }
+            }
+        }
+        let parsed = model.add_source(
+            "checked-constructor.kerml",
+            "class C {feature a; feature b default = 2;} feature instance=new C(1);",
+        );
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let expressions: Vec<_> = r
+            .user_elements()
+            .filter(|&e| r.element_type(e) == "ConstructorExpression")
+            .collect();
+        assert_eq!(
+            expressions.len(),
+            1,
+            "one user constructor valuation, mode {mode}"
+        );
+        let expression = expressions[0];
+        r.implied_relationships(expression);
+        let report = r.constructor_result_report(expression);
+        let result = report
+            .result
+            .unwrap_or_else(|issue| panic!("mode {mode}: {issue:?}, steps {}", report.steps));
+        assert_eq!(result.arguments.bindings.len(), 1, "mode {mode}");
+        // A Class specializes Occurrences::Occurrence. Its eight inherited
+        // defaults are result obligations as well as the locally omitted b.
+        let expected_defaults: Vec<_> = [
+            "C::b",
+            "Occurrences::Occurrence::portionOfLife",
+            "Occurrences::Occurrence::this",
+            "Occurrences::Occurrence::localClock",
+            "Occurrences::Occurrence::isDispatch",
+            "Occurrences::Occurrence::dispatchScope",
+            "Occurrences::Occurrence::isRunToCompletion",
+            "Occurrences::Occurrence::runToCompletionScope",
+            "Occurrences::Occurrence::incomingTransferSort",
+        ]
+        .into_iter()
+        .map(|name| r.resolve_qualified(name).unwrap())
+        .collect();
+        assert_eq!(
+            result
+                .defaults
+                .iter()
+                .map(|binding| binding.feature)
+                .collect::<Vec<_>>(),
+            expected_defaults,
+            "mode {mode}"
+        );
+        assert_eq!(
+            result.arguments.bindings[0].feature,
+            r.resolve_qualified("C::a").unwrap(),
+            "mode {mode}"
+        );
+        assert_eq!(
+            result.defaults[0].feature,
+            r.resolve_qualified("C::b").unwrap(),
+            "mode {mode}"
+        );
+        assert_eq!(
+            r.model_level_evaluability(expression).classification,
+            ModelLevelEvaluability::Evaluable,
+            "mode {mode}"
+        );
+        let identities = (
+            r.element_id(result.arguments.bindings[0].feature),
+            result
+                .defaults
+                .iter()
+                .map(|binding| {
+                    (
+                        r.element_id(binding.feature),
+                        r.element_id(binding.feature_with_value),
+                        r.element_id(binding.valuation),
+                        r.element_id(binding.value),
+                    )
+                })
+                .collect::<Vec<_>>(),
+        );
+        if let Some(expected) = &expected {
+            assert_eq!(&identities, expected, "mode {mode}");
+        } else {
+            expected = Some(identities);
+        }
+        assert_eq!(
+            r.constructor_result_report(expression).result.unwrap(),
+            result,
+            "warm mode {mode}"
+        );
+        if mode == 0 {
+            let full = sysmlv2_parser::full::resolved_to_full_json_with_policy(
+                &mut r,
+                &model,
+                sysmlv2_parser::full::UnresolvedReferencePolicy::Preserve,
+            )
+            .unwrap();
+            let rows = full.as_array().unwrap();
+            assert_eq!(
+                rows.iter()
+                    .filter(|row| row["@type"] == "BindingConnector" && row["isImplied"] == true)
+                    .count(),
+                9
+            );
+            let by_id: std::collections::HashMap<_, _> = rows
+                .iter()
+                .map(|row| (row["@id"].as_str().unwrap(), row))
+                .collect();
+            for connector in rows
+                .iter()
+                .filter(|row| row["@type"] == "BindingConnector" && row["isImplied"] == true)
+            {
+                let featuring: Vec<_> = rows
+                    .iter()
+                    .filter(|row| {
+                        row["@type"] == "TypeFeaturing"
+                            && row["featuringType"]["@id"] == connector["@id"]
+                    })
+                    .collect();
+                assert_eq!(
+                    featuring.len(),
+                    2,
+                    "each default connector has both end featuring relationships"
+                );
+                let mut sources = std::collections::HashSet::new();
+                for relationship in featuring {
+                    let source_id = relationship["featureOfType"]["@id"].as_str().unwrap();
+                    assert!(sources.insert(source_id));
+                    let source = by_id[source_id];
+                    assert_eq!(source["isEnd"], true);
+                    assert!(
+                        source["ownedTypeFeaturing"]
+                            .as_array()
+                            .unwrap()
+                            .iter()
+                            .any(|reference| reference["@id"] == relationship["@id"])
+                    );
+                }
+            }
+            let schema: serde_json::Value = serde_json::from_str(
+                &std::fs::read_to_string(
+                    sysmlv2_testkit::workspace_root().join("spec-refs/SysML.schema.json"),
+                )
+                .unwrap(),
+            )
+            .unwrap();
+            let mut validators = std::collections::HashMap::new();
+            for row in rows {
+                let kind = row["@type"].as_str().unwrap();
+                let validator = validators.entry(kind.to_owned()).or_insert_with(|| {
+                    let definition = &schema["$defs"][kind];
+                    let mut exact = if definition.get("anyOf").is_some() {
+                        definition["anyOf"][0].clone()
+                    } else {
+                        definition.clone()
+                    };
+                    exact["$defs"] = schema["$defs"].clone();
+                    jsonschema::validator_for(&exact).unwrap()
+                });
+                let failures: Vec<_> = validator
+                    .iter_errors(row)
+                    .map(|error| error.to_string())
+                    .collect();
+                assert!(failures.is_empty(), "{kind}: {failures:?}");
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_definition_usage.rs b/crates/sysmlv2-parser/tests/checked_definition_usage.rs
new file mode 100644
index 0000000..6bb0db2
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_definition_usage.rs
@@ -0,0 +1,70 @@
+//! Inherited Usage subsets share the complete Type feature certificate.
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel},
+    model::{GraphFormat, Model},
+};
+
+#[test]
+fn definition_usage_subsets_include_actual_library_and_inherited_members() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        let parsed = model.add_source("usages.sysml", "package P { part def Base { part sensor; port bus; action act; } part def Child :> Base { part extra; } part def Broken :> Missing; }");
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let child = r.resolve_qualified("P::Child").unwrap();
+        let usages = r.property(child, "usage").unwrap();
+        for name in [
+            "P::Base::sensor",
+            "P::Base::bus",
+            "P::Base::act",
+            "P::Child::extra",
+            "Parts::Part::ownedPorts",
+            "Items::Item::checkedConstraints",
+        ] {
+            let member = r.resolve_qualified(name).unwrap();
+            assert!(
+                usages
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .any(|v| v["@id"] == r.element_id(member).to_string()),
+                "{format:?}: {name}"
+            );
+        }
+        assert_eq!(
+            r.property(child, "directedUsage").unwrap(),
+            serde_json::json!([])
+        );
+        let broken = r.resolve_qualified("P::Broken").unwrap();
+        assert!(r.property(broken, "usage").is_err());
+    }
+}
+
+#[test]
+fn simple_part_strict_export_retains_only_the_unproved_implied_completeness_flag() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        assert!(
+            model
+                .add_source("simple.sysml", "part def Box;")
+                .diagnostics
+                .is_empty()
+        );
+        let mut r = ResolvedModel::build(&model);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let report = r.to_full_json_strict().unwrap_err();
+        assert_eq!(report.issues.len(), 1, "{format:?}: {report:?}");
+        assert_eq!(report.issues[0].property, "isImpliedIncluded");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_end_contexts.rs b/crates/sysmlv2-parser/tests/checked_end_contexts.rs
new file mode 100644
index 0000000..aa175dc
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_end_contexts.rs
@@ -0,0 +1,127 @@
+//! Checked end completion preserves its supported ownership boundary across replay.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, PropertyError, ResolvedModel, UsageVariabilityIssue},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+#[test]
+fn typed_occurrence_ends_and_positional_redefinitions_preserve_replay_evidence() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(73).unwrap(), 73).unwrap());
+        let mut expected_ids = None;
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(format);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.load_library_dir(&library).unwrap();
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source(
+                "checked-ends.sysml",
+                "occurrence def Ends {\n\
+                    end item itemEnd : Items::Item;\n\
+                    end part partEnd : Parts::Part;\n\
+                    end ref referenceEnd : Items::Item :> Objects::objects;\n\
+                 }\n\
+                 occurrence def Refined :> Ends {\n\
+                    end item itemEnd; end part partEnd;\n\
+                    end ref referenceEnd : Items::Item :> Objects::objects;\n\
+                 }\n\
+                 part def ContextualOwner {end item itemEnd;}\n\
+                 part def MissingType {end item itemEnd : Missing;}\n\
+                 occurrence def TypedReference {end ref typedEnd : Items::Item;}",
+            );
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut resolved = ResolvedModel::build(&model);
+            resolved.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            let ids: Vec<_> = resolved
+                .user_elements()
+                .map(|e| resolved.element_id(e))
+                .collect();
+            if let Some(expected) = &expected_ids {
+                assert_eq!(&ids, expected, "{format:?} replay {mode}");
+            } else {
+                expected_ids = Some(ids.clone());
+            }
+            for name in [
+                "Ends::itemEnd",
+                "Ends::partEnd",
+                "Ends::referenceEnd",
+                "Refined::itemEnd",
+                "Refined::partEnd",
+                "Refined::referenceEnd",
+                "ContextualOwner::itemEnd",
+            ] {
+                let end = resolved.resolve_qualified(name).unwrap();
+                let owned = resolved.element_properties(end);
+                let report = resolved.usage_variability_report(end);
+                assert_eq!(report.value, Ok(true), "{format:?} replay {mode}: {name}");
+                for property in ["isVariable", "mayTimeVary"] {
+                    assert_eq!(resolved.property(end, property), Ok(true.into()));
+                }
+                let constant = resolved.property(end, "isConstant");
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(constant, Ok(true.into()));
+                    let obligations = resolved.end_constancy_report(end);
+                    assert_eq!(obligations.variable_end_is_constant, Ok(true));
+                    assert_eq!(obligations.constant_is_variable, Ok(true));
+                } else {
+                    assert_eq!(constant, Err(PropertyError::NotComputed));
+                }
+                assert_eq!(resolved.element_properties(end), owned);
+            }
+            // An unresolved type cannot certify the end's specialization
+            // exclusions, even under a supported structural owner.
+            let unresolved_end = resolved.resolve_qualified("MissingType::itemEnd").unwrap();
+            assert_eq!(
+                resolved.usage_variability_report(unresolved_end).value,
+                Err(UsageVariabilityIssue::IncompleteSpecialization),
+                "{format:?} replay {mode}: MissingType::itemEnd"
+            );
+            assert!(resolved.property(unresolved_end, "isConstant").is_err());
+            let typed = resolved
+                .resolve_qualified("TypedReference::typedEnd")
+                .unwrap();
+            if format == GraphFormat::CanonicalV3 {
+                assert_eq!(resolved.usage_variability_report(typed).value, Ok(true));
+                assert_eq!(resolved.property(typed, "isConstant"), Ok(true.into()));
+            } else {
+                assert_eq!(
+                    resolved.usage_variability_report(typed).value,
+                    Err(UsageVariabilityIssue::IncompleteSpecialization)
+                );
+            }
+            assert_eq!(
+                ids,
+                resolved
+                    .user_elements()
+                    .map(|e| resolved.element_id(e))
+                    .collect::<Vec<_>>()
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_import_planning.rs b/crates/sysmlv2-parser/tests/checked_import_planning.rs
new file mode 100644
index 0000000..528e19a
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_import_planning.rs
@@ -0,0 +1,250 @@
+//! Canonical import planning widens complete selectors without changing Legacy publication.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+const OP: &str = "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean";
+fn inherited(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    excluded: Vec<ElementRef>,
+) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        OP,
+        &[
+            DerivedValue::Elements(excluded),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|value| match value {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership identity"),
+        })
+        .collect())
+}
+fn member(r: &mut ResolvedModel, owner: &str, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(owner).unwrap();
+    r.owned_relationships(owner)
+        .into_iter()
+        .find(|&m| r.membership_member_name(m).as_deref() == Some(name))
+        .unwrap_or_else(|| panic!("missing {name}"))
+}
+fn implied_redefinitions(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let owner = r.resolve_qualified(name).unwrap();
+    r.implied_relationships(owner)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>()
+        .into_iter()
+        .map(|e| {
+            let id = r.element_id(e).to_string();
+            let target = r.property(e, "redefinedFeature").unwrap()["@id"]
+                .as_str()
+                .unwrap()
+                .to_owned();
+            (id, target)
+        })
+        .collect()
+}
+#[test]
+fn canonical_package_and_direct_member_import_planning_preserves_actual_library_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(83).unwrap(), 83).unwrap());
+        let mut expected_ids = None;
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(format);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.load_library_dir(&library).unwrap();
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source(
+                "checked-import-planning.kerml",
+                "
+                package External {class Scalar;}
+                package Leaf {alias scalarAlias for External::Scalar;}
+                package Middle {
+                    package Nested {alias nestedAlias for External::Scalar;}
+                    public import Leaf::*;
+                }
+                class TransitiveProvider {public import Middle::*;}
+                class TransitiveChild specializes TransitiveProvider;
+                class RecursiveProvider {public import Middle::**;}
+                class RecursiveChild specializes RecursiveProvider;
+                class Ancestor {feature seed;}
+                class Declaring specializes Ancestor {
+                    feature selected redefines Ancestor::seed;
+                    feature unrelated;
+                }
+                class DirectProvider {
+                    public import Declaring::selected;
+                    public import Ancestor::seed;
+                }
+                class DirectChild specializes DirectProvider;
+                class RedefinedChild specializes DirectProvider {
+                    feature replacement redefines Declaring::selected;
+                }
+                package MarkerLeaf {class Marker;}
+                package Reexport {public import MarkerLeaf::*;}
+                class BaseOwner {public import Reexport::*; end feature original;}
+                class Child specializes BaseOwner {end feature replacement;}
+                class EndBase {end feature baseEnd;}
+                class EndOwner specializes EndBase {end feature importedEnd;}
+                class EndProvider {public import EndOwner::importedEnd;}
+                class EndBridge specializes EndProvider;
+                class EndChild specializes EndBridge {end feature childEnd;}
+            ",
+            );
+            assert!(
+                unit.diagnostics.is_empty(),
+                "{format:?} replay {mode}: {:?}",
+                unit.diagnostics
+            );
+            let mut r = ResolvedModel::build(&model);
+            let transitive = r.resolve_qualified("TransitiveChild").unwrap();
+            let recursive = r.resolve_qualified("RecursiveChild").unwrap();
+            let direct = r.resolve_qualified("DirectChild").unwrap();
+            let redefined = r.resolve_qualified("RedefinedChild").unwrap();
+            let child = r.resolve_qualified("Child").unwrap();
+            let middle = r.resolve_qualified("Middle").unwrap();
+            let leaf = r.resolve_qualified("Leaf").unwrap();
+            let selected = member(&mut r, "Declaring", "selected");
+            let nested = member(&mut r, "Middle", "Nested");
+            let scalar = member(&mut r, "Leaf", "scalarAlias");
+            let marker = member(&mut r, "MarkerLeaf", "Marker");
+            let mut identities = Vec::new();
+            if format == GraphFormat::CanonicalV3 {
+                let cases = [
+                    (transitive, vec![], vec![nested, scalar]),
+                    (transitive, vec![leaf], vec![nested]),
+                    (transitive, vec![middle], vec![]),
+                    (direct, vec![], vec![selected]),
+                    (redefined, vec![], vec![]),
+                    (child, vec![], vec![marker]),
+                ];
+                for (owner, excluded, expected) in cases {
+                    let actual = inherited(&mut r, owner, excluded).unwrap_or_else(|e| {
+                        panic!("{format:?} replay {mode} owner {owner:?}: {e:?}")
+                    });
+                    assert_eq!(actual, expected, "{format:?} replay {mode} owner {owner:?}");
+                    identities.push(
+                        actual
+                            .into_iter()
+                            .map(|e| r.element_id(e).to_string())
+                            .collect::<Vec<_>>(),
+                    );
+                }
+                let features = r.type_feature_report(direct).projections.unwrap();
+                let imported_feature = r.resolve_qualified("Declaring::selected").unwrap();
+                let seed = r.resolve_qualified("Ancestor::seed").unwrap();
+                let unrelated = r.resolve_qualified("Declaring::unrelated").unwrap();
+                assert!(features.inherited_features.contains(&imported_feature));
+                assert!(!features.inherited_features.contains(&seed));
+                assert!(!features.features.contains(&unrelated));
+            } else {
+                for owner in [transitive, recursive, direct, redefined, child] {
+                    assert!(
+                        matches!(
+                            inherited(&mut r, owner, vec![]),
+                            Err(OperationError::Incomplete { .. })
+                        ),
+                        "{format:?} replay {mode} owner {owner:?}"
+                    );
+                }
+            }
+            // The central selector can traverse these packages, but the shared
+            // Type scope provider still qualifies recursive name dependencies.
+            // Exclusions cannot turn that incomplete provider into a certificate.
+            for excluded in [vec![], vec![middle]] {
+                assert!(
+                    matches!(
+                        inherited(&mut r, recursive, excluded),
+                        Err(OperationError::Incomplete { .. })
+                    ),
+                    "{format:?} replay {mode}"
+                );
+            }
+            let edges = implied_redefinitions(&mut r, "Child::replacement");
+            let original = r.resolve_qualified("BaseOwner::original").unwrap();
+            if format == GraphFormat::CanonicalV3 {
+                assert_eq!(edges.len(), 1, "{format:?} replay {mode}");
+                assert_eq!(edges[0].1, r.element_id(original).to_string());
+            } else {
+                assert!(edges.is_empty(), "Legacy publication must remain unchanged");
+            }
+            identities.push(
+                edges
+                    .iter()
+                    .flat_map(|(id, target)| [id.clone(), target.clone()])
+                    .collect(),
+            );
+            // Canonical can now schedule this exact ordinary end's owner as
+            // a prerequisite without making that owner an inherited base.
+            let end_child = r.resolve_qualified("EndChild").unwrap();
+            let end_edges = implied_redefinitions(&mut r, "EndChild::childEnd");
+            if format == GraphFormat::CanonicalV3 {
+                assert!(inherited(&mut r, end_child, vec![]).unwrap().is_empty());
+                let selected = r.resolve_qualified("EndOwner::importedEnd").unwrap();
+                assert_eq!(end_edges.len(), 1, "{format:?} replay {mode}");
+                assert_eq!(end_edges[0].1, r.element_id(selected).to_string());
+            } else {
+                assert!(matches!(
+                    inherited(&mut r, end_child, vec![]),
+                    Err(OperationError::Incomplete { .. })
+                ));
+                assert!(end_edges.is_empty());
+            }
+            identities.push(
+                end_edges
+                    .into_iter()
+                    .flat_map(|(id, target)| [id, target])
+                    .collect(),
+            );
+            let owner_edges = implied_redefinitions(&mut r, "EndOwner::importedEnd");
+            let base_end = r.resolve_qualified("EndBase::baseEnd").unwrap();
+            assert_eq!(owner_edges.len(), 1, "{format:?} replay {mode}");
+            assert_eq!(owner_edges[0].1, r.element_id(base_end).to_string());
+            identities.push(
+                owner_edges
+                    .into_iter()
+                    .flat_map(|(id, target)| [id, target])
+                    .collect(),
+            );
+            if let Some(expected) = &expected_ids {
+                assert_eq!(&identities, expected, "{format:?} replay {mode}");
+            } else {
+                expected_ids = Some(identities);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_owned_relationships.rs b/crates/sysmlv2-parser/tests/checked_owned_relationships.rs
new file mode 100644
index 0000000..8e4aff6
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_owned_relationships.rs
@@ -0,0 +1,86 @@
+//! Structural ownership remains readable when inherited semantics are incomplete.
+use serde_json::{Value, json};
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ElementRef, ResolvedModel},
+    model::Model,
+};
+
+fn relationships(r: &mut ResolvedModel, owner: ElementRef) -> Vec<Value> {
+    let written = r.owned_relationships(owner);
+    let implied = r.implied_relationships(owner);
+    let mut expected = Vec::new();
+    for relationship in written.into_iter().chain(implied) {
+        let value = json!({"@id": r.element_id(relationship).to_string()});
+        if !expected.contains(&value) {
+            expected.push(value);
+        }
+    }
+    expected
+}
+
+#[test]
+fn checked_owned_relationships_include_materialized_edges_in_order() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let unit = model.add_source(
+        "ownership.sysml",
+        "package P { part def A { part child; } part def B :> A; part b : B; }",
+    );
+    assert!(unit.diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&model);
+    let mut with_implied = 0;
+    for name in ["P::A", "P::B", "P::b"] {
+        let owner = r.resolve_qualified(name).unwrap();
+        // The first checked call must publish the same edges as a warm call.
+        let cold = r.property(owner, "ownedRelationship").unwrap();
+        let expected = relationships(&mut r, owner);
+        let has_implied = !r.implied_relationships(owner).is_empty();
+        with_implied += usize::from(has_implied);
+        assert_eq!(cold, json!(expected), "{name}");
+        for policy in [
+            ClosurePolicy::default(),
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            assert_eq!(r.property(owner, "ownedRelationship").unwrap(), cold);
+        }
+        for value in cold.as_array().unwrap() {
+            let relationship = r.element_by_id(value["@id"].as_str().unwrap()).unwrap();
+            assert_eq!(
+                r.property(relationship, "owningRelatedElement").unwrap(),
+                json!({"@id":r.element_id(owner).to_string()}),
+            );
+        }
+        // Listing materialized edges does not claim complete implied semantics.
+        if has_implied {
+            assert!(r.property(owner, "isImpliedIncluded").is_err());
+        }
+    }
+    assert!(with_implied > 0);
+}
+
+#[test]
+fn structural_reads_do_not_hide_unresolved_owned_relationships() {
+    let mut model = Model::new();
+    model.add_source("ownership.sysml", "part broken : Missing;");
+    let mut r = ResolvedModel::build(&model);
+    let owner = r.resolve_qualified("broken").unwrap();
+    let expected = relationships(&mut r, owner);
+    assert!(!expected.is_empty());
+    assert_eq!(
+        r.property(owner, "ownedRelationship").unwrap(),
+        json!(expected)
+    );
+    let strict = r.to_full_json_strict().unwrap_err();
+    assert!(
+        !strict
+            .issues
+            .iter()
+            .any(|issue| issue.property == "ownedRelationship")
+    );
+    assert!(strict.issues.iter().any(|issue| issue.property == "type"));
+}
diff --git a/crates/sysmlv2-parser/tests/checked_parameter_prerequisites.rs b/crates/sysmlv2-parser/tests/checked_parameter_prerequisites.rs
new file mode 100644
index 0000000..539f301
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_parameter_prerequisites.rs
@@ -0,0 +1,301 @@
+//! Imported parameter prerequisites preserve owned-parameter and effective-result rules.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+fn inherited(r: &mut ResolvedModel, owner: ElementRef) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|v| match v {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership"),
+        })
+        .collect())
+}
+fn edges(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let e = r.resolve_qualified(name).unwrap();
+    let rows = r
+        .implied_relationships(e)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>();
+    rows.into_iter()
+        .map(|e| {
+            (
+                r.element_id(e).to_string(),
+                r.property(e, "redefinedFeature").unwrap()["@id"]
+                    .as_str()
+                    .unwrap()
+                    .to_owned(),
+            )
+        })
+        .collect()
+}
+fn id(r: &mut ResolvedModel, name: &str) -> String {
+    let e = r.resolve_qualified(name).unwrap();
+    r.element_id(e).to_string()
+}
+fn membership(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let e = r.resolve_qualified(name).unwrap();
+    let value = r.property(e, "owningRelationship").unwrap();
+    r.element_by_id(value["@id"].as_str().unwrap()).unwrap()
+}
+#[test]
+fn canonical_parameter_prerequisites_preserve_actual_library_oracles_and_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(91).unwrap(), 91).unwrap());
+        for early_foreign in [true, false] {
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.load_library_dir(&library).unwrap();
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let foreign="
+                    behavior ForeignBehavior specializes BaseBehavior {in a; out z; inout both;}
+                    function ForeignFunction specializes BaseFunction {return answer;}
+                    package Aliases {alias inputAlias for ForeignBehavior::a; alias resultAlias for ForeignFunction::answer;}
+                ";
+                let consumers="
+                    behavior ParameterProvider {public import ForeignBehavior::a; public import ForeignBehavior::z; public import ForeignBehavior::both;}
+                    behavior ParameterBridge specializes ParameterProvider;
+                    behavior ParameterGrand specializes ParameterBridge {in ownInput; out ownOutput; inout ownBoth;}
+                    behavior AliasProvider {public import Aliases::inputAlias;}
+                    behavior AliasChild specializes AliasProvider,BaseBehavior;
+                    behavior SiblingChild specializes AliasChild,ForeignBehavior {in siblingInput; out siblingOutput; inout siblingBoth;}
+                    function ResultProvider {public import ForeignFunction::answer;}
+                    function ResultBridge specializes ResultProvider;
+                    function ResultGrand specializes ResultBridge {return ownAnswer;}
+                    function ResultAliasProvider {public import Aliases::resultAlias;}
+                    function ResultAliasChild specializes ResultAliasProvider,BaseFunction;
+                    function ResultAliasGrand specializes ResultAliasChild {return aliasAnswer;}
+                ";
+                let source=format!("behavior BaseBehavior {{in b; out baseOutput; inout baseBoth;}} function BaseFunction {{return baseAnswer;}} {} {}\n
+                    behavior OtherBehavior {{in outside;}}
+                    behavior MixedBehavior specializes BaseBehavior {{in a; feature ordinary redefines OtherBehavior::outside;}}
+                    behavior MixedProvider {{public import MixedBehavior::a;}}
+                    behavior MixedChild specializes MixedProvider {{in localInput;}}
+                ", if early_foreign {foreign}else{consumers},if early_foreign {consumers}else{foreign});
+                let unit = model.add_source("checked-parameter-prerequisites.kerml", &source);
+                assert!(
+                    unit.diagnostics.is_empty(),
+                    "{format:?} early={early_foreign} mode={mode}: {:?}",
+                    unit.diagnostics
+                );
+                let mut r = ResolvedModel::build(&model);
+                let result_grand = r.resolve_qualified("ResultGrand").unwrap();
+                let cold = inherited(&mut r, result_grand);
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(cold.unwrap(), vec![], "early={early_foreign} mode={mode}");
+                } else {
+                    assert!(matches!(cold, Err(OperationError::Incomplete { .. })));
+                }
+                let mut identities = Vec::<Vec<String>>::new();
+                for (source, target, direction) in [
+                    ("ForeignBehavior::a", "BaseBehavior::b", "in"),
+                    ("ForeignBehavior::z", "BaseBehavior::baseOutput", "out"),
+                    ("ForeignBehavior::both", "BaseBehavior::baseBoth", "inout"),
+                    ("ForeignFunction::answer", "BaseFunction::baseAnswer", "out"),
+                ] {
+                    let generated = edges(&mut r, source);
+                    assert_eq!(
+                        generated.len(),
+                        1,
+                        "{format:?} {source} early={early_foreign} mode={mode}"
+                    );
+                    assert_eq!(generated[0].1, id(&mut r, target));
+                    let e = r.resolve_qualified(source).unwrap();
+                    assert_eq!(
+                        r.property(e, "direction").unwrap().as_str(),
+                        Some(direction)
+                    );
+                    if source == "ForeignFunction::answer" {
+                        let m = membership(&mut r, source);
+                        assert_eq!(r.element_type(m), "ReturnParameterMembership");
+                    }
+                    identities.push(generated.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                }
+                let result_edges = edges(&mut r, "ResultGrand::ownAnswer");
+                let alias_result_edges = edges(&mut r, "ResultAliasGrand::aliasAnswer");
+                let parameter_grand = r.resolve_qualified("ParameterGrand").unwrap();
+                let alias_child = r.resolve_qualified("AliasChild").unwrap();
+                let sibling = r.resolve_qualified("SiblingChild").unwrap();
+                let alias_result = r.resolve_qualified("ResultAliasChild").unwrap();
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(result_edges.len(), 1, "early={early_foreign} mode={mode}");
+                    assert_eq!(result_edges[0].1, id(&mut r, "ForeignFunction::answer"));
+                    assert!(
+                        alias_result_edges.is_empty(),
+                        "an alias cannot create a result slot"
+                    );
+                    // Ordinary parameters pair with a direct base's effective
+                    // parameters, as results do with its effective result: the
+                    // imported inputs are slots one inheritance step later.
+                    for (name, target) in [
+                        ("ParameterGrand::ownInput", "ForeignBehavior::a"),
+                        ("ParameterGrand::ownOutput", "ForeignBehavior::z"),
+                        ("ParameterGrand::ownBoth", "ForeignBehavior::both"),
+                    ] {
+                        let generated = edges(&mut r, name);
+                        assert_eq!(
+                            generated.len(),
+                            1,
+                            "{name} early={early_foreign} mode={mode}"
+                        );
+                        assert_eq!(generated[0].1, id(&mut r, target), "{name}");
+                    }
+                    let actual = inherited(&mut r, parameter_grand).unwrap();
+                    assert!(
+                        actual.is_empty(),
+                        "the imported inputs are taken over: early={early_foreign} mode={mode}"
+                    );
+                    identities.push(
+                        actual
+                            .into_iter()
+                            .map(|e| r.element_id(e).to_string())
+                            .collect(),
+                    );
+                    let aliases = r.resolve_qualified("Aliases").unwrap();
+                    let alias_membership = r
+                        .owned_relationships(aliases)
+                        .into_iter()
+                        .find(|&m| r.membership_member_name(m).as_deref() == Some("inputAlias"))
+                        .unwrap();
+                    let actual = inherited(&mut r, alias_child).unwrap();
+                    assert_eq!(
+                        actual,
+                        vec![
+                            alias_membership,
+                            membership(&mut r, "BaseBehavior::baseOutput"),
+                            membership(&mut r, "BaseBehavior::baseBoth")
+                        ]
+                    );
+                    identities.push(
+                        actual
+                            .into_iter()
+                            .map(|e| r.element_id(e).to_string())
+                            .collect(),
+                    );
+                    let alias_features = r.type_feature_report(alias_child).projections.unwrap();
+                    for name in ["ForeignBehavior::a", "BaseBehavior::b"] {
+                        let e = r.resolve_qualified(name).unwrap();
+                        assert!(!alias_features.features.contains(&e));
+                    }
+                    // Each direct base's parameter at the place: the one
+                    // `ForeignBehavior` owns, and `AliasChild`'s effective one
+                    // — the alias of `a` suppresses the `b` it redefines but
+                    // invents no slot, so `AliasChild`'s parameters are
+                    // `baseOutput` and `baseBoth`, shifted one place.
+                    for (source, targets) in [
+                        (
+                            "SiblingChild::siblingInput",
+                            &["ForeignBehavior::a", "BaseBehavior::baseOutput"][..],
+                        ),
+                        (
+                            "SiblingChild::siblingOutput",
+                            &["ForeignBehavior::z", "BaseBehavior::baseBoth"],
+                        ),
+                        ("SiblingChild::siblingBoth", &["ForeignBehavior::both"]),
+                    ] {
+                        let generated = edges(&mut r, source);
+                        let mut actual: Vec<String> =
+                            generated.iter().map(|(_, target)| target.clone()).collect();
+                        actual.sort();
+                        let mut wanted: Vec<String> =
+                            targets.iter().map(|t| id(&mut r, t)).collect();
+                        wanted.sort();
+                        assert_eq!(actual, wanted, "{source}");
+                        identities.push(generated.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                    }
+                    let result_alias_membership = r
+                        .owned_relationships(aliases)
+                        .into_iter()
+                        .find(|&m| r.membership_member_name(m).as_deref() == Some("resultAlias"))
+                        .unwrap();
+                    assert_eq!(
+                        inherited(&mut r, alias_result).unwrap(),
+                        vec![result_alias_membership]
+                    );
+                    assert_eq!(r.function_result_report(alias_result).result, Ok(None));
+                    let own_answer = r.resolve_qualified("ResultGrand::ownAnswer").unwrap();
+                    assert_eq!(
+                        r.function_result_report(result_grand).result,
+                        Ok(Some(own_answer))
+                    );
+                    for owner in [sibling, alias_result] {
+                        let actual = inherited(&mut r, owner).unwrap();
+                        identities.push(
+                            actual
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                    }
+                } else {
+                    for owner in [parameter_grand, alias_child, sibling, alias_result] {
+                        assert!(matches!(
+                            inherited(&mut r, owner),
+                            Err(OperationError::Incomplete { .. })
+                        ));
+                    }
+                }
+                let mixed = r.resolve_qualified("MixedChild").unwrap();
+                assert!(
+                    matches!(
+                        inherited(&mut r, mixed),
+                        Err(OperationError::Incomplete { .. })
+                    ),
+                    "mixed authored/positional source closure remains unsupported"
+                );
+                assert!(edges(&mut r, "MixedChild::localInput").is_empty());
+                for generated in [result_edges, alias_result_edges] {
+                    identities.push(generated.into_iter().flat_map(|(a, b)| [a, b]).collect());
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(
+                        &identities, expected,
+                        "{format:?} early={early_foreign} mode={mode}"
+                    );
+                } else {
+                    expected = Some(identities);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_positional_prerequisites.rs b/crates/sysmlv2-parser/tests/checked_positional_prerequisites.rs
new file mode 100644
index 0000000..b678939
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_positional_prerequisites.rs
@@ -0,0 +1,237 @@
+//! Foreign end prerequisites order the existing reduction without adding inheritance.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+fn inherited(r: &mut ResolvedModel, owner: ElementRef) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|v| match v {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership"),
+        })
+        .collect())
+}
+fn edges(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let owner = r.resolve_qualified(name).unwrap();
+    let rows = r
+        .implied_relationships(owner)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>();
+    rows.into_iter()
+        .map(|e| {
+            let id = r.element_id(e).to_string();
+            let target = r.property(e, "redefinedFeature").unwrap()["@id"]
+                .as_str()
+                .unwrap()
+                .to_owned();
+            (id, target)
+        })
+        .collect()
+}
+fn id(r: &mut ResolvedModel, name: &str) -> String {
+    let e = r.resolve_qualified(name).unwrap();
+    r.element_id(e).to_string()
+}
+#[test]
+fn canonical_foreign_end_prerequisites_preserve_actual_library_order_and_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(89).unwrap(), 89).unwrap());
+        for early_foreign in [true, false] {
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.load_library_dir(&library).unwrap();
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let foreign = "class Foreign specializes BaseOwner {end feature a; class Unrelated;} package Aliases {alias selected for Foreign::a;}";
+                let consumers = "
+                    class DirectProvider {public import Foreign::a;}
+                    class DirectChild specializes DirectProvider;
+                    class DirectGrand specializes DirectChild {end feature d;}
+                    class AliasProvider {public import Aliases::selected;}
+                    class AliasChild specializes AliasProvider,BaseOwner;
+                    class AliasGrand specializes AliasChild {end feature g;}
+                    class SiblingGrand specializes AliasChild,Foreign {end feature s;}
+                ";
+                let mixed = "
+                    class OtherForeign {end feature outside;}
+                    class MixedOwner specializes BaseOwner {
+                        end feature a;
+                        feature ordinary redefines OtherForeign::outside;
+                    }
+                    class MixedProvider {public import MixedOwner::a;}
+                    class MixedChild specializes MixedProvider {end feature m;}
+                ";
+                let source = format!(
+                    "class BaseOwner {{end feature b;}} {} {} {mixed}",
+                    if early_foreign { foreign } else { consumers },
+                    if early_foreign { consumers } else { foreign }
+                );
+                let unit = model.add_source("checked-prerequisites.kerml", &source);
+                assert!(
+                    unit.diagnostics.is_empty(),
+                    "{format:?} early={early_foreign} mode={mode}: {:?}",
+                    unit.diagnostics
+                );
+                let mut r = ResolvedModel::build(&model);
+                let direct = r.resolve_qualified("DirectGrand").unwrap();
+                // The first checked query must establish prerequisites itself;
+                // no prior implied relationship read may warm the proof.
+                let cold = inherited(&mut r, direct);
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(cold.unwrap(), vec![], "early={early_foreign} mode={mode}");
+                } else {
+                    assert!(matches!(cold, Err(OperationError::Incomplete { .. })));
+                }
+                let alias_child = r.resolve_qualified("AliasChild").unwrap();
+                let alias_grand = r.resolve_qualified("AliasGrand").unwrap();
+                let sibling = r.resolve_qualified("SiblingGrand").unwrap();
+                let alias_owner = r.resolve_qualified("Aliases").unwrap();
+                let selected = r
+                    .owned_relationships(alias_owner)
+                    .into_iter()
+                    .find(|&m| r.membership_member_name(m).as_deref() == Some("selected"))
+                    .unwrap();
+                let a_id = id(&mut r, "Foreign::a");
+                let b_id = id(&mut r, "BaseOwner::b");
+                let foreign_edges = edges(&mut r, "Foreign::a");
+                assert_eq!(
+                    foreign_edges.len(),
+                    1,
+                    "{format:?} early={early_foreign} mode={mode}"
+                );
+                assert_eq!(foreign_edges[0].1, b_id);
+                let direct_edges = edges(&mut r, "DirectGrand::d");
+                let alias_edges = edges(&mut r, "AliasGrand::g");
+                let sibling_edges = edges(&mut r, "SiblingGrand::s");
+                let mut identities = Vec::<Vec<String>>::new();
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(direct_edges.len(), 1, "early={early_foreign} mode={mode}");
+                    assert_eq!(direct_edges[0].1, a_id);
+                    assert!(
+                        alias_edges.is_empty(),
+                        "alias suppression cannot create a positional slot"
+                    );
+                    assert_eq!(sibling_edges.len(), 1, "early={early_foreign} mode={mode}");
+                    assert_eq!(
+                        sibling_edges[0].1, a_id,
+                        "sibling must inherit Foreign::a, never the suppressed BaseOwner::b"
+                    );
+                    for (owner, want) in [
+                        (direct, vec![]),
+                        (alias_child, vec![selected]),
+                        (alias_grand, vec![selected]),
+                    ] {
+                        let actual = inherited(&mut r, owner).unwrap_or_else(|e| {
+                            panic!("early={early_foreign} mode={mode} {owner:?}: {e:?}")
+                        });
+                        assert_eq!(actual, want, "early={early_foreign} mode={mode}");
+                        identities.push(
+                            actual
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                    }
+                    let alias_features = r.type_feature_report(alias_child).projections.unwrap();
+                    assert!(!alias_features.inherited_features.iter().any(|&e| {
+                        let id = r.element_id(e).to_string();
+                        id == a_id || id == b_id
+                    }));
+                    let direct_features = r.type_feature_report(direct).projections.unwrap();
+                    let own = r.resolve_qualified("DirectGrand::d").unwrap();
+                    assert!(direct_features.features.contains(&own));
+                    assert!(
+                        !direct_features.inherited_features.iter().any(|&e| r
+                            .element_id(e)
+                            .to_string()
+                            == a_id
+                            || r.element_id(e).to_string() == b_id)
+                    );
+                    // The foreign owner's unrelated class can contribute only
+                    // through the genuine sibling base, never a prerequisite.
+                    let unrelated = r.resolve_qualified("Foreign::Unrelated").unwrap();
+                    let unrelated = r.property(unrelated, "owningRelationship").unwrap();
+                    let unrelated = r.element_by_id(unrelated["@id"].as_str().unwrap()).unwrap();
+                    assert_eq!(inherited(&mut r, sibling).unwrap(), vec![unrelated]);
+                } else {
+                    for owner in [direct, alias_child, alias_grand, sibling] {
+                        assert!(
+                            matches!(
+                                inherited(&mut r, owner),
+                                Err(OperationError::Incomplete { .. })
+                            ),
+                            "early={early_foreign} mode={mode}"
+                        );
+                    }
+                    assert!(
+                        direct_edges.is_empty(),
+                        "Legacy direct foreign end publication is unchanged"
+                    );
+                }
+                let mixed = r.resolve_qualified("MixedChild").unwrap();
+                assert!(
+                    matches!(
+                        inherited(&mut r, mixed),
+                        Err(OperationError::Incomplete { .. })
+                    ),
+                    "mixed owner source closure must remain qualified"
+                );
+                assert!(edges(&mut r, "MixedChild::m").is_empty());
+                for rows in [foreign_edges, direct_edges, alias_edges, sibling_edges] {
+                    identities.push(
+                        rows.into_iter()
+                            .flat_map(|(id, target)| [id, target])
+                            .collect(),
+                    );
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(
+                        &identities, expected,
+                        "{format:?} early={early_foreign} mode={mode}"
+                    );
+                } else {
+                    expected = Some(identities);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_recursive_providers.rs b/crates/sysmlv2-parser/tests/checked_recursive_providers.rs
new file mode 100644
index 0000000..f2e615f
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_recursive_providers.rs
@@ -0,0 +1,352 @@
+//! Recursive lookup providers certify named plain-package trees and exact Membership identity.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+fn inherited(r: &mut ResolvedModel, owner: ElementRef) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|v| match v {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership"),
+        })
+        .collect())
+}
+fn membership(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let e = r.resolve_qualified(name).unwrap();
+    let value = r.property(e, "owningRelationship").unwrap();
+    r.element_by_id(value["@id"].as_str().unwrap()).unwrap()
+}
+fn named_member(r: &mut ResolvedModel, namespace: &str, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(namespace).unwrap();
+    r.owned_relationships(owner)
+        .into_iter()
+        .find(|&m| r.membership_member_name(m).as_deref() == Some(name))
+        .unwrap()
+}
+#[test]
+fn recursive_plain_package_providers_preserve_actual_library_identities_and_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(97).unwrap(), 97).unwrap());
+        for (early_tree, qualified) in [(true, false), (false, false), (true, true), (false, true)]
+        {
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.load_library_dir(&library).unwrap();
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let tree = "package Tree {
+                    alias RootAlias for $::Marker;
+                    package Left {alias DeepAlias for $::Marker; alias Clash for $::Marker;}
+                    package Right {alias Clash for $::OtherMarker;}
+                    private package Hidden {alias SecretAlias for $::Marker;}
+                    private alias PrivateAlias for $::Marker;
+                }";
+                let consumers = "
+                    class MemberProvider {public import $::Tree::**;}
+                    class MemberChild specializes MemberProvider {feature ownMember;}
+                    class NamespaceProvider {public import $::Tree::*::**;}
+                    class NamespaceChild specializes NamespaceProvider {feature ownNamespace;}
+                    class AllProvider {public import all $::Tree::*::**;}
+                    class AllChild specializes AllProvider {feature ownAll;}
+                    package NamespaceConsumer {private import $::Tree::*::**;}
+                ";
+                let negatives = "
+                    package InternalTree {package Nested {private import Marker;}}
+                    class InternalProvider {public import $::InternalTree::*::**;}
+                    class InternalChild specializes InternalProvider;
+                    package CycleTree {public import CycleOther::*;}
+                    package CycleOther {public import $::CycleTree::*;}
+                    class CycleProvider {public import $::CycleTree::*::**;}
+                    class CycleChild specializes CycleProvider;
+                    package TypedTree {class OwnedType;}
+                    class TypedProvider {public import $::TypedTree::*::**;}
+                    class TypedChild specializes TypedProvider;
+                    package UnnamedTree {package {alias AnonymousAlias for $::Marker;}}
+                    class UnnamedProvider {public import $::UnnamedTree::*::**;}
+                    class UnnamedChild specializes UnnamedProvider;
+                ";
+                let mixed_tree = "
+                    package External {alias Imported for $::Definitions::Marker;}
+                    package HiddenExternal {private alias Secret for $::Definitions::OtherMarker;}
+                    package ImportTree {
+                        alias Local for $::Definitions::Marker;
+                        public import $::Relay0::*;
+                        package Nested {public import all $::HiddenExternal::*;}
+                    }
+                ";
+                let mut mixed_tree = mixed_tree.to_owned();
+                // Exercise more semantic import edges than the old helper-call bound admitted.
+                for hop in 0..8 {
+                    let target = if hop == 7 {
+                        "External".to_owned()
+                    } else {
+                        format!("Relay{}", hop + 1)
+                    };
+                    mixed_tree.push_str(&format!(
+                        "package Relay{hop} {{public import $::{target}::*;}}"
+                    ));
+                }
+                let mixed_consumers = "
+                    class MixedProvider {
+                        public import $::ImportTree::*::**;
+                        public import $::External::*;
+                        public import $::Definitions::Marker;
+                    }
+                    class MixedChild specializes MixedProvider {feature ownMixed;}
+                    package MixedConsumer {private import $::ImportTree::*::**;}
+                ";
+                let tree_path = if qualified { "Catalog::Tree" } else { "Tree" };
+                let marker_path = if qualified {
+                    "Definitions::Marker"
+                } else {
+                    "Marker"
+                };
+                let other_path = if qualified {
+                    "Definitions::OtherMarker"
+                } else {
+                    "OtherMarker"
+                };
+                let tree = if !qualified {
+                    tree.to_owned()
+                } else {
+                    format!("package Catalog {{ {tree} }}")
+                        .replace("$::Marker", "$::Definitions::Marker")
+                        .replace("$::OtherMarker", "$::Definitions::OtherMarker")
+                };
+                let tree = format!("{tree} {mixed_tree}");
+                let consumers = format!("{consumers} {mixed_consumers}")
+                    .replace("$::Tree", &format!("$::{tree_path}"));
+                let source = format!(
+                    "class Marker; class OtherMarker; package Definitions {{class Marker; class OtherMarker;}} {} {} {negatives}",
+                    if early_tree { &tree } else { &consumers },
+                    if early_tree { &consumers } else { &tree }
+                );
+                let unit = model.add_source("checked-recursive-providers.kerml", &source);
+                assert!(
+                    unit.diagnostics.is_empty(),
+                    "{format:?} early={early_tree} mode={mode}: {:?}",
+                    unit.diagnostics
+                );
+                let mut r = ResolvedModel::build(&model);
+                let mixed_child = r.resolve_qualified("MixedChild").unwrap();
+                let cold_mixed = inherited(&mut r, mixed_child);
+                if format == GraphFormat::CanonicalV3 {
+                    assert!(
+                        cold_mixed.is_ok(),
+                        "cold mixed early={early_tree} mode={mode}: {cold_mixed:?}"
+                    );
+                } else {
+                    assert!(matches!(cold_mixed, Err(OperationError::Incomplete { .. })));
+                }
+                let namespace_child = r.resolve_qualified("NamespaceChild").unwrap();
+                // Cold provider proof, before relationship/feature publication.
+                let cold = inherited(&mut r, namespace_child);
+                if format == GraphFormat::CanonicalV3 {
+                    assert!(cold.is_ok(), "early={early_tree} mode={mode}: {cold:?}");
+                } else {
+                    assert!(matches!(cold, Err(OperationError::Incomplete { .. })));
+                }
+                let root_alias = named_member(&mut r, tree_path, "RootAlias");
+                let left = membership(&mut r, &format!("{tree_path}::Left"));
+                let right = membership(&mut r, &format!("{tree_path}::Right"));
+                let hidden = membership(&mut r, &format!("{tree_path}::Hidden"));
+                let private_alias = named_member(&mut r, tree_path, "PrivateAlias");
+                let deep = named_member(&mut r, &format!("{tree_path}::Left"), "DeepAlias");
+                let clash_left = named_member(&mut r, &format!("{tree_path}::Left"), "Clash");
+                let clash_right = named_member(&mut r, &format!("{tree_path}::Right"), "Clash");
+                let secret = named_member(&mut r, &format!("{tree_path}::Hidden"), "SecretAlias");
+                let public = vec![root_alias, left, right, deep, clash_left, clash_right];
+                let all = vec![
+                    root_alias,
+                    left,
+                    right,
+                    hidden,
+                    private_alias,
+                    deep,
+                    clash_left,
+                    clash_right,
+                    secret,
+                ];
+                let mut with_root = vec![membership(&mut r, tree_path)];
+                with_root.extend(public.iter().copied());
+                let mut identities = Vec::<Vec<String>>::new();
+                for (owner, wanted, own_name) in [
+                    ("MemberChild", with_root, "ownMember"),
+                    ("NamespaceChild", public, "ownNamespace"),
+                    ("AllChild", all, "ownAll"),
+                ] {
+                    let receiver = r.resolve_qualified(owner).unwrap();
+                    let actual = inherited(&mut r, receiver);
+                    if format == GraphFormat::CanonicalV3 {
+                        let actual = actual.unwrap_or_else(|e| {
+                            panic!("{owner} early={early_tree} mode={mode}: {e:?}")
+                        });
+                        assert_eq!(actual, wanted, "exact recursive Membership order: {owner}");
+                        identities.push(
+                            actual
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                        let report = r.type_feature_report(receiver).projections.unwrap();
+                        let own = r
+                            .resolve_qualified(&format!("{owner}::{own_name}"))
+                            .unwrap();
+                        assert_eq!(
+                            report.owned_feature_memberships,
+                            vec![membership(&mut r, &format!("{owner}::{own_name}"))]
+                        );
+                        assert!(report.features.contains(&own));
+                        // Imported aliases to Classes and Package memberships
+                        // are bindings, not FeatureMembership slots.
+                        let marker = r.resolve_qualified(marker_path).unwrap();
+                        let other = r.resolve_qualified(other_path).unwrap();
+                        assert!(!report.features.contains(&marker));
+                        assert!(!report.features.contains(&other));
+                    } else {
+                        assert!(matches!(actual, Err(OperationError::Incomplete { .. })));
+                    }
+                }
+                // Actual resolver lookup must consume the recursive tree's
+                // descendants and preserve sibling ambiguity rather than first-hit wins.
+                let marker = r.resolve_qualified(marker_path).unwrap();
+                assert_eq!(
+                    r.resolve_qualified("NamespaceChild::DeepAlias"),
+                    Some(marker)
+                );
+                assert_eq!(r.resolve_qualified("NamespaceChild::Clash"), None);
+                assert_eq!(r.resolve_qualified("NamespaceChild::SecretAlias"), None);
+                assert_eq!(r.resolve_qualified("AllChild::SecretAlias"), Some(marker));
+                assert_eq!(r.resolve_qualified("AllChild::PrivateAlias"), Some(marker));
+                // Namespace importedMembership prunes the two colliding names;
+                // Type visibility-specific inherited memberships retain both.
+                let consumer = r.resolve_qualified("NamespaceConsumer").unwrap();
+                let report = r
+                    .invoke_operation(
+                        consumer,
+                        "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                        &[DerivedValue::Elements(vec![])],
+                    )
+                    .unwrap();
+                assert_eq!(
+                    report.value,
+                    DerivedValue::References(
+                        vec![root_alias, left, right, deep]
+                            .into_iter()
+                            .map(Reference::Element)
+                            .collect()
+                    )
+                );
+                identities.push(
+                    vec![root_alias, left, right, deep]
+                        .into_iter()
+                        .map(|e| r.element_id(e).to_string())
+                        .collect(),
+                );
+                let local = named_member(&mut r, "ImportTree", "Local");
+                let nested = membership(&mut r, "ImportTree::Nested");
+                let imported = named_member(&mut r, "External", "Imported");
+                let secret = named_member(&mut r, "HiddenExternal", "Secret");
+                let marker_membership = membership(&mut r, "Definitions::Marker");
+                if format == GraphFormat::CanonicalV3 {
+                    let wanted = vec![local, nested, imported, secret, marker_membership];
+                    assert_eq!(inherited(&mut r, mixed_child).unwrap(), wanted);
+                    identities.push(
+                        wanted
+                            .into_iter()
+                            .map(|e| r.element_id(e).to_string())
+                            .collect(),
+                    );
+                    let own = r.resolve_qualified("MixedChild::ownMixed").unwrap();
+                    let report = r.type_feature_report(mixed_child).projections.unwrap();
+                    assert_eq!(
+                        report.owned_feature_memberships,
+                        vec![membership(&mut r, "MixedChild::ownMixed")]
+                    );
+                    assert_eq!(
+                        report
+                            .features
+                            .into_iter()
+                            .filter(|&e| !r.is_library_element(e))
+                            .collect::<Vec<_>>(),
+                        vec![own]
+                    );
+                }
+                let marker = r.resolve_qualified("Definitions::Marker").unwrap();
+                let other = r.resolve_qualified("Definitions::OtherMarker").unwrap();
+                assert_eq!(r.resolve_qualified("MixedChild::Imported"), Some(marker));
+                assert_eq!(r.resolve_qualified("MixedChild::Secret"), Some(other));
+                let consumer = r.resolve_qualified("MixedConsumer").unwrap();
+                let report = r
+                    .invoke_operation(
+                        consumer,
+                        "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                        &[DerivedValue::Elements(vec![])],
+                    )
+                    .unwrap();
+                assert_eq!(
+                    report.value,
+                    DerivedValue::References(
+                        vec![local, nested, imported, secret]
+                            .into_iter()
+                            .map(Reference::Element)
+                            .collect()
+                    )
+                );
+                for owner in ["InternalChild", "CycleChild", "TypedChild", "UnnamedChild"] {
+                    let e = r.resolve_qualified(owner).unwrap();
+                    assert!(
+                        matches!(inherited(&mut r, e), Err(OperationError::Incomplete { .. })),
+                        "unsupported recursive provider {owner}"
+                    );
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(
+                        &identities, expected,
+                        "{format:?} early={early_tree} mode={mode}"
+                    );
+                } else {
+                    expected = Some(identities);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_structural_members.rs b/crates/sysmlv2-parser/tests/checked_structural_members.rs
new file mode 100644
index 0000000..1a6e594
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_structural_members.rs
@@ -0,0 +1,57 @@
+//! Ordinary structural members do not require execution of their own bodies.
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel},
+    model::{GraphFormat, Model},
+};
+
+#[test]
+fn checked_part_features_include_ordinary_usage_members_and_library_members() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        let unit = model.add_source(
+            "members.sysml",
+            "package P {
+            part def Base {
+                part sensor;
+                port bus;
+                action act;
+                state status;
+                constraint guard;
+                connect sensor to sensor;
+            }
+            part def Child :> Base { part extra; }
+            part def Broken :> Missing { port bus; }
+        }",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let child = r.resolve_qualified("P::Child").unwrap();
+        for property in ["feature", "inheritedFeature"] {
+            let values = r.property(child, property).unwrap();
+            for member in [
+                "P::Base::sensor",
+                "P::Base::bus",
+                "P::Base::act",
+                "P::Base::status",
+                "P::Base::guard",
+                "Parts::Part::ownedPorts",
+                "Items::Item::checkedConstraints",
+            ] {
+                let element = r.resolve_qualified(member).unwrap();
+                let id = r.element_id(element).to_string();
+                assert!(
+                    values.as_array().unwrap().iter().any(|v| v["@id"] == id),
+                    "{format:?} {property} lacks {member}"
+                );
+            }
+        }
+        let broken = r.resolve_qualified("P::Broken").unwrap();
+        assert!(r.property(broken, "feature").is_err());
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_type_imports.rs b/crates/sysmlv2-parser/tests/checked_type_imports.rs
new file mode 100644
index 0000000..a36fb5f
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_type_imports.rs
@@ -0,0 +1,307 @@
+//! Imported Type memberships and recursive Feature namespaces preserve replay evidence.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+fn invoke(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    operation: &str,
+    arguments: &[DerivedValue],
+) -> Vec<ElementRef> {
+    let report = r.invoke_operation(receiver, operation, arguments).unwrap();
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected Membership references");
+    };
+    values
+        .into_iter()
+        .map(|value| match value {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded Membership identity"),
+        })
+        .collect()
+}
+fn membership(r: &mut ResolvedModel, owner: &str, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(owner).unwrap();
+    let values = r.property(owner, "ownedMembership").unwrap();
+    values
+        .as_array()
+        .unwrap()
+        .iter()
+        .find_map(|value| {
+            let member = r.element_by_id(value["@id"].as_str().unwrap()).unwrap();
+            (r.membership_member_name(member).as_deref() == Some(name)).then_some(member)
+        })
+        .unwrap_or_else(|| panic!("missing owned Membership {name}"))
+}
+fn inherited(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    namespaces: Vec<ElementRef>,
+    types: Vec<ElementRef>,
+) -> Vec<ElementRef> {
+    invoke(
+        r,
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(namespaces),
+            DerivedValue::Elements(types),
+            DerivedValue::Bool(true),
+        ],
+    )
+}
+fn visible(
+    r: &mut ResolvedModel,
+    owner: ElementRef,
+    recursive: bool,
+    all: bool,
+) -> Vec<ElementRef> {
+    invoke(
+        r,
+        owner,
+        "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(recursive),
+            DerivedValue::Bool(all),
+        ],
+    )
+}
+
+#[test]
+fn type_imports_and_recursive_feature_visibility_preserve_actual_library_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(79).unwrap(), 79).unwrap());
+        let mut expected_ids = None;
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(format);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.load_library_dir(&library).unwrap();
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let source = "package Sources {
+                class LocalType;
+                alias NamedType for LocalType;
+                feature packageSlot;
+                class Slots { feature original; feature kept; }
+                alias importedOriginal for Slots::original;
+                alias importedKept for Slots::kept;
+            }
+            class Provider {
+                public import Sources::NamedType;
+                public import Sources::packageSlot;
+                public import Sources::importedOriginal;
+                protected import Sources::importedKept;
+                protected feature ownProtected;
+            }
+            class Child specializes Provider { feature replacement redefines Sources::Slots::original; }
+            package Leaf { class LeafType; }
+            class LeafProvider { public import Leaf::*; }
+            class LeafChild specializes LeafProvider;
+            class UnsupportedProvider { public import Sources::Slots::original; }
+            classifier BaseType { class Inherited; }
+            class Outer {
+                feature plain;
+                feature typedSlot : BaseType { class Local; }
+                private feature hidden { class Secret; }
+            }
+            package Consumer { public import Outer::**; }";
+            let unit = model.add_source("checked-type-imports.kerml", source);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let child = r.resolve_qualified("Child").unwrap();
+            let provider = r.resolve_qualified("Provider").unwrap();
+            let sources = r.resolve_qualified("Sources").unwrap();
+            let named = membership(&mut r, "Sources", "NamedType");
+            let package_slot = membership(&mut r, "Sources", "packageSlot");
+            let original_alias = membership(&mut r, "Sources", "importedOriginal");
+            let kept_alias = membership(&mut r, "Sources", "importedKept");
+            let protected = membership(&mut r, "Provider", "ownProtected");
+            let replacement = membership(&mut r, "Child", "replacement");
+            assert!(r.membership_is_alias(named));
+            assert!(r.membership_is_alias(original_alias));
+            assert!(r.membership_is_alias(kept_alias));
+            let inherited_members = inherited(&mut r, child, vec![], vec![]);
+            assert_eq!(
+                inherited_members,
+                vec![named, package_slot, protected, kept_alias],
+                "{format:?} replay {mode}"
+            );
+            let inheritable = invoke(
+                &mut r,
+                child,
+                "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean",
+                &[
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Bool(true),
+                ],
+            );
+            assert_eq!(
+                inheritable,
+                vec![named, package_slot, original_alias, protected, kept_alias]
+            );
+            let nonprivate = invoke(
+                &mut r,
+                child,
+                "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean",
+                &[
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Bool(true),
+                ],
+            );
+            assert_eq!(
+                nonprivate,
+                vec![replacement, named, package_slot, protected, kept_alias]
+            );
+            assert_eq!(
+                inherited(&mut r, child, vec![sources], vec![]),
+                inherited_members,
+                "direct MembershipImport retains its selected membership when its declaring namespace is excluded"
+            );
+            assert!(inherited(&mut r, child, vec![], vec![provider]).is_empty());
+            let public = visible(&mut r, child, false, false);
+            let relevant = [
+                replacement,
+                named,
+                package_slot,
+                original_alias,
+                protected,
+                kept_alias,
+            ];
+            assert_eq!(
+                public
+                    .iter()
+                    .copied()
+                    .filter(|e| relevant.contains(e))
+                    .collect::<Vec<_>>(),
+                vec![replacement, named, package_slot, kept_alias]
+            );
+            // Inherited visibility tests the original Membership's visibility;
+            // the public kept alias remains public after a protected import.
+            assert!(!public.contains(&protected));
+            let features = r.type_feature_report(child).projections.unwrap();
+            let kept = r.resolve_qualified("Sources::Slots::kept").unwrap();
+            let package_feature = r.resolve_qualified("Sources::packageSlot").unwrap();
+            assert!(!features.inherited_features.contains(&kept));
+            assert!(!features.inherited_features.contains(&package_feature));
+            assert!(
+                features
+                    .inherited_features
+                    .contains(&r.resolve_qualified("Provider::ownProtected").unwrap())
+            );
+            let leaf = r.resolve_qualified("Leaf").unwrap();
+            let leaf_child = r.resolve_qualified("LeafChild").unwrap();
+            let leaf_type = membership(&mut r, "Leaf", "LeafType");
+            let leaf_members = inherited(&mut r, leaf_child, vec![], vec![]);
+            assert_eq!(leaf_members, vec![leaf_type]);
+            assert!(inherited(&mut r, leaf_child, vec![leaf], vec![]).is_empty());
+            let unsupported = r.resolve_qualified("UnsupportedProvider").unwrap();
+            let direct_import = r.invoke_operation(
+                unsupported,
+                "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean",
+                &[
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Elements(vec![]),
+                    DerivedValue::Bool(true),
+                ],
+            );
+            if format == GraphFormat::CanonicalV3 {
+                let original = membership(&mut r, "Sources::Slots", "original");
+                assert_eq!(
+                    direct_import.unwrap().value,
+                    DerivedValue::References(vec![Reference::Element(original)]),
+                    "{format:?} replay {mode}"
+                );
+            } else {
+                assert!(matches!(
+                    direct_import,
+                    Err(OperationError::Incomplete { .. })
+                ));
+            }
+            let outer = r.resolve_qualified("Outer").unwrap();
+            let plain = membership(&mut r, "Outer", "plain");
+            let typed = membership(&mut r, "Outer", "typedSlot");
+            let hidden = membership(&mut r, "Outer", "hidden");
+            let local = membership(&mut r, "Outer::typedSlot", "Local");
+            let inherited_type = membership(&mut r, "BaseType", "Inherited");
+            let secret = membership(&mut r, "Outer::hidden", "Secret");
+            let recursive = visible(&mut r, outer, true, false);
+            assert_eq!(recursive, vec![plain, typed, local, inherited_type]);
+            let recursive_all = visible(&mut r, outer, true, true);
+            assert_eq!(
+                recursive_all,
+                vec![plain, typed, hidden, local, inherited_type, secret]
+            );
+            let consumer = r.resolve_qualified("Consumer").unwrap();
+            let imported = invoke(
+                &mut r,
+                consumer,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![])],
+            );
+            // Outer::** is a recursive MembershipImport: the selected Outer
+            // Membership precedes traversal and survives namespace exclusion.
+            let outer_membership = r.property(outer, "owningRelationship").unwrap();
+            let outer_membership = r
+                .element_by_id(outer_membership["@id"].as_str().unwrap())
+                .unwrap();
+            assert_eq!(
+                imported,
+                vec![outer_membership, plain, typed, local, inherited_type]
+            );
+            let excluded = invoke(
+                &mut r,
+                consumer,
+                "Root-Namespaces-Namespace-importedMemberships_Namespace",
+                &[DerivedValue::Elements(vec![outer])],
+            );
+            assert_eq!(excluded, vec![outer_membership]);
+            let ids: Vec<Vec<_>> = [
+                inherited_members,
+                inheritable,
+                nonprivate,
+                public,
+                leaf_members,
+                recursive,
+                recursive_all,
+                imported,
+                excluded,
+            ]
+            .into_iter()
+            .map(|members| members.into_iter().map(|e| r.element_id(e)).collect())
+            .collect();
+            if let Some(expected) = &expected_ids {
+                assert_eq!(&ids, expected, "{format:?} replay {mode}");
+            } else {
+                expected_ids = Some(ids);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_type_memberships.rs b/crates/sysmlv2-parser/tests/checked_type_memberships.rs
new file mode 100644
index 0000000..3f651c6
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_type_memberships.rs
@@ -0,0 +1,168 @@
+//! Checked Type operation identities remain stable across library replay.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+fn invoke(
+    r: &mut ResolvedModel,
+    receiver: ElementRef,
+    operation: &str,
+    arguments: &[DerivedValue],
+) -> Vec<ElementRef> {
+    let result = r.invoke_operation(receiver, operation, arguments).unwrap();
+    let DerivedValue::References(values) = result.value else {
+        panic!("expected Membership references");
+    };
+    values
+        .into_iter()
+        .map(|value| match value {
+            Reference::Element(e) => e,
+            _ => panic!("expected local Membership identity"),
+        })
+        .collect()
+}
+
+#[test]
+fn type_membership_operations_preserve_actual_library_replay_and_exclusions() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(95).unwrap(), 95).unwrap());
+        let mut expected = None;
+        for mode in 0..4 {
+            let mut model = Model::with_graph_format(format);
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.load_library_dir(&library).unwrap();
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let source = "class A { feature original; feature retained; protected feature guarded; private feature hidden; alias Scalar for ScalarValues::Integer; } class B specializes A { feature replacement redefines original; feature own; }";
+            let unit = model.add_source("type-memberships.kerml", source);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let mut r = ResolvedModel::build(&model);
+            let a = r.resolve_qualified("A").unwrap();
+            let b = r.resolve_qualified("B").unwrap();
+            let original = r.resolve_qualified("A::original").unwrap();
+            let retained = r.resolve_qualified("A::retained").unwrap();
+            let guarded = r.resolve_qualified("A::guarded").unwrap();
+            let hidden = r.resolve_qualified("A::hidden").unwrap();
+            let membership = |r: &mut ResolvedModel, e| {
+                let value = r.property(e, "owningRelationship").unwrap();
+                r.element_by_id(value["@id"].as_str().unwrap()).unwrap()
+            };
+            let original = membership(&mut r, original);
+            let retained = membership(&mut r, retained);
+            let guarded = membership(&mut r, guarded);
+            let hidden = membership(&mut r, hidden);
+            let owned = r.property(a, "ownedMembership").unwrap();
+            let scalar = owned
+                .as_array()
+                .unwrap()
+                .iter()
+                .find_map(|value| {
+                    let member = r.element_by_id(value["@id"].as_str().unwrap()).unwrap();
+                    (r.membership_member_name(member).as_deref() == Some("Scalar"))
+                        .then_some(member)
+                })
+                .unwrap();
+            assert!(r.membership_is_alias(scalar));
+            let visible_args = [
+                DerivedValue::Elements(vec![]),
+                DerivedValue::Bool(false),
+                DerivedValue::Bool(false),
+            ];
+            let visible = invoke(
+                &mut r,
+                b,
+                "Root-Namespaces-Namespace-visibleMemberships_Namespace_Boolean_Boolean",
+                &visible_args,
+            );
+            assert!(visible.contains(&retained));
+            assert!(visible.contains(&scalar));
+            assert!(!visible.contains(&guarded));
+            assert!(!visible.contains(&hidden));
+            let args = [
+                DerivedValue::Elements(vec![]),
+                DerivedValue::Elements(vec![]),
+                DerivedValue::Bool(false),
+            ];
+            let inherited = invoke(
+                &mut r,
+                b,
+                "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+                &args,
+            );
+            assert!(inherited.contains(&retained));
+            assert!(inherited.contains(&scalar));
+            assert!(inherited.contains(&guarded));
+            assert!(!inherited.contains(&original));
+            assert!(!inherited.contains(&hidden));
+            let inheritable = invoke(
+                &mut r,
+                b,
+                "Core-Types-Type-inheritableMemberships_Namespace_Type_Boolean",
+                &args,
+            );
+            assert!(inheritable.contains(&original));
+            let non_private = invoke(
+                &mut r,
+                b,
+                "Core-Types-Type-nonPrivateMemberships_Namespace_Type_Boolean",
+                &args,
+            );
+            assert!(inherited.iter().all(|e| non_private.contains(e)));
+            let mut excluding = args.clone();
+            excluding[0] = DerivedValue::Elements(vec![a]);
+            assert_eq!(
+                invoke(
+                    &mut r,
+                    b,
+                    "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+                    &excluding,
+                ),
+                inherited,
+                "Namespace exclusions affect imports, not ancestry"
+            );
+            excluding[1] = DerivedValue::Elements(vec![a]);
+            let excluded = invoke(
+                &mut r,
+                b,
+                "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+                &excluding,
+            );
+            assert!(!excluded.contains(&retained));
+            assert!(!excluded.contains(&guarded));
+            let ids: Vec<Vec<_>> = [inherited, inheritable, non_private, visible, excluded]
+                .into_iter()
+                .map(|values| values.into_iter().map(|e| r.element_id(e)).collect())
+                .collect();
+            if let Some(expected) = &expected {
+                assert_eq!(&ids, expected, "{format:?} replay {mode}");
+            } else {
+                expected = Some(ids);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_usage_typing.rs b/crates/sysmlv2-parser/tests/checked_usage_typing.rs
new file mode 100644
index 0000000..dee804e
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_usage_typing.rs
@@ -0,0 +1,406 @@
+//! Checked Usage definitions reuse the complete Feature typing closure.
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel},
+    model::{GraphFormat, Model},
+};
+
+#[test]
+fn structural_usage_types_and_definition_subsets_use_the_real_library() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = Model::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        // Attribute library aliases do not yet provide retained implied paths;
+        // explicit canonical heritage keeps this test about the checked reader.
+        let unit = model.add_source(
+            "typing.sysml",
+            "package P {
+            part def Module;
+            part def Vehicle { ref part camera : Module; part compositeCamera : Module; }
+            part vehicle : Vehicle { part camera : Module { part sensor : Module; } }
+            occurrence def Event;
+            part def Carrier { item component : ItemType; occurrence happening : Event; }
+            ref part standalone : Module;
+            item def ItemType;
+            ref item component : ItemType;
+            ref part mixed : ItemType;
+            ref occurrence occurrenceValue : Event;
+            attribute def Data :> Base::DataValue;
+            ref attribute data : Data :> Base::dataValues;
+        }",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        for (path, target, properties) in [
+            (
+                "P::Vehicle::camera",
+                "P::Module",
+                &[
+                    "type",
+                    "definition",
+                    "occurrenceDefinition",
+                    "itemDefinition",
+                    "partDefinition",
+                ][..],
+            ),
+            (
+                "P::standalone",
+                "P::Module",
+                &["type", "partDefinition"][..],
+            ),
+            (
+                "P::component",
+                "P::ItemType",
+                &["type", "definition", "itemDefinition"][..],
+            ),
+            (
+                "P::occurrenceValue",
+                "P::Event",
+                &["type", "definition", "occurrenceDefinition"][..],
+            ),
+            (
+                "P::data",
+                "P::Data",
+                &["type", "definition", "attributeDefinition"][..],
+            ),
+        ] {
+            let e = r.resolve_qualified(path).unwrap();
+            let target = r.resolve_qualified(target).unwrap();
+            let expected = serde_json::json!([{"@id": r.element_id(target).to_string()}]);
+            for property in properties {
+                assert_eq!(
+                    r.property(e, property),
+                    Ok(expected.clone()),
+                    "{format:?} {path}.{property}"
+                );
+            }
+        }
+        let mixed = r.resolve_qualified("P::mixed").unwrap();
+        let part = r.resolve_qualified("Parts::Part").unwrap();
+        assert_eq!(
+            r.property(mixed, "partDefinition"),
+            Ok(serde_json::json!([{"@id": r.element_id(part).to_string()}]))
+        );
+        assert_eq!(
+            r.property(mixed, "itemDefinition")
+                .unwrap()
+                .as_array()
+                .unwrap()
+                .len(),
+            2
+        );
+        for (path, target) in [
+            ("P::Vehicle::compositeCamera", "P::Module"),
+            ("P::vehicle::camera", "P::Module"),
+            ("P::vehicle::camera::sensor", "P::Module"),
+            ("P::Carrier::component", "P::ItemType"),
+            ("P::Carrier::happening", "P::Event"),
+        ] {
+            let composite = r.resolve_qualified(path).unwrap();
+            let target = r.resolve_qualified(target).unwrap();
+            assert_eq!(
+                r.feature_type_report(composite).types,
+                Ok(vec![target]),
+                "{format:?} {path}"
+            );
+            assert_eq!(
+                r.property(composite, "definition"),
+                Ok(serde_json::json!([{"@id": r.element_id(target).to_string()}]))
+            );
+        }
+    }
+}
+
+fn small_library(parts: &str) -> Model {
+    let mut model = Model::new();
+    for (name, text) in [
+        (
+            "kernel.kerml",
+            "standard library package Base { classifier Anything; feature things : Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything; feature occurrences : Occurrence subsets Base::things; } standard library package Objects { struct Object specializes Occurrences::Occurrence; feature objects : Object subsets Occurrences::occurrences; }",
+        ),
+        (
+            "items.sysml",
+            "standard library package Items { item def Item :> Objects::Object; ref item items : Item :> Objects::objects; }",
+        ),
+        ("parts.sysml", parts),
+    ] {
+        let unit = model.add_library_source(name, text);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    }
+    model
+}
+
+#[test]
+fn checked_usage_typing_replays_and_preserves_policy_and_incomplete_refusals() {
+    use std::sync::Arc;
+    use sysmlv2_parser::prepared::PreparedLibrary;
+    const PARTS: &str = "standard library package Parts { part def Part :> Items::Item; ref part parts : Part :> Items::items; }";
+    let mut library = small_library(PARTS);
+    let prepared = library.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(137).unwrap(), 137).unwrap());
+    let mut expected_ids = None;
+    for mode in 0..3 {
+        let mut model = match mode {
+            0 => small_library(PARTS),
+            _ => {
+                let mut model = Model::new();
+                Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                    .install(&mut model)
+                    .unwrap();
+                model
+            }
+        };
+        assert!(model.add_source("user.sysml", "part def Module; part def Container { ref part camera : Module; part compositeCamera : Module; } part outer { ref part nested : Module; } ref part broken : Missing; ").diagnostics.is_empty());
+        let mut r = ResolvedModel::build(&model);
+        let camera = r.resolve_qualified("Container::camera").unwrap();
+        let module = r.resolve_qualified("Module").unwrap();
+        let ids = (r.element_id(camera), r.element_id(module));
+        assert_eq!(*expected_ids.get_or_insert(ids), ids);
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            for property in ["type", "definition", "itemDefinition", "partDefinition"] {
+                let value = r.property(camera, property);
+                if policy
+                    == (ClosurePolicy::Closure {
+                        include_implied: true,
+                    })
+                {
+                    assert_eq!(
+                        value,
+                        Ok(serde_json::json!([{"@id": ids.1.to_string()}])),
+                        "mode {mode} {property}"
+                    );
+                } else {
+                    assert_eq!(value, Err(sysmlv2_parser::json::PropertyError::Approximate));
+                }
+            }
+        }
+        for path in ["Container::compositeCamera", "outer::nested", "broken"] {
+            let e = r.resolve_qualified(path).unwrap();
+            assert!(r.property(e, "type").is_err(), "{path}");
+            assert!(r.property(e, "partDefinition").is_err(), "{path}");
+        }
+    }
+    // A direct authored typing cannot replace the canonical family witness.
+    let mut model =
+        small_library("standard library package Parts { part def Part :> Items::Item; }");
+    model.add_source(
+        "missing-role.sysml",
+        "part def Module; ref part camera : Module;",
+    );
+    let mut r = ResolvedModel::build(&model);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let camera = r.resolve_qualified("camera").unwrap();
+    assert!(r.property(camera, "type").is_err());
+    assert!(r.property(camera, "partDefinition").is_err());
+}
+
+const COMPOSITE_KERNEL: &str = "standard library package Base { classifier Anything; feature things : Anything; } standard library package Occurrences { class Occurrence specializes Base::Anything { composite feature suboccurrences : Occurrence subsets occurrences; } feature occurrences : Occurrence subsets Base::things; } standard library package Objects { struct Object specializes Occurrences::Occurrence { composite feature subobjects : Object subsets objects, Occurrences::Occurrence::suboccurrences intersects objects, Occurrences::Occurrence::suboccurrences; } feature objects : Object subsets Occurrences::occurrences; }";
+const COMPOSITE_ITEMS: &str = "standard library package Items { item def Item :> Objects::Object { item subitems : Item :> items, Objects::Object::subobjects; part subparts : Parts::Part :> subitems, Parts::parts; } ref item items : Item :> Objects::objects; } standard library package Parts { part def Part :> Items::Item; ref part parts : Part :> Items::items; }";
+fn composite_library(format: GraphFormat, kernel: &str, items: &str) -> Model {
+    let mut model = Model::with_graph_format(format);
+    for (name, text) in [("kernel.kerml", kernel), ("items.sysml", items)] {
+        let parsed = model.add_library_source(name, text);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    }
+    model
+}
+#[test]
+fn composite_usage_typing_replays_and_is_independent_of_query_order() {
+    use std::sync::Arc;
+    use sysmlv2_parser::prepared::PreparedLibrary;
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut library = composite_library(format, COMPOSITE_KERNEL, COMPOSITE_ITEMS);
+        let prepared = library.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(138).unwrap(), 138).unwrap());
+        let mut expected = None;
+        for mode in 0..3 {
+            for warm in [false, true] {
+                let mut model = if mode == 0 {
+                    composite_library(format, COMPOSITE_KERNEL, COMPOSITE_ITEMS)
+                } else {
+                    let mut model = Model::with_graph_format(format);
+                    Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                        .install(&mut model)
+                        .unwrap();
+                    model
+                };
+                let parsed = model.add_source("composite.sysml", "part def Module; part def Container { part camera : Module; } part outer { part nested : Module; } part def Bad { part broken : Missing; }");
+                assert!(parsed.diagnostics.is_empty());
+                let mut r = ResolvedModel::build(&model);
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let container = r.resolve_qualified("Container").unwrap();
+                let camera = r.resolve_qualified("Container::camera").unwrap();
+                let module = r.resolve_qualified("Module").unwrap();
+                if warm {
+                    let _ = r.property(container, "inheritedFeature");
+                    let _ = r.property(camera, "ownedRelationship");
+                }
+                let nested = r.resolve_qualified("outer::nested").unwrap();
+                assert_eq!(r.feature_type_report(nested).types, Ok(vec![module]));
+                for property in [
+                    "type",
+                    "definition",
+                    "occurrenceDefinition",
+                    "itemDefinition",
+                    "partDefinition",
+                ] {
+                    let value = r.property(camera, property).unwrap();
+                    assert_eq!(
+                        value,
+                        serde_json::json!([{"@id": r.element_id(module).to_string()}])
+                    );
+                    assert_eq!(
+                        expected.get_or_insert_with(|| value.clone()),
+                        &value,
+                        "{format:?} {mode} {warm}"
+                    );
+                }
+                let broken = r.resolve_qualified("Bad::broken").unwrap();
+                assert!(r.property(broken, "type").is_err());
+                for policy in [
+                    ClosurePolicy::Passthrough,
+                    ClosurePolicy::Closure {
+                        include_implied: false,
+                    },
+                ] {
+                    r.set_closure_policy(policy);
+                    assert!(r.property(camera, "type").is_err());
+                }
+            }
+        }
+    }
+}
+#[test]
+fn composite_typing_requires_canonical_composition_paths_and_redundant_intersections() {
+    for (kernel, items) in [
+        (
+            COMPOSITE_KERNEL.to_owned(),
+            COMPOSITE_ITEMS.replace("part subparts", "part missingSubparts"),
+        ),
+        (
+            COMPOSITE_KERNEL.to_owned(),
+            COMPOSITE_ITEMS.replace("part subparts", "item subparts"),
+        ),
+        (
+            COMPOSITE_KERNEL.replace(
+                "subsets objects, Occurrences::Occurrence::suboccurrences intersects",
+                "subsets objects intersects",
+            ),
+            COMPOSITE_ITEMS.to_owned(),
+        ),
+        (
+            COMPOSITE_KERNEL.replace(
+                "intersects objects, Occurrences::Occurrence::suboccurrences",
+                "intersects objects, Missing",
+            ),
+            COMPOSITE_ITEMS.to_owned(),
+        ),
+    ] {
+        for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+            let mut model = composite_library(format, &kernel, &items);
+            model.add_source(
+                "refusal.sysml",
+                "part def Module; part def Container { part camera : Module; } part outer : Module { part camera : Module; }",
+            );
+            let mut r = ResolvedModel::build(&model);
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            let camera = r.resolve_qualified("Container::camera").unwrap();
+            assert!(
+                r.property(camera, "type").is_err(),
+                "{format:?} {kernel} {items}"
+            );
+            assert!(r.property(camera, "partDefinition").is_err());
+            let nested = r.resolve_qualified("outer::camera").unwrap();
+            assert!(r.property(nested, "type").is_err());
+        }
+    }
+}
+
+#[test]
+fn nested_composite_typing_uses_complete_owner_types_across_replay() {
+    use std::sync::Arc;
+    use sysmlv2_parser::prepared::PreparedLibrary;
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = composite_library(format, COMPOSITE_KERNEL, COMPOSITE_ITEMS);
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(139).unwrap(), 139).unwrap());
+        for mode in 0..3 {
+            for warm in [false, true] {
+                let mut model = if mode == 0 {
+                    composite_library(format, COMPOSITE_KERNEL, COMPOSITE_ITEMS)
+                } else {
+                    let mut model = Model::with_graph_format(format);
+                    Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                        .install(&mut model)
+                        .unwrap();
+                    model
+                };
+                let parsed = model.add_source(
+                    "nested.sysml",
+                    "
+                    part def Module; item def ItemType; occurrence def Event;
+                    part outer : Module { part inner : Module { part sensor : Module; } }
+                    item items : ItemType { item inner : ItemType; }
+                    occurrence events : Event { occurrence inner : Event; }
+                    part broken : Missing { part inner : Module; }
+                    part valued : Module = 1 { part inner : Module; }
+                    variation part varying : Module { part inner : Module; }
+                ",
+                );
+                assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+                let mut r = ResolvedModel::build(&model);
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                for (path, target) in [
+                    ("outer::inner", "Module"),
+                    ("outer::inner::sensor", "Module"),
+                    ("items::inner", "ItemType"),
+                    ("events::inner", "Event"),
+                ] {
+                    let e = r.resolve_qualified(path).unwrap();
+                    let target = r.resolve_qualified(target).unwrap();
+                    if warm {
+                        let _ = r.property(e, "owningType");
+                        let _ = r.property(e, "ownedRelationship");
+                    }
+                    assert_eq!(
+                        r.feature_type_report(e).types,
+                        Ok(vec![target]),
+                        "{format:?} {mode} {warm} {path}"
+                    );
+                    assert_eq!(
+                        r.property(e, "definition"),
+                        Ok(serde_json::json!([{"@id":r.element_id(target).to_string()}]))
+                    );
+                }
+                for path in ["broken::inner", "valued::inner", "varying::inner"] {
+                    let e = r.resolve_qualified(path).unwrap();
+                    assert!(r.property(e, "type").is_err(), "{format:?} {mode} {path}");
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checked_visible_prerequisites.rs b/crates/sysmlv2-parser/tests/checked_visible_prerequisites.rs
new file mode 100644
index 0000000..6f430d2
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checked_visible_prerequisites.rs
@@ -0,0 +1,255 @@
+//! Visible package imports on prerequisite owners preserve selected contribution identity.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{DerivedValue, ElementRef, OperationError, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+fn inherited(r: &mut ResolvedModel, owner: ElementRef) -> Result<Vec<ElementRef>, OperationError> {
+    let report = r.invoke_operation(
+        owner,
+        "Core-Types-Type-inheritedMemberships_Namespace_Type_Boolean",
+        &[
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Elements(vec![]),
+            DerivedValue::Bool(true),
+        ],
+    )?;
+    let DerivedValue::References(values) = report.value else {
+        panic!("expected memberships")
+    };
+    Ok(values
+        .into_iter()
+        .map(|v| match v {
+            Reference::Element(e) => e,
+            _ => panic!("expected loaded membership"),
+        })
+        .collect())
+}
+fn edges(r: &mut ResolvedModel, name: &str) -> Vec<(String, String)> {
+    let e = r.resolve_qualified(name).unwrap();
+    let rows = r
+        .implied_relationships(e)
+        .into_iter()
+        .filter(|&e| r.element_type(e) == "Redefinition")
+        .collect::<Vec<_>>();
+    rows.into_iter()
+        .map(|e| {
+            (
+                r.element_id(e).to_string(),
+                r.property(e, "redefinedFeature").unwrap()["@id"]
+                    .as_str()
+                    .unwrap()
+                    .to_owned(),
+            )
+        })
+        .collect()
+}
+fn id(r: &mut ResolvedModel, name: &str) -> String {
+    let e = r.resolve_qualified(name).unwrap();
+    r.element_id(e).to_string()
+}
+fn membership(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let e = r.resolve_qualified(name).unwrap();
+    let value = r.property(e, "owningRelationship").unwrap();
+    r.element_by_id(value["@id"].as_str().unwrap()).unwrap()
+}
+fn named_membership(r: &mut ResolvedModel, owner: &str, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(owner).unwrap();
+    r.owned_relationships(owner)
+        .into_iter()
+        .find(|&m| r.membership_member_name(m).as_deref() == Some(name))
+        .unwrap()
+}
+#[test]
+fn canonical_visible_prerequisites_preserve_actual_library_imports_and_replay() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        return;
+    }
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut base = Model::with_graph_format(format);
+        base.load_library_dir(&library).unwrap();
+        base.record_library_cache();
+        ResolvedModel::build(&base);
+        let cache =
+            LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes())
+                .unwrap();
+        let prepared = base.prepare_library().unwrap();
+        let decoded =
+            Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(95).unwrap(), 95).unwrap());
+        for early_foreign in [true, false] {
+            let mut expected = None;
+            for mode in 0..4 {
+                let mut model = Model::with_graph_format(format);
+                match mode {
+                    2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                    3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                    _ => {
+                        model.load_library_dir(&library).unwrap();
+                        if mode == 1 {
+                            model.set_library_cache(cache.clone());
+                        }
+                    }
+                }
+                let catalogs="
+                    package PublicNamed {class Named;}
+                    package PublicNamespace {class ViaNamespace; alias NamedAlias for PublicNamed::Named;}
+                    package ProtectedNamed {class Hidden;}
+                    package ProtectedNamespace {class ViaProtected;}
+                    package AncestorCatalog {class AncestorMarker;}
+                    package FeatureCatalog {feature packageFeature;}
+                    class Tools {feature slot;}
+                    package FeatureAliases {alias typeSlotAlias for Tools::slot;}
+                ";
+                let mut foreign = String::new();
+                let mut consumers = String::new();
+                for (family, kind, role) in [
+                    ("End", "class", "end feature"),
+                    ("Input", "behavior", "in"),
+                    ("Result", "function", "return"),
+                ] {
+                    foreign.push_str(&format!(
+                        "{kind} Base{family} {{public import AncestorCatalog::*; {role} original;}}
+                        {kind} Foreign{family} specializes Base{family} {{
+                            public import PublicNamed::Named;
+                            public import PublicNamespace::*;
+                            protected import ProtectedNamed::Hidden;
+                            protected import ProtectedNamespace::*;
+                            public import FeatureCatalog::*;
+                            public import FeatureAliases::typeSlotAlias;
+                            {role} selected;
+                        }}"
+                    ));
+                    consumers.push_str(&format!(
+                        "{kind} Provider{family} {{public import Foreign{family}::selected;}}
+                        {kind} Bridge{family} specializes Provider{family};
+                        {kind} Child{family} specializes Bridge{family} {{{role} replacement;}}
+                        {kind} RealChild{family} specializes Foreign{family};"
+                    ));
+                }
+                let negatives="
+                    class OtherRole {end feature outside;}
+                    package RoleAliases {alias outsideAlias for OtherRole::outside;}
+                    class NestedRoleOwner specializes BaseEnd {public import RoleAliases::*; end feature nested;}
+                    class NestedProvider {public import NestedRoleOwner::nested;}
+                    class NestedChild specializes NestedProvider;
+                    package RecursiveCatalog {package Inner {class Item;}}
+                    class RecursiveOwner specializes BaseEnd {public import RecursiveCatalog::**; end feature recursiveEnd;}
+                    class RecursiveProvider {public import RecursiveOwner::recursiveEnd;}
+                    class RecursiveChild specializes RecursiveProvider;
+                ";
+                let source = format!(
+                    "{catalogs} {} {} {negatives}",
+                    if early_foreign { &foreign } else { &consumers },
+                    if early_foreign { &consumers } else { &foreign }
+                );
+                let unit = model.add_source("checked-visible-prerequisites.kerml", &source);
+                assert!(
+                    unit.diagnostics.is_empty(),
+                    "{format:?} early={early_foreign} mode={mode}: {:?}",
+                    unit.diagnostics
+                );
+                let mut r = ResolvedModel::build(&model);
+                let cold_owner = r.resolve_qualified("ChildResult").unwrap();
+                let cold = inherited(&mut r, cold_owner);
+                if format == GraphFormat::CanonicalV3 {
+                    assert_eq!(cold.unwrap(), vec![], "early={early_foreign} mode={mode}");
+                } else {
+                    assert!(matches!(cold, Err(OperationError::Incomplete { .. })));
+                }
+                let mut identities = Vec::<Vec<String>>::new();
+                for family in ["End", "Input", "Result"] {
+                    let foreign_name = format!("Foreign{family}::selected");
+                    let selected = id(&mut r, &foreign_name);
+                    let own_name = format!("Child{family}::replacement");
+                    let foreign_edges = edges(&mut r, &foreign_name);
+                    let child_edges = edges(&mut r, &own_name);
+                    let child = r.resolve_qualified(&format!("Child{family}")).unwrap();
+                    let real = r.resolve_qualified(&format!("RealChild{family}")).unwrap();
+                    if format == GraphFormat::CanonicalV3 {
+                        assert_eq!(foreign_edges.len(), 1);
+                        assert_eq!(
+                            foreign_edges[0].1,
+                            id(&mut r, &format!("Base{family}::original"))
+                        );
+                        // An imported end, input or result is a slot one
+                        // inheritance step later, which the child's own takes
+                        // over.
+                        let inherited_child = inherited(&mut r, child).unwrap();
+                        assert_eq!(child_edges.len(), 1, "{family}");
+                        assert_eq!(child_edges[0].1, selected, "{family}");
+                        assert!(
+                            inherited_child.is_empty(),
+                            "proof-only foreign imports must not contribute: {family}"
+                        );
+                        identities.push(
+                            inherited_child
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                        let wanted = vec![
+                            membership(&mut r, &foreign_name),
+                            membership(&mut r, "PublicNamed::Named"),
+                            membership(&mut r, "PublicNamespace::ViaNamespace"),
+                            named_membership(&mut r, "PublicNamespace", "NamedAlias"),
+                            membership(&mut r, "FeatureCatalog::packageFeature"),
+                            named_membership(&mut r, "FeatureAliases", "typeSlotAlias"),
+                            membership(&mut r, "ProtectedNamed::Hidden"),
+                            membership(&mut r, "ProtectedNamespace::ViaProtected"),
+                            membership(&mut r, "AncestorCatalog::AncestorMarker"),
+                        ];
+                        let inherited_real = inherited(&mut r, real).unwrap();
+                        assert_eq!(
+                            inherited_real, wanted,
+                            "real inheritance contributes public/protected imports in order: {family} early={early_foreign} mode={mode}"
+                        );
+                        identities.push(
+                            inherited_real
+                                .into_iter()
+                                .map(|e| r.element_id(e).to_string())
+                                .collect(),
+                        );
+                        // Package-owned Feature and alias-to-Type Feature retain
+                        // their memberships but create no FeatureMembership slot.
+                        let report = r.type_feature_report(real).projections.unwrap();
+                        for name in ["FeatureCatalog::packageFeature", "Tools::slot"] {
+                            let e = r.resolve_qualified(name).unwrap();
+                            assert!(!report.features.contains(&e));
+                        }
+                    } else {
+                        assert!(matches!(
+                            inherited(&mut r, child),
+                            Err(OperationError::Incomplete { .. })
+                        ));
+                    }
+                    for rows in [foreign_edges, child_edges] {
+                        identities.push(
+                            rows.into_iter()
+                                .flat_map(|(id, target)| [id, target])
+                                .collect(),
+                        );
+                    }
+                }
+                for owner in ["NestedChild", "RecursiveChild"] {
+                    let e = r.resolve_qualified(owner).unwrap();
+                    assert!(
+                        matches!(inherited(&mut r, e), Err(OperationError::Incomplete { .. })),
+                        "nested external role or recursive lookup remains qualified: {owner}"
+                    );
+                }
+                if let Some(expected) = &expected {
+                    assert_eq!(
+                        &identities, expected,
+                        "{format:?} early={early_foreign} mode={mode}"
+                    );
+                } else {
+                    expected = Some(identities);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/checker_identity.rs b/crates/sysmlv2-parser/tests/checker_identity.rs
new file mode 100644
index 0000000..c0502f9
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/checker_identity.rs
@@ -0,0 +1,872 @@
+//! Semantic diagnostics must use bound identities rather than display spellings.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    check, json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+
+fn models(source: &str) -> Vec<Model> {
+    models_in(source, "kerml")
+}
+
+fn models_in(source: &str, dialect: &str) -> Vec<Model> {
+    models_with_library(
+        source,
+        dialect,
+        "package ScalarValues { datatype Integer; datatype Boolean; } package Tags { metaclass Tag; #Tag class Tagged; }",
+    )
+}
+
+fn models_with_library(source: &str, dialect: &str, library: &str) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("library.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("library.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for package in ["A", "B"] {
+                let unit = model.add_source(
+                    format!("{package}.{dialect}"),
+                    &format!("package {package} {{ {source} }}"),
+                );
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            }
+            model
+        })
+        .collect()
+}
+
+#[test]
+fn scalar_conformance_uses_source_bound_identity_without_capturing_other_units() {
+    for (actual, spelled, expected) in [("\"bad\"", "2", "A.kerml"), ("2", "\"bad\"", "B.kerml")] {
+        let source = format!(
+            "feature actual = {actual}; feature '{ID}' = {spelled}; feature checked : ScalarValues::Integer = '{ID}';"
+        );
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            let actual = r.resolve_qualified("A::actual").unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(actual),
+                ID.parse().unwrap(),
+            )]));
+            let checked = r.resolve_qualified("A::checked").unwrap();
+            let value = r.members_via(checked, "FeatureValue")[0];
+            let membership = r.owned_relationships(value)[0];
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let findings = check::validate_semantics_with(&mut r, &model);
+                assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, expected);
+                assert!(
+                    findings[0].1.message.contains("evaluates to a String"),
+                    "{findings:?}"
+                );
+                let text = format!(
+                    "package {} {{ {source} }}",
+                    expected.trim_end_matches(".kerml")
+                );
+                assert_eq!(
+                    &text[findings[0].1.span.start as usize..findings[0].1.span.end as usize],
+                    format!("'{ID}'")
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn duplicate_specializations_use_resolved_endpoints_across_replay() {
+    let source = format!("class Good; class '{ID}'; class Child specializes Good, '{ID}';");
+    for (mode, model) in models(&source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        let good = r.resolve_qualified("A::Good").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(good), ID.parse().unwrap())]));
+        let child = r.resolve_qualified("A::Child").unwrap();
+        let edges: Vec<_> = r
+            .owned_relationships(child)
+            .into_iter()
+            .filter(|e| r.element_type(*e) == "Subclassification")
+            .collect();
+        let mut hints = HashMap::from([(
+            (r.element_id(edges[1]), "superclassifier".into()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+            assert_eq!(model.unit(findings[0].0).name, "A.kerml");
+            assert!(
+                findings[0]
+                    .1
+                    .message
+                    .starts_with("duplicate specialization"),
+                "{findings:?}"
+            );
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn specialization_cycles_follow_bound_endpoints() {
+    for cyclic in [false, true] {
+        let source = if cyclic {
+            format!("class Good specializes Bridge; class Bridge specializes '{ID}'; class '{ID}';")
+        } else {
+            format!("class Good specializes '{ID}'; class '{ID}';")
+        };
+        for model in models(&source) {
+            let mut r = ResolvedModel::build(&model);
+            let good = r.resolve_qualified("A::Good").unwrap();
+            r.override_ids(&HashMap::from([(r.element_id(good), ID.parse().unwrap())]));
+            let owner = if cyclic {
+                r.resolve_qualified("A::Bridge").unwrap()
+            } else {
+                good
+            };
+            let edge = r
+                .owned_relationships(owner)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Subclassification")
+                .unwrap();
+            let mut hints = HashMap::from([(
+                (r.element_id(edge), "superclassifier".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), if cyclic { 2 } else { 1 }, "{findings:?}");
+            for (unit, d) in findings {
+                assert_eq!(model.unit(unit).name, "A.kerml");
+                assert!(
+                    if cyclic {
+                        d.message.starts_with("circular specialization")
+                    } else {
+                        d.message.contains("cannot specialize itself")
+                    },
+                    "{}",
+                    d.message
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn redefinition_duplicate_checks_preserve_pending_header_exclusion() {
+    let mut model = Model::new();
+    model.add_source("test.kerml", "class Base { feature x; } class Child specializes Base { feature x redefines x, Base::x; }");
+    assert!(!model.has_errors());
+    let findings = check::validate_semantics(&model);
+    assert_eq!(findings.len(), 1, "{findings:?}");
+    assert!(
+        findings[0]
+            .1
+            .message
+            .starts_with("duplicate specialization"),
+        "{findings:?}"
+    );
+}
+
+#[test]
+fn metadata_typing_uses_the_stored_type_identity() {
+    let source = format!("metaclass Good; class '{ID}'; metadata m : '{ID}';");
+    for model in models(&source) {
+        let mut r = ResolvedModel::build(&model);
+        let good = r.resolve_qualified("A::Good").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(good), ID.parse().unwrap())]));
+        let owner = r.resolve_qualified("A::m").unwrap();
+        let edge = r
+            .owned_relationships(owner)
+            .into_iter()
+            .find(|e| r.element_type(*e) == "FeatureTyping")
+            .unwrap();
+        let mut hints = HashMap::from([((r.element_id(edge), "type".into()), ID.parse().unwrap())]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+            .into_iter()
+            .filter(|(_, d)| d.message.starts_with("metadata must be typed"))
+            .collect();
+        assert_eq!(findings.len(), 1, "{findings:?}");
+        assert_eq!(model.unit(findings[0].0).name, "B.kerml");
+    }
+}
+
+#[test]
+fn unresolved_redefinitions_are_not_reinterpreted_as_self_targets() {
+    let mut model = Model::new();
+    model.add_source("test.kerml", "class C { feature x redefines x, x; }");
+    assert!(!model.has_errors());
+    assert!(check::validate_semantics(&model).is_empty());
+}
+
+#[test]
+fn shorthand_metadata_typings_record_identity_and_preserve_replay() {
+    for spelling in [
+        format!("#'{ID}' class Annotated;"),
+        format!("class Annotated {{ @'{ID}'; }}"),
+    ] {
+        let source = format!("metaclass Good; class '{ID}'; {spelling}");
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            let good = r.resolve_qualified("A::Good").unwrap();
+            r.override_ids(&HashMap::from([(r.element_id(good), ID.parse().unwrap())]));
+            let annotated = r.resolve_qualified("A::Annotated").unwrap();
+            let metadata = r.metadata_of(annotated);
+            assert_eq!(metadata.len(), 1);
+            let edge = r
+                .owned_relationships(metadata[0])
+                .into_iter()
+                .find(|e| r.element_type(*e) == "FeatureTyping")
+                .unwrap();
+            let mut hints =
+                HashMap::from([((r.element_id(edge), "type".into()), ID.parse().unwrap())]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| d.message.starts_with("metadata must be typed"))
+                    .collect();
+                assert_eq!(findings.len(), 1, "mode{mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, "B.kerml");
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+// Bind only the selected expression in A; B has identical source spans and an
+// ordinary declaration whose name happens to be the UUID spelling.
+fn bind_expression(r: &mut ResolvedModel, owner: &str, relationship: &str) {
+    let actual = r.resolve_qualified("A::Actual").unwrap();
+    r.override_ids(&HashMap::from([(
+        r.element_id(actual),
+        ID.parse().unwrap(),
+    )]));
+    let owner = r.resolve_qualified(owner).unwrap();
+    let expr = r.members_via(owner, relationship)[0];
+    let edge = r
+        .owned_relationships(expr)
+        .into_iter()
+        .find(|e| r.element_type(*e) == "Membership")
+        .unwrap();
+    let mut hints = HashMap::from([(
+        (r.element_id(edge), "memberElement".into()),
+        ID.parse().unwrap(),
+    )]);
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&ID.parse().unwrap())
+    );
+}
+
+#[test]
+fn expression_reference_kind_preserves_value_and_result_source_identity() {
+    for (actual, spelled, expected) in [
+        ("class Actual;", format!("feature '{ID}'=1;"), "A.kerml"),
+        ("feature Actual=1;", format!("class '{ID}';"), "B.kerml"),
+    ] {
+        for (declaration, relation) in [
+            (format!("feature checked='{ID}';"), "FeatureValue"),
+            (
+                format!("function checked {{ '{ID}' }}"),
+                "ResultExpressionMembership",
+            ),
+        ] {
+            let source = format!("{actual} {spelled} {declaration}");
+            for (mode, model) in models(&source).into_iter().enumerate() {
+                let mut r = ResolvedModel::build(&model);
+                bind_expression(&mut r, "A::checked", relation);
+                for _ in 0..2 {
+                    let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                        .into_iter()
+                        .filter(|(_, d)| {
+                            d.message
+                                .contains("validateFeatureReferenceExpressionReferentIsFeature")
+                        })
+                        .collect();
+                    assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                    assert_eq!(model.unit(findings[0].0).name, expected);
+                    let text = format!(
+                        "package {} {{ {source} }}",
+                        expected.trim_end_matches(".kerml")
+                    );
+                    assert_eq!(
+                        &text[findings[0].1.span.start as usize..findings[0].1.span.end as usize],
+                        format!("'{ID}'")
+                    );
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn invocation_arity_preserves_value_and_result_source_identity() {
+    for (actual, spelled, expected) in [
+        ("in a; in b; a+b", "in a; a", "A.sysml"),
+        ("in a; a", "in a; in b; a+b", "B.sysml"),
+    ] {
+        for (declaration, relation) in [
+            (format!("attribute checked='{ID}'(1);"), "FeatureValue"),
+            (
+                format!("calc def checked {{ '{ID}'(1) }}"),
+                "ResultExpressionMembership",
+            ),
+        ] {
+            let source = format!(
+                "calc def Actual {{ {actual} }} calc def '{ID}' {{ {spelled} }} {declaration}"
+            );
+            for (mode, model) in models_in(&source, "sysml").into_iter().enumerate() {
+                let mut r = ResolvedModel::build(&model);
+                bind_expression(&mut r, "A::checked", relation);
+                for _ in 0..2 {
+                    let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                        .into_iter()
+                        .filter(|(_, d)| d.message.contains("never bound"))
+                        .collect();
+                    assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                    assert_eq!(model.unit(findings[0].0).name, expected);
+                    let text = format!(
+                        "package {} {{ {source} }}",
+                        expected.trim_end_matches(".sysml")
+                    );
+                    assert_eq!(
+                        &text[findings[0].1.span.start as usize..findings[0].1.span.end as usize],
+                        format!("'{ID}'(1)")
+                    );
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn invocation_callee_kind_uses_bound_identity() {
+    for (actual, spelled, expected) in [
+        (
+            "class Actual;",
+            format!("function '{ID}' {{ 1 }}"),
+            "A.kerml",
+        ),
+        ("function Actual { 1 }", format!("class '{ID}';"), "B.kerml"),
+    ] {
+        let source = format!("{actual} {spelled} feature checked='{ID}'();");
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            bind_expression(&mut r, "A::checked", "FeatureValue");
+            let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                .into_iter()
+                .filter(|(_, d)| {
+                    d.message
+                        .contains("validateInvocationExpressionInstantiatedType")
+                })
+                .collect();
+            assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+            assert_eq!(model.unit(findings[0].0).name, expected);
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn scoped_filter_type_uses_bound_source_identity() {
+    for (actual, spelled, expected) in [
+        ("Integer = 1", "Boolean = true", "A.kerml"),
+        ("Boolean = true", "Integer = 1", "B.kerml"),
+    ] {
+        let source = format!(
+            "feature Actual : ScalarValues::{actual}; feature '{ID}' : ScalarValues::{spelled}; filter '{ID}';"
+        );
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            bind_expression(&mut r, "A", "ElementFilterMembership");
+            let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                .into_iter()
+                .filter(|(_, d)| {
+                    d.message
+                        .contains("validateElementFilterMembershipIsBoolean")
+                })
+                .collect();
+            assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+            assert_eq!(model.unit(findings[0].0).name, expected);
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn contract_reference_kind_preserves_source_identity() {
+    for (actual, spelled, expected) in [
+        (
+            "attribute Actual = true;",
+            format!("part def '{ID}';"),
+            "B.sysml",
+        ),
+        (
+            "part def Actual;",
+            format!("attribute '{ID}' = true;"),
+            "A.sysml",
+        ),
+    ] {
+        let source =
+            format!("{actual} {spelled} part target; action def Work {{ send '{ID}' to target; }}");
+        for (mode, model) in models_in(&source, "sysml").into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            let actual = r.resolve_qualified("A::Actual").unwrap();
+            let spelled = r.resolve_qualified(&format!("A::'{ID}'")).unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(actual),
+                ID.parse().unwrap(),
+            )]));
+            let sites = r.references_to(spelled);
+            assert_eq!(sites.len(), 1);
+            let mut hints = HashMap::from([(
+                (r.element_id(sites[0].owner), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| {
+                        d.message
+                            .contains("validateFeatureReferenceExpressionReferentIsFeature")
+                    })
+                    .collect();
+                assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, expected);
+                let text = format!(
+                    "package {} {{ {source} }}",
+                    expected.trim_end_matches(".sysml")
+                );
+                assert_eq!(
+                    &text[findings[0].1.span.start as usize..findings[0].1.span.end as usize],
+                    format!("'{ID}'")
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn filter_evaluability_follows_dependency_source_across_units() {
+    for (actual, spelled, expected) in [
+        (
+            "class Holder { feature Actual; }",
+            format!("feature '{ID}'=true;"),
+            "UA",
+        ),
+        (
+            "feature Actual=true;",
+            format!("class Holder {{ feature runtime; }} feature '{ID}'=Holder::runtime;"),
+            "UB",
+        ),
+    ] {
+        let actual_path = if actual.starts_with("class") {
+            "A::Holder::Actual"
+        } else {
+            "A::Actual"
+        };
+        let reference = format!("'{ID}'");
+        let source = format!("{actual} {spelled} feature bridge={reference};");
+        for (mode, mut model) in models(&source).into_iter().enumerate() {
+            let use_source = "package UA { filter A::bridge; } package UB { filter B::bridge; }";
+            model.add_source("use.kerml", use_source);
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let actual = r.resolve_qualified(actual_path).unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(actual),
+                ID.parse().unwrap(),
+            )]));
+            let bridge = r.resolve_qualified("A::bridge").unwrap();
+            let expr = r.members_via(bridge, "FeatureValue")[0];
+            let edge = r
+                .owned_relationships(expr)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Membership")
+                .unwrap();
+            let mut hints = HashMap::from([(
+                (r.element_id(edge), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| {
+                        d.message
+                            .contains("validateElementFilterMembershipIsModelLevelEvaluable")
+                    })
+                    .collect();
+                assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, "use.kerml");
+                let span = findings[0].1.span;
+                assert_eq!(
+                    &use_source[span.start as usize..span.end as usize],
+                    if expected == "UA" {
+                        "A::bridge"
+                    } else {
+                        "B::bridge"
+                    }
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+fn bind_named_site(r: &mut ResolvedModel, actual: &str, key: &str) {
+    let actual = r.resolve_qualified(actual).unwrap();
+    let spelled = r.resolve_qualified(&format!("A::'{ID}'")).unwrap();
+    r.override_ids(&HashMap::from([(
+        r.element_id(actual),
+        ID.parse().unwrap(),
+    )]));
+    let sites = r.references_to(spelled);
+    assert_eq!(sites.len(), 1, "{sites:?}");
+    let mut hints = HashMap::from([(
+        (r.element_id(sites[0].owner), key.into()),
+        ID.parse().unwrap(),
+    )]);
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&ID.parse().unwrap())
+    );
+}
+
+#[test]
+fn metadata_relationship_and_chain_checks_preserve_bound_identity() {
+    let cases = [
+        (
+            "kerml",
+            format!(
+                "class Holder {{ feature Actual; }} feature '{ID}'=true; metaclass M {{ feature value; }} metadata m:M {{ feature value='{ID}'; }}"
+            ),
+            "A::Holder::Actual",
+            "memberElement",
+            "metadata body value must be model-level",
+        ),
+        (
+            "kerml",
+            format!(
+                "datatype T; datatype U; feature Actual:U; feature '{ID}':T; function f {{ return r:T; '{ID}' }}"
+            ),
+            "A::Actual",
+            "memberElement",
+            "validateBindingConnectorTypeConformance",
+        ),
+        (
+            "kerml",
+            format!(
+                "class Holder {{ feature Actual; }} feature '{ID}'; class C {{ feature checked='{ID}'; }}"
+            ),
+            "A::Holder::Actual",
+            "memberElement",
+            "validateConnectorTypeFeaturing",
+        ),
+        (
+            "kerml",
+            format!(
+                "class Holder {{ feature Actual {{ feature leaf; }} }} feature '{ID}' {{ feature leaf; }} class C {{ feature checked subsets '{ID}'.leaf; }}"
+            ),
+            "A::Holder::Actual",
+            "chainingFeature",
+            "subsetted feature chain is featured",
+        ),
+        (
+            "sysml",
+            format!(
+                "part def T; part def U; part Actual:U; part '{ID}':T; requirement def R {{ subject s:T; }} requirement req:R; satisfy req by '{ID}';"
+            ),
+            "A::Actual",
+            "memberElement",
+            "validateBindingConnectorTypeConformance",
+        ),
+    ];
+    for (dialect, source, actual, key, rule) in cases {
+        for (mode, model) in models_in(&source, dialect).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            bind_named_site(&mut r, actual, key);
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| d.message.contains(rule))
+                    .collect();
+                assert_eq!(findings.len(), 1, "{rule}, mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, format!("A.{dialect}"));
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+const QUANTITY_LIBRARY: &str = "package Quantities { datatype QuantityValue; datatype QuantityPowerFactor; } package Q { feature L; feature T; datatype LengthUnit { feature pf : Quantities::QuantityPowerFactor { feature quantity = Q::L; feature exponent = 1; } } datatype TimeUnit { feature pf : Quantities::QuantityPowerFactor { feature quantity = Q::T; feature exponent = 1; } } datatype Length { feature mRef : LengthUnit; } datatype Time { feature mRef : TimeUnit; } } package ISQ { datatype DurationValue :> Q::Time; }";
+
+#[test]
+fn dimension_checks_preserve_root_and_cross_unit_dependency_identity() {
+    for (actual, spelled, expected) in [("Time", "Length", "A"), ("Length", "Time", "B")] {
+        for expression in [format!("'{ID}' + length"), "bridge + length".into()] {
+            let recursive = expression.starts_with("bridge");
+            let bridge = if recursive {
+                format!("feature bridge = '{ID}';")
+            } else {
+                String::new()
+            };
+            for result in [false, true] {
+                let root = if result {
+                    format!("function checked {{ {expression} }}")
+                } else {
+                    format!("feature checked = {expression};")
+                };
+                let source = format!(
+                    "feature Actual : Q::{actual}; feature '{ID}' : Q::{spelled}; feature length : Q::Length; {bridge} {root}"
+                );
+                for (mode, mut model) in models_with_library(&source, "kerml", QUANTITY_LIBRARY)
+                    .into_iter()
+                    .enumerate()
+                {
+                    if recursive {
+                        model.add_source("use.kerml", "package UA { feature checked=A::bridge + A::length; } package UB { feature checked=B::bridge + B::length; }");
+                    }
+                    let mut r = ResolvedModel::build(&model);
+                    bind_named_site(&mut r, "A::Actual", "memberElement");
+                    for _ in 0..2 {
+                        let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                            .into_iter()
+                            .filter(|(_, d)| d.message.contains("incompatible quantity dimensions"))
+                            .collect();
+                        assert_eq!(
+                            findings.len(),
+                            if recursive { 2 } else { 1 },
+                            "mode {mode}: {findings:?}"
+                        );
+                        assert!(
+                            findings
+                                .iter()
+                                .any(|(u, _)| model.unit(*u).name == format!("{expected}.kerml"))
+                        );
+                        for (unit, d) in findings {
+                            if model.unit(unit).name == "use.kerml" {
+                                let text = "package UA { feature checked=A::bridge + A::length; } package UB { feature checked=B::bridge + B::length; }";
+                                assert_eq!(
+                                    &text[d.span.start as usize..d.span.end as usize],
+                                    format!("{expected}::bridge + {expected}::length")
+                                );
+                            }
+                        }
+                    }
+                    if mode == 3 {
+                        assert_eq!(model.loaded_library_unit_count(), 0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn action_contract_checks_preserve_bound_identity() {
+    let cases = [
+        (
+            format!(
+                "part def Actual; attribute '{ID}'[1]; action def Work {{ assign '{ID}' := 1; }}"
+            ),
+            "validateAssignmentActionUsageReferent",
+        ),
+        (
+            format!("port Actual; part '{ID}'; action def Work {{ send 1 to '{ID}'; }}"),
+            "validateSendActionUsageReceiver",
+        ),
+        (
+            format!(
+                "attribute Actual : ScalarValues::Integer; attribute '{ID}' : ScalarValues::Boolean; action def Work {{ accept when '{ID}'; }}"
+            ),
+            "validateTriggerInvocationActionWhenArgument",
+        ),
+        (
+            format!(
+                "attribute Actual : ScalarValues::Integer; attribute '{ID}' : ScalarValues::Boolean; state def Work {{ state a; state b; transition first a if '{ID}' then b; }}"
+            ),
+            "validateTransitionFeatureMembershipGuardExpression",
+        ),
+    ];
+    for (source, rule) in cases {
+        for (mode, model) in models_in(&source, "sysml").into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            bind_named_site(&mut r, "A::Actual", "memberElement");
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| d.code == Some(rule))
+                    .collect();
+                assert_eq!(findings.len(), 1, "{rule}, mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, "A.sysml");
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn quantity_factor_queries_preserve_quantity_and_exponent_identity() {
+    for exponent in [false, true] {
+        let source = if exponent {
+            format!(
+                "feature Actual=2; feature '{ID}'=1; feature L; datatype Unit {{ feature pf:Quantities::QuantityPowerFactor {{ feature quantity=L; feature exponent='{ID}'; }} }} datatype Amount {{ feature mRef:Unit; }}"
+            )
+        } else {
+            format!(
+                "feature Actual; feature '{ID}'; datatype Unit {{ feature pf:Quantities::QuantityPowerFactor {{ feature quantity='{ID}'; feature exponent=1; }} }} datatype Amount {{ feature mRef:Unit; }}"
+            )
+        };
+        for (mode, model) in models_with_library(&source, "kerml", QUANTITY_LIBRARY)
+            .into_iter()
+            .enumerate()
+        {
+            let mut r = ResolvedModel::build(&model);
+            bind_named_site(&mut r, "A::Actual", "memberElement");
+            for _ in 0..2 {
+                for package in ["B", "A"] {
+                    let amount = r.resolve_qualified(&format!("{package}::Amount")).unwrap();
+                    let dims = r.quantity_dims_of_type(amount).unwrap();
+                    assert_eq!(
+                        dims.render(&r),
+                        if exponent {
+                            if package == "A" { "L^2" } else { "L" }
+                        } else if package == "A" {
+                            "Actual"
+                        } else {
+                            ID
+                        },
+                        "mode {mode}"
+                    );
+                }
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn after_trigger_dimension_inference_preserves_source_identity() {
+    for (actual, spelled, expected) in
+        [("Length", "Time", "A.sysml"), ("Time", "Length", "B.sysml")]
+    {
+        let source = format!(
+            "attribute Actual:Q::{actual}; attribute '{ID}':Q::{spelled}; action def Work {{ accept after ('{ID}' * 1); }}"
+        );
+        for (mode, model) in models_with_library(&source, "sysml", QUANTITY_LIBRARY)
+            .into_iter()
+            .enumerate()
+        {
+            let mut r = ResolvedModel::build(&model);
+            bind_named_site(&mut r, "A::Actual", "memberElement");
+            for _ in 0..2 {
+                let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                    .into_iter()
+                    .filter(|(_, d)| d.code == Some("validateTriggerInvocationActionAfterArgument"))
+                    .collect();
+                assert_eq!(findings.len(), 1, "mode {mode}: {findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, expected);
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn declared_multiplicity_query_preserves_bound_identity() {
+    for (actual, expected) in [("2", Some((2.0, 2.0))), ("true", None), ("missing", None)] {
+        let source = format!("feature Actual={actual}; feature '{ID}'=1; feature sized['{ID}'];");
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            bind_named_site(&mut r, "A::Actual", "memberElement");
+            for _ in 0..2 {
+                let a = r.resolve_qualified("A::sized").unwrap();
+                let b = r.resolve_qualified("B::sized").unwrap();
+                assert_eq!(r.declared_multiplicity(a), expected, "mode {mode}");
+                assert_eq!(r.declared_multiplicity(b), Some((1.0, 1.0)), "mode {mode}");
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/closure_policy.rs b/crates/sysmlv2-parser/tests/closure_policy.rs
index 303f834..4be702d 100644
--- a/crates/sysmlv2-parser/tests/closure_policy.rs
+++ b/crates/sysmlv2-parser/tests/closure_policy.rs
@@ -1,4 +1,4 @@
-//! The closure policy on the standard corpus (plan §33h): the full form
+//! The closure policy on the standard corpus: the full form
 //! with the inheritance and import closures materialized per element
 //! stays schema-shaped and a superset of the passthrough form, and its
 //! size is measured — the number INTEROP.md's "passthrough level"
@@ -8,6 +8,7 @@
 
 #![cfg(feature = "json")]
 
+use serde_json::Value;
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use sysmlv2_parser::full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json};
@@ -123,11 +124,11 @@ fn corpus_closure_form_is_a_superset_and_measured() {
         },
     );
     // Per element: the closure names are empty at the passthrough level
-    // and the inheritance-aware lists grow into supersets. The lengths
-    // the implied heritage is measured against outlive the two documents
+    // and the inheritance-aware lists retain every owned member. Owned
+    // feature references outlive the two documents
     // they come from — a third corpus document alongside them is
     // gigabytes, so they are carried out and the documents dropped.
-    let implied_floor: HashMap<String, [Option<usize>; 2]> = {
+    let owned_features: HashMap<String, Vec<Value>> = {
         let pass = by_id(&passthrough);
         let closed = by_id(&explicit);
         assert_eq!(pass.len(), closed.len());
@@ -190,11 +191,11 @@ fn corpus_closure_form_is_a_superset_and_measured() {
         );
         assert!(closure_nonempty > 0);
         assert!(feature_grew > 0);
-        closed
-            .iter()
-            .map(|(id, c)| {
-                let len = |name: &str| c.get(name).and_then(|v| v.as_array()).map(Vec::len);
-                ((*id).to_string(), [len("feature"), len("inheritedFeature")])
+        pass.iter()
+            .filter_map(|(id, p)| {
+                p.get("feature")
+                    .and_then(Value::as_array)
+                    .map(|features| ((*id).to_owned(), features.clone()))
             })
             .collect()
     };
@@ -211,19 +212,15 @@ fn corpus_closure_form_is_a_superset_and_measured() {
         explicit_bytes as f64 / pass_bytes as f64,
         implied_bytes as f64 / pass_bytes as f64
     );
-    // The implied heritage only adds.
+    // Implied redefinitions can remove previously inherited features.
+    // They must never remove a feature owned by the queried element.
     let more = by_id(&implied);
-    for (id, floor) in &implied_floor {
-        let m = more[id.as_str()];
-        for (name, b) in ["feature", "inheritedFeature"].iter().zip(floor) {
-            let (Some(b), Some(c2)) = (b, m.get(*name).and_then(|v| v.as_array())) else {
-                continue;
-            };
-            assert!(
-                c2.len() >= *b,
-                "{id}.{name} shrank with the implied heritage"
-            );
-        }
+    for (id, owned) in &owned_features {
+        let features = more[id.as_str()]["feature"].as_array().unwrap();
+        assert!(
+            contains_all(owned, features),
+            "{id}.feature lost an owned feature"
+        );
     }
 }
 
diff --git a/crates/sysmlv2-parser/tests/connector_bound_scopes.rs b/crates/sysmlv2-parser/tests/connector_bound_scopes.rs
new file mode 100644
index 0000000..a7956fb
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/connector_bound_scopes.rs
@@ -0,0 +1,78 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{json::ResolvedModel, model::Model};
+
+#[test]
+fn connector_bounds_use_body_members_without_recapturing_end_targets() {
+    let source = "package P {
+        item a; item b; attribute n = 99;
+        succession link first [n] a then [n] b { attribute n = 1; }
+        connection c connect [count] a to [count] b { attribute count = 2; }
+        succession outer first [n] a then [n] b;
+    }";
+    let mut model = Model::new();
+    model.add_source("bounds.sysml", source);
+    assert!(!model.has_errors(), "{:?}", model.units()[0].diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    assert!(
+        r.unresolved_references().is_empty(),
+        "{:?}",
+        r.unresolved_references()
+    );
+    let outer = r.resolve_qualified("P::n").unwrap();
+    assert_eq!(r.references_to(outer).len(), 2);
+    for name in ["P::link::n", "P::c::count"] {
+        let bound = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.references_to(bound).len(), 2, "{name}");
+    }
+    for name in ["P::a", "P::b"] {
+        let target = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.references_to(target).len(), 3, "{name}");
+    }
+}
+
+#[test]
+fn causation_library_end_bounds_resolve_body_variables() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let r = ResolvedModel::build(&model);
+    let failures: Vec<_> = r
+        .unresolved_references()
+        .into_iter()
+        .filter(|reference| {
+            model
+                .unit(reference.unit)
+                .name
+                .ends_with("CausationConnections.sysml")
+                && matches!(reference.spelling.as_str(), "nCauses" | "nEffects")
+        })
+        .collect();
+    assert!(failures.is_empty(), "{failures:?}");
+}
+
+#[test]
+fn prepared_connector_bounds_keep_local_resolution() {
+    let mut source = Model::new();
+    source.add_library_source(
+        "bounds.sysml",
+        "package L { item a; item b; succession link first [n] a then [n] b { attribute n = 1; } }",
+    );
+    let prepared = source.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(1).unwrap(), 1)
+            .unwrap(),
+    );
+    for library in [prepared, decoded] {
+        let mut model = Model::new();
+        library.install(&mut model).unwrap();
+        model.add_source("use.sysml", "attribute check = L::link::n;");
+        let r = ResolvedModel::build(&model);
+        assert!(
+            r.unresolved_references().is_empty(),
+            "{:?}",
+            r.unresolved_references()
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/connector_end_bindings.rs b/crates/sysmlv2-parser/tests/connector_end_bindings.rs
new file mode 100644
index 0000000..72c72f6
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/connector_end_bindings.rs
@@ -0,0 +1,138 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{
+    json::{ResolvedModel, model_resolution_report},
+    model::Model,
+};
+
+fn checked(source: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    model.add_source("ends.sysml", source);
+    assert!(!model.has_errors(), "{:?}", model.units()[0].diagnostics);
+    let report = model_resolution_report(&model);
+    assert!(report.unresolved.is_empty(), "{:?}", report.unresolved);
+    assert!(report.ambiguous.is_empty(), "{:?}", report.ambiguous);
+    ResolvedModel::build(&model)
+}
+
+#[test]
+fn declared_connector_ends_keep_context_over_inherited_end_names() {
+    for before in [true, false] {
+        let actual = "port actual : Composite { port pin1 :> pin; }";
+        let source = format!(
+            "package P {{
+                port def Pin;
+                port def Composite {{ port pin : Pin[*]; }}
+                interface def Fastener {{ end a: Pin; end b: Pin; }}
+                interface def Hub {{
+                    end left: Composite; end right: Composite;
+                    interface fastener : Fastener connect left.pin to right.pin;
+                }}
+                part assembly {{
+                    {}
+                    interface hub : Hub connect left ::> actual to right ::> actual {{
+                        interface f :> fastener connect a ::> left.pin1 to b ::> right.pin1;
+                    }}
+                    {}
+                }}
+            }}",
+            if before { actual } else { "" },
+            if before { "" } else { actual },
+        );
+        let mut resolved = checked(&source);
+        let hub = resolved.resolve_qualified("P::assembly::hub").unwrap();
+        let left = resolved
+            .resolve_qualified("P::assembly::hub::left")
+            .unwrap();
+        assert_eq!(resolved.owner(left), Some(hub));
+        assert_eq!(resolved.element_name(left), Some("left"));
+        let source_alias = resolved.resolve_qualified("P::assembly::hub::source");
+        assert_eq!(source_alias, Some(left));
+        let pin1 = resolved.resolve_qualified("P::assembly::actual::pin1");
+        assert_eq!(
+            resolved.resolve_qualified("P::assembly::hub::left::pin1"),
+            pin1,
+        );
+        assert!(pin1.is_some());
+    }
+}
+
+#[test]
+fn declared_end_bindings_cover_nary_connectors_and_override_fallback_names() {
+    let mut resolved = checked(
+        "package P {
+            part p { attribute value; }
+            connection binary connect left ::> p to source ::> p {
+                attribute a = left.value;
+                attribute b = source.value;
+                attribute c = target.value;
+            }
+            connection ternary connect (one ::> p, two ::> p, three ::> p) {
+                attribute a = one.value;
+                attribute b = two.value;
+                attribute c = three.value;
+            }
+            connection ordinary {
+                end <l> left ::> p;
+                end <r> right ::> p;
+                attribute a = l.value;
+                attribute b = right.value;
+            }
+        }",
+    );
+    let source = resolved.resolve_qualified("P::binary::source").unwrap();
+    assert_eq!(resolved.element_name(source), Some("source"));
+    assert_eq!(
+        resolved.resolve_qualified("P::binary::target"),
+        Some(source)
+    );
+    let one = resolved.resolve_qualified("P::ternary::one").unwrap();
+    let ternary = resolved.resolve_qualified("P::ternary").unwrap();
+    assert_eq!(resolved.owner(one), Some(ternary));
+    assert_eq!(resolved.resolve_qualified("P::ternary::source"), None);
+    assert_eq!(
+        resolved.resolve_qualified("P::ordinary::l"),
+        resolved.resolve_qualified("P::ordinary::left"),
+    );
+}
+
+#[test]
+fn standard_library_nested_interfaces_resolve_numbered_actual_ports() {
+    let corpus = sysmlv2_testkit::corpus_root();
+    let path = corpus
+        .join("sysml/src/examples/Vehicle Example/SysML v2 Spec Annex A SimpleVehicleModel.sysml");
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    model.add_source(
+        "nested-interfaces.sysml",
+        &std::fs::read_to_string(path).unwrap(),
+    );
+    assert!(!model.has_errors());
+    let mut resolved = ResolvedModel::build(&model);
+    let missing = resolved.unresolved_references();
+    for name in [
+        "lugNutPort1",
+        "lugNutPort2",
+        "lugNutPort3",
+        "shankPort1",
+        "shankPort2",
+        "shankPort3",
+    ] {
+        assert!(
+            !missing.iter().any(|reference| reference.spelling == name),
+            "{name}"
+        );
+    }
+    let base = "SimpleVehicleModel::VehicleConfigurations::WheelHubAssemblies::wheelHubAssy3";
+    let hub = resolved
+        .resolve_qualified(&format!("{base}::wheelHubInterface"))
+        .unwrap();
+    for end in ["lugNutCompositePort", "shankCompositePort"] {
+        let feature = resolved
+            .resolve_qualified(&format!("{base}::wheelHubInterface::{end}"))
+            .unwrap();
+        assert_eq!(resolved.owner(feature), Some(hub), "{end}");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/connector_relationship_ends.rs b/crates/sysmlv2-parser/tests/connector_relationship_ends.rs
new file mode 100644
index 0000000..5469cdf
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/connector_relationship_ends.rs
@@ -0,0 +1,346 @@
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json},
+    json::{
+        ClosurePolicy, Derived, DerivedValue, ElementRef, Reference, ResolvedModel,
+        model_to_compact_json,
+    },
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(source: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut library = Model::new();
+    library.add_library_source(
+        "connector-library.kerml",
+        "package L {feature a; feature b;}",
+    );
+    library.record_library_cache();
+    ResolvedModel::build(&library);
+    let cache =
+        LibraryCache::from_bytes(&library.take_recorded_library_cache().unwrap().to_bytes())
+            .unwrap();
+    let prepared = library.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(37).unwrap(), 37).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source(
+                        "connector-library.kerml",
+                        "package L {feature a; feature b;}",
+                    );
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(
+                model
+                    .add_source("connectors.sysml", source)
+                    .diagnostics
+                    .is_empty()
+            );
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn refs(r: &mut ResolvedModel, e: ElementRef, property: &str) -> Vec<Reference> {
+    match r.derived(e, property) {
+        Derived::Value(DerivedValue::References(values)) => values,
+        Derived::Value(DerivedValue::Reference(value)) => vec![value],
+        Derived::Value(DerivedValue::Null) => vec![],
+        other => panic!("{property}: {other:?}"),
+    }
+}
+
+fn policies() -> [ClosurePolicy; 3] {
+    [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ]
+}
+
+#[test]
+fn connector_generic_ends_agree_with_typed_projections_and_keep_repeated_related_features() {
+    let source = "package P {
+        part a; part b;
+        connection empty;
+        connection single {end one ::> a;}
+        connection binary connect a to b;
+        connection reflexive connect a to a;
+        connection ternary connect (a,b,a);
+        connection repeated connect (a,b,b);
+        connection imported connect L::a to L::b;
+    }";
+    for (model, mut r) in models(source) {
+        let loaded = model.loaded_library_unit_count();
+        let compact = model_to_compact_json(&model);
+        let a = Reference::Element(r.resolve_qualified("P::a").unwrap());
+        let b = Reference::Element(r.resolve_qualified("P::b").unwrap());
+        let la = Reference::Element(r.resolve_qualified("L::a").unwrap());
+        let lb = Reference::Element(r.resolve_qualified("L::b").unwrap());
+        let cases = [
+            ("empty", vec![], vec![]),
+            ("single", vec![a.clone()], vec![]),
+            ("binary", vec![a.clone(), b.clone()], vec![b.clone()]),
+            ("reflexive", vec![a.clone(), a.clone()], vec![a.clone()]),
+            (
+                "ternary",
+                vec![a.clone(), b.clone(), a.clone()],
+                vec![b.clone(), a.clone()],
+            ),
+            (
+                "repeated",
+                vec![a.clone(), b.clone(), b.clone()],
+                vec![b.clone()],
+            ),
+            ("imported", vec![la.clone(), lb.clone()], vec![lb.clone()]),
+        ];
+        for policy in policies() {
+            r.set_closure_policy(policy);
+            for (name, related, targets) in &cases {
+                let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+                let sources: Vec<_> = related.first().cloned().into_iter().collect();
+                assert_eq!(
+                    r.relationship_ends(e),
+                    (sources.clone(), targets.clone()),
+                    "{name}/{policy:?}"
+                );
+                assert_eq!(refs(&mut r, e, "sourceFeature"), sources);
+                assert_eq!(refs(&mut r, e, "targetFeature"), *targets);
+                assert_eq!(refs(&mut r, e, "relatedFeature"), *related);
+                assert_eq!(refs(&mut r, e, "relatedElement"), *related);
+                assert_eq!(
+                    r.derived_exact(e, "relatedElement"),
+                    Err(sysmlv2_parser::json::PropertyError::Approximate),
+                    "generic alias cannot certify more than relatedFeature"
+                );
+            }
+            let full = resolved_to_full_json(
+                &mut r,
+                &model,
+                EmissionPolicy {
+                    unresolved: UnresolvedReferencePolicy::Reject,
+                    closures: policy,
+                },
+            )
+            .unwrap();
+            let rows = full.as_array().unwrap();
+            for (name, related, targets) in &cases {
+                let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+                let row = rows
+                    .iter()
+                    .find(|row| row["@id"] == r.element_id(e).to_string())
+                    .unwrap();
+                let json_refs = |values: &[Reference]| {
+                    serde_json::Value::Array(
+                        values
+                            .iter()
+                            .map(|value| {
+                                let Reference::Element(element) = value else {
+                                    panic!("in-model fixture")
+                                };
+                                serde_json::json!({"@id":r.element_id(*element).to_string()})
+                            })
+                            .collect(),
+                    )
+                };
+                assert_eq!(row["source"], json_refs(&related[..related.len().min(1)]));
+                assert_eq!(row["target"], json_refs(targets));
+                assert_eq!(row["relatedElement"], json_refs(related));
+                assert_eq!(row["relatedFeature"], json_refs(related));
+                assert_eq!(row["targetFeature"], json_refs(targets));
+            }
+        }
+        assert_eq!(model_to_compact_json(&model), compact);
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn connector_generic_ends_follow_the_existing_inherited_end_policy() {
+    for (_, mut r) in models(
+        "package P {part a; part b; connection base connect a to b; connection child :> base;}",
+    ) {
+        let child = r.resolve_qualified("P::child").unwrap();
+        let a = Reference::Element(r.resolve_qualified("P::a").unwrap());
+        let b = Reference::Element(r.resolve_qualified("P::b").unwrap());
+        for policy in policies() {
+            r.set_closure_policy(policy);
+            let expected = if policy == ClosurePolicy::Passthrough {
+                vec![]
+            } else {
+                vec![a.clone(), b.clone()]
+            };
+            assert_eq!(refs(&mut r, child, "relatedElement"), expected);
+            assert_eq!(
+                r.derived_exact(child, "relatedElement"),
+                Err(sysmlv2_parser::json::PropertyError::Approximate)
+            );
+            assert_eq!(
+                r.relationship_ends(child),
+                (
+                    expected.first().cloned().into_iter().collect(),
+                    expected.into_iter().skip(1).collect()
+                )
+            );
+        }
+    }
+}
+
+#[test]
+fn connector_generic_ends_preserve_unresolved_reference_identity() {
+    for (model, mut r) in models(
+        "package P {part a; connection missing connect a to Absent; connection repeated connect (Absent,Absent,Absent);}",
+    ) {
+        for policy in policies() {
+            r.set_closure_policy(policy);
+            let e = r.resolve_qualified("P::missing").unwrap();
+            let a = Reference::Element(r.resolve_qualified("P::a").unwrap());
+            let missing = Reference::Unresolved("Absent".into());
+            assert_eq!(
+                r.derived_exact(e, "relatedElement"),
+                Err(sysmlv2_parser::json::PropertyError::Approximate)
+            );
+            assert_eq!(
+                r.relationship_ends(e),
+                (vec![a.clone()], vec![missing.clone()])
+            );
+            assert_eq!(refs(&mut r, e, "relatedElement"), vec![a, missing.clone()]);
+            let repeated = r.resolve_qualified("P::repeated").unwrap();
+            assert_eq!(
+                r.relationship_ends(repeated),
+                (vec![missing.clone()], vec![missing.clone()])
+            );
+            assert_eq!(
+                refs(&mut r, repeated, "relatedElement"),
+                vec![missing.clone(), missing.clone(), missing]
+            );
+            let full = resolved_to_full_json(
+                &mut r,
+                &model,
+                EmissionPolicy {
+                    unresolved: UnresolvedReferencePolicy::LegacyDanglingId,
+                    closures: policy,
+                },
+            )
+            .unwrap();
+            let row = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|row| row["@id"] == r.element_id(repeated).to_string())
+                .unwrap();
+            let target = row["relatedFeature"][0].clone();
+            assert_eq!(row["source"], serde_json::json!([target.clone()]));
+            assert_eq!(row["target"], serde_json::json!([target.clone()]));
+            assert_eq!(
+                row["relatedElement"],
+                serde_json::json!([target.clone(), target.clone(), target])
+            );
+        }
+    }
+}
+
+#[test]
+fn payload_endpoint_completion_preserves_supplied_owned_values() {
+    use std::collections::HashMap;
+    use sysmlv2_parser::full::from_compact_value;
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "payload.sysml",
+                "part a; part b; connection c connect (a,b,b);"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut resolved = ResolvedModel::build(&model);
+    let connector = resolved.resolve_qualified("c").unwrap();
+    let connector_id = resolved.element_id(connector).to_string();
+    let b = resolved.resolve_qualified("b").unwrap();
+    let compact = model_to_compact_json(&model);
+    let full = from_compact_value(compact.clone(), &HashMap::new(), true);
+    let by_id =
+        |value: &serde_json::Value| -> std::collections::BTreeMap<String, serde_json::Value> {
+            value
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|row| (row["@id"].as_str().unwrap().to_owned(), row.clone()))
+                .collect()
+        };
+    let expected = by_id(&full);
+    assert_eq!(
+        by_id(&from_compact_value(full.clone(), &HashMap::new(), true)),
+        expected
+    );
+    let mut missing = full;
+    let row = missing
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|row| row["@id"] == connector_id)
+        .unwrap()
+        .as_object_mut()
+        .unwrap();
+    row.remove("source");
+    row.remove("target");
+    assert_eq!(
+        by_id(&from_compact_value(missing, &HashMap::new(), true)),
+        expected
+    );
+
+    let mut supplied = compact;
+    let row = supplied
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|row| row["@id"] == connector_id)
+        .unwrap();
+    let source = serde_json::json!([{"@id":resolved.element_id(b).to_string()}]);
+    row["source"] = source.clone();
+    row["target"] = serde_json::json!([]);
+    let result = by_id(&from_compact_value(supplied, &HashMap::new(), true));
+    assert_eq!(result[&connector_id]["source"], source);
+    assert_eq!(result[&connector_id]["target"], serde_json::json!([]));
+}
+
+#[test]
+fn unrelated_relationship_fidelity_is_unchanged() {
+    use sysmlv2_parser::json::{Derives, derives_under};
+    for policy in policies() {
+        assert_eq!(
+            derives_under("Subsetting", "relatedElement", policy),
+            Derives::Exact
+        );
+        assert_eq!(
+            derives_under("Membership", "relatedElement", policy),
+            Derives::Exact
+        );
+        assert_eq!(
+            derives_under("ConnectionUsage", "relatedElement", policy),
+            Derives::Passthrough
+        );
+        assert_eq!(
+            derives_under("BindingConnector", "relatedElement", policy),
+            Derives::Passthrough
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/constructor_static_evaluation.rs b/crates/sysmlv2-parser/tests/constructor_static_evaluation.rs
new file mode 100644
index 0000000..6abc71e
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/constructor_static_evaluation.rs
@@ -0,0 +1,85 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+
+#[test]
+fn actual_library_constructor_ancestry_preserves_source_graph_and_no_owned_result_claim() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        eprintln!("skipping: standard library unavailable");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).unwrap();
+    assert!(model
+        .add_source(
+            "constructor-static.kerml",
+            "class Box { feature item; } feature empty=new Box(); feature filled=new Box(item=1);"
+        )
+        .diagnostics
+        .is_empty());
+    let compact = model_to_compact_json(&model);
+    let mut r = ResolvedModel::build(&model);
+    let expressions: Vec<_> = r
+        .user_elements()
+        .filter(|&e| r.element_type(e) == "ConstructorExpression")
+        .collect();
+    assert_eq!(expressions.len(), 2);
+    let target = r
+        .resolve_qualified("Performances::constructorEvaluations")
+        .unwrap();
+    let target_id = r.element_id(target).to_string();
+    let original_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let mut edges = Vec::new();
+        for &expression in &expressions {
+            let required: Vec<_> = r
+                .implied_relationships(expression)
+                .into_iter()
+                .filter(|&rel| {
+                    r.element_type(rel) == "Subsetting"
+                        && r.element_properties(rel)["subsettedFeature"]["@id"] == target_id
+                })
+                .collect();
+            assert_eq!(required.len(), 1);
+            assert!(matches!(
+                r.model_level_evaluability(expression).classification,
+                sysmlv2_parser::json::ModelLevelEvaluability::Unknown(_)
+            ));
+            edges.push(r.element_id(required[0]));
+            assert_eq!(
+                r.element_properties(required[0])["subsettingFeature"]["@id"],
+                r.element_id(expression).to_string()
+            );
+            assert!(
+                !r.owned_relationships(expression)
+                    .into_iter()
+                    .any(|rel| r.element_type(rel) == "ReturnParameterMembership")
+            );
+        }
+        if let Some(ref expected) = expected {
+            assert_eq!(&edges, expected);
+        } else {
+            expected = Some(edges);
+        }
+    }
+    assert_eq!(
+        original_ids,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(model_to_compact_json(&model), compact);
+}
diff --git a/crates/sysmlv2-parser/tests/corpus_identity.rs b/crates/sysmlv2-parser/tests/corpus_identity.rs
new file mode 100644
index 0000000..b6de638
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/corpus_identity.rs
@@ -0,0 +1,45 @@
+//! Corpus source labels must preserve identity even when basenames collide.
+#![cfg(feature = "json")]
+use std::collections::HashSet;
+use std::path::Path;
+use sysmlv2_parser::{json::model_to_compact_json, model::Model};
+
+fn compact_at(checkout: &Path) -> serde_json::Value {
+    let mut model = Model::new();
+    for relative in ["examples/model.sysml", "validation/model.sysml"] {
+        let path = checkout.join(relative);
+        let name = sysmlv2_testkit::relative_source_name(checkout, &path);
+        model.add_source(name, "package P { attribute x = 1; }");
+    }
+    assert!(!model.has_errors());
+    model_to_compact_json(&model)
+}
+
+#[test]
+fn same_basename_documents_have_distinct_root_and_descendant_ids() {
+    let compact = compact_at(Path::new("checkout-a"));
+    let rows = compact.as_array().unwrap();
+    let ids: HashSet<_> = rows
+        .iter()
+        .map(|row| row["@id"].as_str().unwrap())
+        .collect();
+    assert_eq!(
+        ids.len(),
+        rows.len(),
+        "no document or descendant identity is aliased"
+    );
+    let roots: Vec<_> = rows
+        .iter()
+        .filter(|row| row["@type"] == "Namespace")
+        .collect();
+    assert_eq!(roots.len(), 2);
+    assert_ne!(roots[0]["@id"], roots[1]["@id"]);
+}
+
+#[test]
+fn relocating_a_checkout_preserves_relative_source_identity() {
+    assert_eq!(
+        compact_at(Path::new("checkout-a")),
+        compact_at(Path::new("checkout-b"))
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/cross_feature_scopes.rs b/crates/sysmlv2-parser/tests/cross_feature_scopes.rs
new file mode 100644
index 0000000..f402b91
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/cross_feature_scopes.rs
@@ -0,0 +1,157 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{
+    json::{Reference, ResolvedModel},
+    model::{GraphFormat, Model},
+};
+
+const FORMATS: [GraphFormat; 2] = [GraphFormat::LegacyV2, GraphFormat::CanonicalV3];
+
+const SOURCE: &str = "package P {
+    class A { feature leaf; }
+    class B { feature leaf; feature count; }
+    feature leaf; feature count;
+    assoc Pair {
+        end feature a : A;
+        end cross [count] subsets leaf feature b : B;
+    }
+    assoc Derived specializes Pair {
+        end feature a redefines Pair::a;
+        end inheritedCross subsets leaf feature b redefines Pair::b;
+    }
+}";
+
+fn assert_cross_targets(model: &Model, source_sites: bool) {
+    let mut resolved = ResolvedModel::build(model);
+    assert!(
+        resolved.unresolved_references().is_empty(),
+        "{:?}",
+        resolved.unresolved_references()
+    );
+    for (name, count) in [
+        ("P::B::leaf", 2),
+        ("P::B::count", 1),
+        ("P::A::leaf", 0),
+        ("P::leaf", 0),
+        ("P::count", 0),
+    ] {
+        let target = resolved.resolve_qualified(name).unwrap();
+        let sites = resolved.references_to(target);
+        assert_eq!(
+            sites.len(),
+            if source_sites { count } else { 0 },
+            "{name}: {sites:?}"
+        );
+        for site in sites {
+            assert_eq!(
+                &SOURCE[site.name_span.start as usize..site.name_span.end as usize],
+                name.rsplit("::").next().unwrap()
+            );
+        }
+    }
+    let leaf = resolved.resolve_qualified("P::B::leaf").unwrap();
+    for name in ["P::Pair::b", "P::Derived::b"] {
+        let end = resolved.resolve_qualified(name).unwrap();
+        let cross = resolved
+            .owned_members(end)
+            .into_iter()
+            .find(|&member| resolved.element_type(member) == "ReferenceUsage")
+            .unwrap();
+        let subset = resolved
+            .owned_relationships(cross)
+            .into_iter()
+            .find(|&rel| resolved.element_type(rel) == "Subsetting")
+            .unwrap();
+        assert_eq!(
+            resolved.relationship_ends(subset).1,
+            vec![Reference::Element(leaf)]
+        );
+    }
+}
+
+#[test]
+fn cross_feature_references_use_the_owning_end_scope() {
+    for format in FORMATS {
+        let mut model = Model::with_graph_format(format);
+        model.add_source("cross.kerml", SOURCE);
+        assert!(!model.has_errors(), "{:?}", model.units()[0].diagnostics);
+        assert_cross_targets(&model, true);
+    }
+}
+
+#[test]
+fn prepared_cross_feature_scope_survives_serialization() {
+    for format in FORMATS {
+        let mut model = Model::with_graph_format(format);
+        model.add_library_source("cross.kerml", SOURCE);
+        let prepared = model.prepare_library().unwrap();
+        let decoded = std::sync::Arc::new(
+            sysmlv2_parser::prepared::PreparedLibrary::from_bytes(
+                &prepared.to_bytes(1).unwrap(),
+                1,
+            )
+            .unwrap(),
+        );
+        for library in [prepared, decoded] {
+            let mut model = Model::with_graph_format(format);
+            library.install(&mut model).unwrap();
+            assert_cross_targets(&model, false);
+        }
+    }
+}
+
+#[test]
+fn cross_feature_missing_and_ambiguous_members_stay_unresolved() {
+    for format in FORMATS {
+        for source in [
+            "package P { class A { feature leaf; } class B; assoc Pair { end feature a : A; end cross subsets leaf feature b : B; } }",
+            "package P { feature leaf; class A { feature leaf; } class B { feature leaf; } class C specializes A, B; assoc Pair { end cross subsets leaf feature c : C; } }",
+        ] {
+            let mut model = Model::with_graph_format(format);
+            model.add_source("unresolved.kerml", source);
+            assert!(!model.has_errors(), "{:?}", model.units()[0].diagnostics);
+            let resolved = ResolvedModel::build(&model);
+            let failures = resolved.unresolved_references();
+            assert_eq!(failures.len(), 1, "{failures:?}");
+            assert_eq!(failures[0].spelling, "leaf");
+        }
+    }
+}
+
+#[test]
+fn occurrence_library_cross_feature_members_resolve_after_replay() {
+    for format in FORMATS {
+        let mut source = Model::with_graph_format(format);
+        source
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        let prepared = source.prepare_library().unwrap();
+        let decoded = std::sync::Arc::new(
+            sysmlv2_parser::prepared::PreparedLibrary::from_bytes(
+                &prepared.to_bytes(1).unwrap(),
+                1,
+            )
+            .unwrap(),
+        );
+        let mut models = vec![source];
+        for library in [prepared, decoded] {
+            let mut model = Model::with_graph_format(format);
+            library.install(&mut model).unwrap();
+            models.push(model);
+        }
+        for model in models {
+            let resolved = ResolvedModel::build(&model);
+            let failures: Vec<_> = resolved
+                .unresolved_references()
+                .into_iter()
+                .filter(|reference| {
+                    model
+                        .unit(reference.unit)
+                        .name
+                        .ends_with("Occurrences.kerml")
+                })
+                .collect();
+            assert!(failures.is_empty(), "{failures:?}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/default_featuring_identity.rs b/crates/sysmlv2-parser/tests/default_featuring_identity.rs
new file mode 100644
index 0000000..9b59001
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/default_featuring_identity.rs
@@ -0,0 +1,151 @@
+//! Specialization identity in connector featuring compatibility reads.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{Derived, DerivedValue, PropertyError, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+use uuid::Uuid;
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn default(r: &mut ResolvedModel, name: &str) -> Option<sysmlv2_parser::json::ElementRef> {
+    let connector = r.resolve_qualified(name).unwrap();
+    assert_eq!(
+        r.property(connector, "defaultFeaturingType"),
+        Err(PropertyError::Approximate)
+    );
+    match r.derived(connector, "defaultFeaturingType") {
+        Derived::Value(DerivedValue::Element(value)) => Some(value),
+        Derived::Value(DerivedValue::Null) => None,
+        other => panic!("unexpected default featuring value: {other:?}"),
+    }
+}
+#[test]
+fn conjugated_and_ordinary_specializations_preserve_default_featuring_identity() {
+    let library = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} class A {feature x; feature y;}";
+    let user = "class B conjugates A {feature y; connector c from A::x to y;} class C specializes A {feature z; connector c from A::x to z;} class D conjugates B {feature q; connector c from A::x to q;} class E specializes B {feature r; connector c from A::x to r;}";
+    for (model, mut r) in models(library, user) {
+        let loaded = model.loaded_library_unit_count();
+        for _ in 0..2 {
+            for name in ["C", "E"] {
+                let expected = r.resolve_qualified(name).unwrap();
+                assert_eq!(default(&mut r, &format!("{name}::c")), Some(expected));
+            }
+            // A conjugated receiver delegates specializes before reflexivity:
+            // A does not specialize B or D, so neither is a common context.
+            for name in ["B", "D"] {
+                assert_eq!(default(&mut r, &format!("{name}::c")), None);
+            }
+        }
+        let a = r.resolve_qualified("A").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(a), Uuid::new_v4())]));
+        let e = r.resolve_qualified("E").unwrap();
+        assert_eq!(default(&mut r, "E::c"), Some(e));
+        assert_eq!(default(&mut r, "B::c"), None);
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+#[test]
+fn missing_owned_featuring_evidence_cannot_select_a_default() {
+    let library = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} class A;";
+    let user = "class Good {feature x; feature y; connector c from x to y;} class MissingFeaturing {feature x featured by Missing; feature y; connector c from x to y;} class ExternalBase specializes Missing {feature x; feature y; connector c from x to y;}";
+    for (_, mut r) in models(library, user) {
+        let expected = r.resolve_qualified("Good").unwrap();
+        assert_eq!(default(&mut r, "Good::c"), Some(expected));
+        assert_eq!(default(&mut r, "MissingFeaturing::c"), None);
+        // Reflexive compatibility remains a witness even if an unrelated
+        // superclass is unavailable. Strict property access still refuses.
+        let expected = r.resolve_qualified("ExternalBase").unwrap();
+        assert_eq!(default(&mut r, "ExternalBase::c"), Some(expected));
+    }
+}
+
+#[test]
+fn inverse_type_featuring_is_not_omitted_from_common_contexts() {
+    let library = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}";
+    for (_, mut r) in models(
+        library,
+        "class B; class A {feature x; feature y; connector c from x to y;} featuring A::x by B;",
+    ) {
+        assert_eq!(default(&mut r, "A::c"), None);
+    }
+}
+#[test]
+fn a_missing_required_library_hierarchy_does_not_prove_candidate_absence() {
+    for (_, mut r) in models(
+        "class A {feature x;}",
+        "class B conjugates A {feature y; connector c from A::x to y;}",
+    ) {
+        assert_eq!(default(&mut r, "B::c"), None);
+    }
+}
+
+#[test]
+fn unaudited_sysml_compatibility_domain_retains_existing_defaults() {
+    let source = "package P { part def Wheel { port hub; } part def Axle {port end_;} part def Car {part w:Wheel; part ax:Axle; connection c1 connect w to ax; connection c2 connect w.hub to ax.end_; part inner {part x;part y;connection c3 connect x to y;}} part car:Car;connection top connect car.w to car.ax;}";
+    for (_, mut r) in models_named("class A;", source, "compat.sysml") {
+        let car = r.resolve_qualified("P::Car").unwrap();
+        let inner = r.resolve_qualified("P::Car::inner").unwrap();
+        assert_eq!(default(&mut r, "P::Car::c1"), Some(car));
+        assert_eq!(default(&mut r, "P::Car::c2"), Some(car));
+        assert_eq!(default(&mut r, "P::Car::inner::c3"), Some(inner));
+        assert_eq!(default(&mut r, "P::top"), None);
+    }
+}
+
+#[test]
+fn materialized_implied_ownership_preserves_featuring_proofs_and_id_overrides() {
+    let library = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;}";
+    let source =
+        "class A {feature x;} class C specializes A {feature y; connector c from A::x to y;}";
+    for (model, mut r) in models(library, source) {
+        let loaded = model.loaded_library_unit_count();
+        let a = r.resolve_qualified("A").unwrap();
+        let c = r.resolve_qualified("C").unwrap();
+        assert_eq!(default(&mut r, "C::c"), Some(c));
+        assert!(!r.implied_relationships(a).is_empty());
+        assert_eq!(default(&mut r, "C::c"), Some(c));
+        r.override_ids(&HashMap::from([(r.element_id(a), Uuid::new_v4())]));
+        assert_eq!(default(&mut r, "C::c"), Some(c));
+        r.implied_relationships(a);
+        assert_eq!(default(&mut r, "C::c"), Some(c));
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/derived_api.rs b/crates/sysmlv2-parser/tests/derived_api.rs
index 1776fcb..f2da7fb 100644
--- a/crates/sysmlv2-parser/tests/derived_api.rs
+++ b/crates/sysmlv2-parser/tests/derived_api.rs
@@ -462,7 +462,11 @@ fn definition_back_references_follow_the_declared_type() {
     let go = elem(&mut r, "P::go");
     let god = elem(&mut r, "P::Go");
     assert_eq!(many(&mut r, go, "actionDefinition"), [god]);
-    assert_eq!(derives("ActionUsage", "actionDefinition"), Derives::Exact);
+    // Definition filters inherit the qualified type projection.
+    assert_eq!(
+        derives("ActionUsage", "actionDefinition"),
+        Derives::Passthrough
+    );
     // A composition over a passthrough base is passthrough; the same
     // name on FlowDefinition is another property (`associationEnd`).
     assert_eq!(derives("FlowUsage", "flowEnd"), Derives::Passthrough);
@@ -556,10 +560,13 @@ fn a_composition_is_not_computed_where_its_base_is_another_property() {
     // Compositions over the owned relationships are exact.
     assert_eq!(derives("PartDefinition", "ownedDisjoining"), Derives::Exact);
     assert_eq!(derives("PartUsage", "nestedEnumeration"), Derives::Exact);
-    assert_eq!(derives("PortUsage", "portDefinition"), Derives::Exact);
+    // This filter depends on type, rather than only owned relationships.
+    assert_eq!(derives("PortUsage", "portDefinition"), Derives::Passthrough);
+    // The typing's same-named single reference follows the conjugated
+    // definition's original, independently of the usage composition.
     assert_eq!(
         derives("ConjugatedPortTyping", "portDefinition"),
-        Derives::NotComputed
+        Derives::Exact
     );
 }
 
@@ -656,7 +663,7 @@ fn string(r: &mut ResolvedModel, e: ElementRef, name: &str) -> Option<String> {
 
 /// `Element::name` / `shortName` / `qualifiedName` per KerML 8.2.3.5: an
 /// unnamed feature is named by the feature it redefines (recursively),
-/// references, or chains to; `qualifiedName` falls back to the short name
+/// or references under SysML naming rules; `qualifiedName` falls back to the short name
 /// where `name` does not.
 #[test]
 fn names_follow_the_naming_feature() {
@@ -844,13 +851,13 @@ fn qualified_name_needs_a_membership_chain() {
     let c = elem(&mut r, "P::c");
     let end = many(&mut r, c, "ownedEndFeature")[0];
     // The end references a chain feature it owns through the
-    // ReferenceSubsetting; the chain is named by its last link but has
-    // no owning namespace.
+    // ReferenceSubsetting; the anonymous chain has neither a name nor
+    // an owning namespace.
     let chain = many(&mut r, end, "ownedElement")
         .into_iter()
         .find(|&e| r.element_type(e) == "Feature" || r.element_type(e) == "ReferenceUsage")
         .expect("chain feature");
-    assert_eq!(string(&mut r, chain, "name").as_deref(), Some("mass"));
+    assert_eq!(string(&mut r, chain, "name"), None);
     assert_eq!(string(&mut r, chain, "qualifiedName"), None);
     assert_eq!(r.element_qualified_name(chain), None);
     // The reference spelling joins the lookup names, not the
@@ -941,6 +948,39 @@ fn references_outside_the_model_are_reported() {
 /// and carry the endpoint families like any relationship — while the
 /// explicit graph the resolver and lints iterate stays as built. None
 /// exist for a model whose library bases are unknown.
+/// A parameter, end or result redefines its general's by position, and
+/// `type` follows that implied redefinition as it follows a written one.
+#[test]
+fn a_positional_redefinition_types_the_redefining_feature() {
+    let src = "package P {
+            part def P1; part def P2;
+            action def A { in p : P1; in q : P2; }
+            action def Swapped :> A { in q; in p; }
+            action def Renamed :> A { in x :>> p; in y; }
+            action swappedUse : A { in q; in p; }
+            calc def C1 { in i; return r : P1; }
+            calc def C2 :> C1 { return s; }
+            connection def Conn { end e1 : P1; end e2 : P2; }
+            connection def Conn2 :> Conn { end f1; end f2; }
+        }";
+    let mut r = build(src);
+    let p1 = elem(&mut r, "P::P1");
+    let p2 = elem(&mut r, "P::P2");
+    for (feature, expected) in [
+        ("P::Swapped::q", p1),
+        ("P::Swapped::p", p2),
+        ("P::Renamed::x", p1),
+        ("P::Renamed::y", p2),
+        ("P::swappedUse::q", p1),
+        ("P::C2::s", p1),
+        ("P::Conn2::f1", p1),
+        ("P::Conn2::f2", p2),
+    ] {
+        let f = elem(&mut r, feature);
+        assert_eq!(many(&mut r, f, "type"), vec![expected], "{feature}");
+    }
+}
+
 #[test]
 fn implied_relationships_are_materialized_on_demand() {
     let src = "package P {
@@ -1242,7 +1282,7 @@ fn members_and_qualified_names_through_unnamed_owners() {
     assert_eq!(string(&mut r, child, "qualifiedName"), None);
 }
 
-// ---- M33f: behavior, expression, requirement and view structure ----
+// ---- behavior, expression, requirement and view structure ----
 
 /// States and transitions: the sub-actions by membership kind; the
 /// transition's trigger, guard, effect, succession, source and target.
@@ -1593,7 +1633,8 @@ fn requirement_case_and_view_structure() {
     assert_eq!(one(&mut r, filter_m, "condition"), Some(conditions[0]));
     let v1 = elem(&mut r, "P::v1");
     let exposed = many(&mut r, v1, "exposedElement");
-    assert!(exposed.contains(&car));
+    // VD's inherited condition applies to v1; car has no Safety metadata.
+    assert!(!exposed.contains(&car));
     let vp = elem(&mut r, "P::VP");
     let sfv = elem(&mut r, "P::VP::sfv");
     assert_eq!(many(&mut r, vp, "framedConcern"), vec![sfv]);
@@ -1883,7 +1924,7 @@ fn chained_references_in_behavior_and_cases() {
     assert_eq!(one(&mut r, vd, "viewRendering"), Some(as_tree));
 }
 
-// ---- M33g: type operations, association types, featuring, evaluability ----
+// ---- type operations, association types, featuring, evaluability ----
 
 /// Unioning, intersecting and differencing types and their relationship
 /// ends; an association's related, source and target types.
@@ -2018,7 +2059,7 @@ fn model_level_evaluability() {
     );
 }
 
-// ---- M33h: the closures and the inheritance-aware switch ----
+// ---- the closures and the inheritance-aware switch ----
 
 /// The four closure names answer through the resolver's walks whatever
 /// the policy; under the closure policy the inheritance-aware families
@@ -2090,8 +2131,7 @@ fn closures_and_the_inheritance_aware_switch() {
     assert!(u_memberships.contains(&imported[0]));
     assert!(refs(&mut r, u, "member").contains(&Reference::Element(own)));
     // The written-heritage tier stays passthrough; the closure with the
-    // implied heritage is the specification's value, except for the three
-    // approximations.
+    // implied heritage still has incomplete semantic dependencies.
     let written = ClosurePolicy::Closure {
         include_implied: false,
     };
@@ -2104,11 +2144,11 @@ fn closures_and_the_inheritance_aware_switch() {
     );
     assert_eq!(
         derives_under("PartDefinition", "feature", full),
-        Derives::Exact
+        Derives::Passthrough
     );
     assert_eq!(
         derives_under("PartDefinition", "inheritedMembership", full),
-        Derives::Exact
+        Derives::Passthrough
     );
     assert_eq!(
         derives_under("OperatorExpression", "isModelLevelEvaluable", full),
@@ -2123,10 +2163,10 @@ fn closures_and_the_inheritance_aware_switch() {
     assert_eq!(many(&mut r, w, "feature"), vec![extra]);
 }
 
-/// A heritage deeper than the resolver's budget is reported, never
-/// presented as a complete closure.
+/// Iterative inheritance has no depth cap; bounded import traversal
+/// still reports a cut rather than presenting it as a complete closure.
 #[test]
-fn a_deep_heritage_reports_truncation() {
+fn deep_heritage_completes_while_deep_imports_report_truncation() {
     use sysmlv2_parser::json::ClosurePolicy;
     let mut src = String::from("package P { part def D0 { attribute a0; }");
     for i in 1..=26 {
@@ -2141,11 +2181,12 @@ fn a_deep_heritage_reports_truncation() {
     r.set_closure_policy(ClosurePolicy::Closure {
         include_implied: false,
     });
-    assert!(r.closure_truncated(deep));
+    assert!(!r.closure_truncated(deep));
+    assert_eq!(many(&mut r, deep, "feature").len(), 27);
     let shallow = elem(&mut r, "P::D3");
     assert!(!r.closure_truncated(shallow));
     assert_eq!(many(&mut r, shallow, "feature").len(), 4);
-    // The import walk has the same budget.
+    // The import walk retains its bounded traversal.
     let mut src = String::from("package P { package I0 { part x; }");
     for i in 1..=26 {
         src.push_str(&format!(" package I{i} {{ public import I{}::*; }}", i - 1));
@@ -2297,3 +2338,230 @@ fn computable_names_are_the_computed_names_the_gate_admits() {
     // A metaclass outside the catalog has no computable names.
     assert!(r.computable_names("NoSuchMetaclass").is_empty());
 }
+
+#[test]
+fn implied_specializations_follow_reachability_and_preserve_existing_ids() {
+    let mut model = Model::new();
+    for (file, source) in [
+        (
+            "parts.kerml",
+            "standard library package Parts { class Part; feature parts : Part; }",
+        ),
+        (
+            "items.kerml",
+            "standard library package Items { class Item; feature items : Item; }",
+        ),
+    ] {
+        let unit = model.add_library_source(file, source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    }
+    let unit = model.add_source(
+        "model.sysml",
+        "package P {
+        item def Other;
+        part def Broken :> Other;
+        part def Good :> Base;
+        part def Base;
+        part def CycleA :> CycleB;
+        part def CycleB :> CycleA;
+        variation part def Choice { variant part bySub : Sub; }
+        part def Sub :> Choice;
+        variation part a { variant part b :> middle; }
+        part middle :> a;
+        item unrelated;
+        variation part def Choice2 { variant part pick :> unrelated; }
+    }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    let part = elem(&mut r, "Parts::Part");
+    let broken = elem(&mut r, "P::Broken");
+    let good = elem(&mut r, "P::Good");
+    let cycle_a = elem(&mut r, "P::CycleA");
+    let cycle_b = elem(&mut r, "P::CycleB");
+    let by_sub = elem(&mut r, "P::Choice::bySub");
+    let choice = elem(&mut r, "P::Choice");
+    let b = elem(&mut r, "P::a::b");
+    let a = elem(&mut r, "P::a");
+    let pick = elem(&mut r, "P::Choice2::pick");
+    let choice2 = elem(&mut r, "P::Choice2");
+    let original_owned = r.owned_relationships(pick);
+    let original_elements: Vec<_> = r.user_elements().collect();
+
+    assert!(
+        !r.conforms(broken, part),
+        "the existing limited query remains compatible"
+    );
+    assert!(r.conforms_with_implied(broken, part));
+    let broken_edges = r.implied_relationships(broken);
+    assert_eq!(
+        broken_edges.len(),
+        1,
+        "an unrelated subclassification does not cover Parts::Part"
+    );
+    assert_eq!(
+        r.relationship_ends(broken_edges[0]).1,
+        vec![Reference::Element(part)]
+    );
+    assert!(
+        r.implied_relationships(good).is_empty(),
+        "an explicit path through Base already reaches its required library base"
+    );
+    assert!(r.conforms_with_implied(good, part));
+    assert!(r.conforms_with_implied(cycle_a, part));
+    assert!(r.conforms_with_implied(cycle_b, part));
+    assert_eq!(
+        r.implied_relationships(cycle_a).len() + r.implied_relationships(cycle_b).len(),
+        1,
+        "an explicit cycle retains one required library anchor"
+    );
+    assert!(r.conforms_with_implied(by_sub, choice));
+    for edge in r.implied_relationships(by_sub) {
+        assert_ne!(
+            r.element_type(edge),
+            "FeatureTyping",
+            "indirect typing already specializes the variation"
+        );
+    }
+    assert!(r.conforms_with_implied(b, a));
+    for edge in r.implied_relationships(b) {
+        assert_ne!(
+            r.relationship_ends(edge).1,
+            vec![Reference::Element(a)],
+            "indirect subsetting already specializes the variation"
+        );
+    }
+    let pick_edges = r.implied_relationships(pick);
+    assert_eq!(
+        pick_edges.len(),
+        2,
+        "new required base coexists with existing variant typing"
+    );
+    let typing = pick_edges
+        .into_iter()
+        .find(|&e| r.element_type(e) == "FeatureTyping")
+        .unwrap();
+    assert_eq!(
+        r.relationship_ends(typing).1,
+        vec![Reference::Element(choice2)]
+    );
+    let old_id = uuid::Uuid::new_v5(
+        &uuid::Uuid::NAMESPACE_OID,
+        format!("{}/implied0", r.element_id(pick)).as_bytes(),
+    );
+    assert_eq!(
+        r.element_id(typing),
+        old_id,
+        "inserting a newly required base must not renumber the existing typing"
+    );
+    assert_eq!(r.owned_relationships(pick), original_owned);
+    assert_eq!(r.user_elements().collect::<Vec<_>>(), original_elements);
+    let old_part_id = r.element_id(part);
+    let new_part_id = uuid::Uuid::new_v4();
+    r.override_ids(&std::collections::HashMap::from([
+        (old_part_id, new_part_id),
+        (r.element_id(broken), uuid::Uuid::new_v4()),
+    ]));
+    assert!(r.conforms_with_implied(broken, part));
+    assert_eq!(r.element_by_id(&new_part_id.to_string()), Some(part));
+    assert_eq!(r.element_by_id(&old_part_id.to_string()), None);
+}
+
+#[test]
+fn implied_reachability_is_independent_of_declaration_order() {
+    for reverse in [false, true] {
+        let mut declarations = vec!["part def T0;".to_string()];
+        for i in 1..256 {
+            declarations.push(format!("part def T{i} :> T{};", i - 1));
+        }
+        declarations.extend(["part def A :> B;".into(), "part def B :> A;".into()]);
+        if reverse {
+            declarations.reverse();
+        }
+        let mut model = Model::new();
+        model.add_library_source(
+            "parts.kerml",
+            "standard library package Parts { class Part; }",
+        );
+        let unit = model.add_source(
+            "chain.sysml",
+            &format!("package P {{ {} }}", declarations.join("\n")),
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let mut r = ResolvedModel::build(&model);
+        let part = elem(&mut r, "Parts::Part");
+        for name in ["T0", "T255", "A", "B"] {
+            let e = elem(&mut r, &format!("P::{name}"));
+            assert!(
+                r.conforms_with_implied(e, part),
+                "{name}, reverse={reverse}"
+            );
+        }
+        let mut count = 0;
+        for i in 0..256 {
+            let e = elem(&mut r, &format!("P::T{i}"));
+            count += r.implied_relationships(e).len();
+        }
+        assert_eq!(count, 1, "one library anchor suffices for the chain");
+    }
+}
+
+#[test]
+fn multiple_required_library_bases_are_covered_individually() {
+    let mut model = Model::new();
+    model.add_library_source(
+        "actions.kerml",
+        "standard library package Actions { feature transitionActions; }",
+    );
+    model.add_library_source(
+        "states.kerml",
+        "standard library package States { feature stateTransitions; }",
+    );
+    let unit = model.add_source(
+        "transition.sysml",
+        "package P { state a; state b; transition t first a then b; }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let relation = model.add_source(
+        "relation.kerml",
+        "subset P::t subsets Actions::transitionActions;",
+    );
+    assert!(
+        relation.diagnostics.is_empty(),
+        "{:?}",
+        relation.diagnostics
+    );
+    let mut r = ResolvedModel::build(&model);
+    let t = elem(&mut r, "P::t");
+    let actions = elem(&mut r, "Actions::transitionActions");
+    let states = elem(&mut r, "States::stateTransitions");
+    let edges = r.implied_relationships(t);
+    assert_eq!(
+        edges.len(),
+        1,
+        "the written action base does not cover the state base"
+    );
+    assert_eq!(
+        r.relationship_ends(edges[0]).1,
+        vec![Reference::Element(states)]
+    );
+    assert!(r.conforms_with_implied(t, actions));
+    assert!(r.conforms_with_implied(t, states));
+}
+
+#[test]
+fn implied_reachability_refreshes_after_binding_uuid_references() {
+    let target_id = uuid::Uuid::new_v4();
+    let mut r = build(&format!(
+        "package P {{ part def Target; part def Source :> '{target_id}'; }}"
+    ));
+    let source = elem(&mut r, "P::Source");
+    let target = elem(&mut r, "P::Target");
+    r.override_ids(&std::collections::HashMap::from([(
+        r.element_id(target),
+        target_id,
+    )]));
+    assert!(!r.conforms_with_implied(source, target));
+    assert!(r.bind_id_spelled_references().contains(&target_id));
+    assert!(r.conforms_with_implied(source, target));
+}
diff --git a/crates/sysmlv2-parser/tests/distinguishability.rs b/crates/sysmlv2-parser/tests/distinguishability.rs
index 47aa5ef..fbadc7b 100644
--- a/crates/sysmlv2-parser/tests/distinguishability.rs
+++ b/crates/sysmlv2-parser/tests/distinguishability.rs
@@ -86,7 +86,7 @@ fn short_names_share_the_name_space() {
 }
 
 #[test]
-fn a_usage_typed_by_the_offending_definition_inherits_both() {
+fn a_usage_inherits_the_filtered_definition_members() {
     let out = findings(
         "package P {
             private import ScalarValues::*;
@@ -95,9 +95,9 @@ fn a_usage_typed_by_the_offending_definition_inherits_both() {
             attribute def LanStatus { attribute m1 : M1SwitchStatus; }
         }",
     );
-    assert_eq!(out.len(), 2, "{out:?}");
+    assert_eq!(out.len(), 1, "{out:?}");
     assert!(
-        out.iter().any(|m| m.starts_with(
+        !out.iter().any(|m| m.starts_with(
             "`downlinkPort` is inherited from both `M1SwitchStatus` and `SwitchStatus`"
         )),
         "{out:?}"
@@ -271,11 +271,11 @@ fn a_chain_names_the_nearest_declaring_type() {
             part c : C;
         }",
     );
-    assert_eq!(out.len(), 3, "{out:?}");
+    assert_eq!(out.len(), 2, "{out:?}");
     assert!(out.contains(&"`x` duplicates the inherited member name from `A` — redefine it (`:>>`) or rename it [validateNamespaceDistinguishibility]".to_string()), "{out:?}");
     assert!(out.contains(&"`x` duplicates the inherited member name from `B` — redefine it (`:>>`) or rename it [validateNamespaceDistinguishibility]".to_string()), "{out:?}");
     assert!(
-        out.iter()
+        !out.iter()
             .any(|m| m.starts_with("`x` is inherited from both")),
         "{out:?}"
     );
@@ -361,6 +361,54 @@ fn parameters_redefine_positionally_only_under_behaviors() {
     );
 }
 
+#[test]
+fn a_parameter_reusing_the_name_of_one_at_another_position_is_reported() {
+    // Positions pair the parameters: `Partial::b` redefines `Diff::a`, so
+    // `Diff::b` is still inherited and its name reused; `Swapped` redefines
+    // both; `Same` pairs each name with itself.
+    let out = findings(
+        "package P {
+            private import ScalarValues::*;
+            calc def Diff { in a : Real; in b : Real; }
+            calc def Partial :> Diff { in b : Real; }
+            calc def Swapped :> Diff { in b : Real; in a : Real; }
+            calc def Same :> Diff { in a : Real; in b : Real; }
+            action def Act { in x : Real; in y : Real; }
+            action def ActPartial :> Act { in y : Real; }
+        }",
+    );
+    assert_eq!(out.len(), 2, "{out:?}");
+    assert!(
+        out[0].starts_with("`b` duplicates the inherited member name from `Diff`"),
+        "{out:?}"
+    );
+    assert!(
+        out[1].starts_with("`y` duplicates the inherited member name from `Act`"),
+        "{out:?}"
+    );
+}
+
+#[test]
+fn a_result_named_like_one_of_two_inherited_results_is_reported() {
+    // `C1` inherits two results from unrelated generals, so its heritage
+    // does not say which one `D1`'s result redefines: it redefines neither,
+    // and reusing `r` is the collision.
+    let out = findings(
+        "package P {
+            private import ScalarValues::*;
+            calc def A1 { return r : Real; }
+            calc def B1 { return s : Real; }
+            calc def C1 :> A1, B1;
+            calc def D1 :> C1 { return r : Real; }
+        }",
+    );
+    assert_eq!(out.len(), 1, "{out:?}");
+    assert!(
+        out[0].starts_with("`r` duplicates the inherited member name from `A1`"),
+        "{out:?}"
+    );
+}
+
 #[test]
 fn library_features_collide_with_user_usages_and_kerml_features() {
     // The usage is typed by `B`, so its own body inherits both `portions`
diff --git a/crates/sysmlv2-parser/tests/dynamic_invocations.rs b/crates/sysmlv2-parser/tests/dynamic_invocations.rs
new file mode 100644
index 0000000..fcdf861
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/dynamic_invocations.rs
@@ -0,0 +1,91 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ModelLevelEvaluability, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+
+#[test]
+fn public_dynamic_callee_and_argument_edges_preserve_source_and_report_qualification() {
+    let mut model = Model::new();
+    assert!(model.add_source("dynamic-sdk.kerml", "function F {in p; return result;} feature callee {feature nested;} feature call=F(1); feature other=callee();").diagnostics.is_empty());
+    let compact = model_to_compact_json(&model);
+    let mut r = ResolvedModel::build(&model);
+    let calls: Vec<_> = r
+        .user_elements()
+        .filter(|&e| r.element_type(e) == "InvocationExpression")
+        .collect();
+    assert_eq!(calls.len(), 2);
+    let f = r.resolve_qualified("F").unwrap();
+    let p = r.resolve_qualified("F::p").unwrap();
+    let callee = r.resolve_qualified("callee").unwrap();
+    let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let mut edges = Vec::new();
+        for (&call, (kind, target, key)) in calls.iter().zip([
+            ("FeatureTyping", f, "type"),
+            ("Subsetting", callee, "subsettedFeature"),
+        ]) {
+            assert!(r.feature_type_report(call).types.is_err());
+            let rows: Vec<_> = r
+                .implied_relationships(call)
+                .into_iter()
+                .filter(|&row| {
+                    r.element_type(row) == kind
+                        && r.element_properties(row)[key]["@id"] == r.element_id(target).to_string()
+                })
+                .collect();
+            assert_eq!(rows.len(), 1);
+            edges.push(r.element_id(rows[0]));
+            assert_eq!(
+                r.element_properties(rows[0])["owningRelatedElement"]["@id"],
+                r.element_id(call).to_string()
+            );
+            assert!(
+                !r.owned_relationships(call)
+                    .iter()
+                    .any(|&row| r.element_type(row) == "ReturnParameterMembership")
+            );
+            assert!(r.feature_type_report(call).types.is_err());
+            assert!(matches!(
+                r.model_level_evaluability(call).classification,
+                ModelLevelEvaluability::Unknown(_)
+            ));
+        }
+        let user: Vec<_> = r.user_elements().collect();
+        let mut positional = Vec::new();
+        for candidate in user {
+            for row in r.implied_relationships(candidate) {
+                if r.element_type(row) == "Redefinition"
+                    && r.element_properties(row)["redefinedFeature"]["@id"]
+                        == r.element_id(p).to_string()
+                {
+                    positional.push(r.element_id(row));
+                }
+            }
+        }
+        assert_eq!(positional.len(), 1);
+        edges.extend(positional);
+        if let Some(old) = &expected {
+            assert_eq!(old, &edges);
+        } else {
+            expected = Some(edges);
+        }
+    }
+    assert_eq!(
+        source_ids,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(compact, model_to_compact_json(&model));
+}
diff --git a/crates/sysmlv2-parser/tests/eval.rs b/crates/sysmlv2-parser/tests/eval.rs
index 600802a..cea2452 100644
--- a/crates/sysmlv2-parser/tests/eval.rs
+++ b/crates/sysmlv2-parser/tests/eval.rs
@@ -4,8 +4,9 @@
 //! never panic).
 
 use sysmlv2_parser::eval::{EvalError, Value};
-use sysmlv2_parser::json::ResolvedModel;
+use sysmlv2_parser::json::{ElementRef, ResolvedModel};
 use sysmlv2_parser::model::Model;
+use sysmlv2_parser::parser::parse_expression;
 use sysmlv2_parser::rational::Rational;
 
 /// Evaluate `expr` as `attribute result = <expr>;` inside a package with
@@ -44,8 +45,8 @@ fn unknown_member_provenance_survives_value_operations() {
         part def Child { attribute flag default = false; }
         part def SpecializedChild :> Child { attribute :>> flag; }
         part def Parent { part child : SpecializedChild; part children : Child[0..*]; }
-        part installed : Child;
-        requirement def R { subject unit : Parent; }
+        part installed : Child[1];
+        requirement def R { subject unit : Parent[1]; }
         calc def Identity { in x; return result = x; }
     ";
     for expr in [
@@ -101,8 +102,8 @@ fn library_calls_preserve_unknown_receiver_members() {
                 part child : Child;
                 attribute independent = L::LocalDefault();
             }
-            requirement def R { subject unit : Parent; }
-            part installed : Parent;
+            requirement def R { subject unit : Parent[1]; }
+            part installed : Parent[1];
             attribute unknownResult = L::Read(R::unit);
             attribute knownResult = L::Read(installed);
             attribute localDefault = R::unit.independent;
@@ -130,10 +131,10 @@ fn unknown_receivers_agree_across_evaluation_entry_points() {
             part def Child { attribute flag default = false; }
             part def Parent { part child : Child; attribute flag default = false; }
             requirement def R {
-                subject unit : Parent;
+                subject unit : Parent[1];
                 ref part aliasUnit : Parent = unit;
             }
-            part installed : Parent;
+            part installed : Parent[1];
         }",
     );
     let mut r = ResolvedModel::build(&model);
@@ -386,7 +387,7 @@ fn featuring_context_redefinition() {
                  attribute extra = 100;
                  attribute total = baseMass + extra;
              }
-             part car : Vehicle { attribute :>> baseMass = 1200; }
+             part car : Vehicle[1] { attribute :>> baseMass = 1200; }
              attribute carTotal = car.total;
              attribute defTotal = Vehicle::total;
          }",
@@ -427,9 +428,9 @@ fn chain_member_through_overriding_usage() {
              part def L { attribute d; }
              part def N :> L { attribute :>> d = 5; }
              part def D { part c : L; attribute v = c.d; }
-             part unnamed : D { part :>> c : N; }
-             part named : D { part c :>> c : N; }
-             part subset : D { part :> c : N; }
+             part unnamed : D[1] { part :>> c : N; }
+             part named : D[1] { part c :>> c : N; }
+             part subset : D[1] { part :> c : N; }
              attribute chainUnnamed = unnamed.c.d;
              attribute chainNamed = named.c.d;
              attribute chainSubset = subset.c.d;
@@ -478,12 +479,12 @@ fn implicit_redefinition_by_name_shadows_in_diamonds() {
              part def Base { attribute f; }
              part def Base2 :> Base { attribute f = 7; }
              part def C { part p : Base; }
-             part c1 : C { part :>> p : Base2; }
+             part c1 : C[1] { part :>> p : Base2; }
              attribute probe = c1.p.f;
 
              part def A1 { attribute g = 1; }
              part def A2 { attribute g = 2; }
-             part q { part x : A1, A2; }
+             part q[1] { part x : A1, A2; }
              attribute unrelated = q.x.g;
          }",
     );
@@ -512,14 +513,14 @@ fn that_denotes_the_featuring_instance() {
         "t.sysml",
         "package T {
              part def Boxy;
-             part outer : Boxy {
+             part outer : Boxy[1] {
                  part inner {
                      attribute me = that;
                  }
              }
              attribute probeMe = outer.inner.me istype Boxy;
              attribute probeChain = outer.inner.that istype Boxy;
-             part shadow { attribute that = 42; attribute reads = that; }
+             part shadow[1] { attribute that = 42; attribute reads = that; }
              attribute probeShadow = shadow.reads;
          }",
     );
@@ -655,8 +656,9 @@ fn unbound_operands_degrade_to_indeterminate() {
         eval_with(u, "(u == 1) implies true"),
         Ok(Value::Boolean(true))
     );
-    // Collection membership is also three-valued: a known match decides,
-    // but a wholly unknown search value cannot fabricate absence.
+    // Collection membership is three-valued. An indeterminate tuple
+    // constituent may denote a collection of unknown arity, so the tuple
+    // stays indeterminate even when another constituent is a known match.
     assert_eq!(
         eval_with(u, "includes((1, 2), u + 1)"),
         Ok(Value::Indeterminate)
@@ -667,11 +669,11 @@ fn unbound_operands_degrade_to_indeterminate() {
     );
     assert_eq!(
         eval_with(u, "includes((1, u + 1), 1)"),
-        Ok(Value::Boolean(true))
+        Ok(Value::Indeterminate)
     );
     assert_eq!(
         eval_with(u, "excludes((1, u + 1), 1)"),
-        Ok(Value::Boolean(false))
+        Ok(Value::Indeterminate)
     );
     // Indeterminate propagates through further arithmetic.
     assert_eq!(eval_with(u, "(u + 5) * 2"), Ok(Value::Indeterminate));
@@ -825,11 +827,10 @@ fn user_defined_calculations() {
         eval_with(calc, "Torque(lever = 3, force = 10)"),
         Err(EvalError::Unresolved(_))
     ));
-    // KFL names stay reserved: a user calc named `sum` does not shadow the
-    // intrinsic.
+    // A declared calculation takes precedence over an intrinsic spelling.
     assert_eq!(
         eval_with("calc def sum { in x; 0 }", "sum((1, 2, 3))"),
-        Ok(int(6))
+        Ok(int(0))
     );
     // The `return x = expr;` spelling (a bound return parameter) also
     // yields the calculation's result — the rocket equation, no less.
@@ -924,10 +925,10 @@ fn implied_collections_roll_up() {
         "package T {
             private import ScalarValues::*;
             action def Step { attribute cost : Real default 0; }
-            action a1 : Step { attribute :>> cost = 5; }
-            action a2 : Step { attribute :>> cost = 7; }
-            action a3 : Step { attribute :>> cost = 10; }
-            part p { perform a1; perform a2; }
+            action a1 : Step[1] { attribute :>> cost = 5; }
+            action a2 : Step[1] { attribute :>> cost = 7; }
+            action a3 : Step[1] { attribute :>> cost = 10; }
+            part p[1] { perform a1; perform a2; }
             part rollup {
                 attribute total : Real = RealFunctions::sum((p.performedActions as Step).cost);
             }
@@ -938,6 +939,66 @@ fn implied_collections_roll_up() {
     assert_eq!(r.evaluate(e), Ok(Value::Integer(12)));
 }
 
+/// A query of a feature that a part redefines answers as the redefining
+/// part does: the part's owned parts do not stand in for it, and a part
+/// that owns none does not answer empty. Feature values read the same way.
+/// The receivers are single instances (`[1]`) so that the redefinition,
+/// not an unknown receiver, decides each answer where unbound collections
+/// answer indeterminate.
+#[test]
+fn a_redefined_feature_answers_as_its_redefining_part() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .expect("library");
+    model.add_source(
+        "t.sysml",
+        "package P {
+            part def Wheel;
+            part def Car { part wheels : Wheel[0..*]; }
+            part car : Car[1] {
+                part frontWheels :>> wheels {
+                    part left : Wheel;
+                    part right : Wheel;
+                }
+            }
+            part car2 : Car[1] {
+                part frontWheels :>> wheels {
+                    attribute mass = 12;
+                }
+            }
+            attribute viaRedefined = car2.wheels.mass;
+            attribute viaRedefining = car2.frontWheels.mass;
+        }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let root = r.root_scope();
+    let query = |r: &mut ResolvedModel, text: &str| {
+        let parsed = parse_expression(text);
+        r.query(root, &parsed.expr.expect("expression"))
+    };
+    for (redefined, redefining) in [
+        ("P::car.wheels", "P::car.frontWheels"),
+        ("P::car2.wheels", "P::car2.frontWheels"),
+        ("P::car2.wheels.mass", "P::car2.frontWheels.mass"),
+    ] {
+        let answer = query(&mut r, redefined);
+        assert!(answer.is_ok(), "{redefined}: {answer:?}");
+        assert_eq!(
+            answer,
+            query(&mut r, redefining),
+            "{redefined} answers as {redefining}"
+        );
+    }
+    let value = |r: &mut ResolvedModel, name: &str| {
+        let e = r.resolve_qualified(name).expect(name);
+        r.evaluate(e)
+    };
+    let via_redefined = value(&mut r, "P::viaRedefined");
+    assert!(via_redefined.is_ok(), "{via_redefined:?}");
+    assert_eq!(via_redefined, value(&mut r, "P::viaRedefining"));
+}
+
 /// Corpus smoke gate: every feature value in the full corpus (with the
 /// standard library loaded) either evaluates or returns a clean error —
 /// no panics, and a healthy fraction actually computes.
@@ -949,7 +1010,10 @@ fn corpus_feature_values_evaluate_or_fail_cleanly() {
         .expect("library");
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let mut r = ResolvedModel::build(&model);
     let features = r.features_with_values();
@@ -970,6 +1034,88 @@ fn corpus_feature_values_evaluate_or_fail_cleanly() {
     );
 }
 
+/// The parameters an invocation binds, read off a callable's heritage
+/// alone, are the parameters among the model's own view of its features
+/// (implied heritage included), for every type of the library and the
+/// corpus but a few the inherited view reads differently: a performed
+/// action reached through a feature chain, whose parameters the walk pairs
+/// by position where the inherited view keeps both; a state's performed
+/// action, whose inherited view also lists an accept action's payload
+/// registered in the enclosing scope; and a requirement's subject that
+/// redefines its general's subject explicitly, which the inherited view
+/// gives none.
+#[test]
+fn corpus_callable_parameters_agree_with_the_inherited_view() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .expect("library");
+    for f in sysmlv2_testkit::user_files() {
+        let src = std::fs::read_to_string(&f).unwrap();
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
+    }
+    let mut r = ResolvedModel::build(&model);
+    let mut checked = 0;
+    let mut differ = Vec::new();
+    for callee in r.elements().collect::<Vec<_>>() {
+        if r.inheritance_incomplete(callee, true) {
+            continue;
+        }
+        let inherited: Vec<_> = r
+            .effective_features(callee, true)
+            .into_iter()
+            .filter(|&f| {
+                r.is_parameter(f)
+                    && r.owning_membership_type(f) != Some("ReturnParameterMembership")
+            })
+            .collect();
+        let Some(parameters) = r.callable_parameters(callee) else {
+            let name = r.element_qualified_name(callee).unwrap_or_default();
+            panic!("no signature for {} {name}", r.element_type(callee));
+        };
+        let parameters: Vec<_> = parameters.into_iter().map(|p| p.element).collect();
+        if parameters.is_empty() && inherited.is_empty() {
+            continue;
+        }
+        checked += 1;
+        if parameters != inherited {
+            let metaclass = r.element_type(callee);
+            let name = r.element_qualified_name(callee).unwrap_or_default();
+            let spell = |r: &mut ResolvedModel, list: &[ElementRef]| {
+                list.iter()
+                    .map(|&p| r.element_qualified_name(p).unwrap_or_default())
+                    .collect::<Vec<_>>()
+            };
+            let (walk, view) = (spell(&mut r, &parameters), spell(&mut r, &inherited));
+            let difference = format!("{metaclass} {name}: walk {walk:?}, view {view:?}");
+            assert!(
+                matches!(metaclass, "PerformActionUsage" | "Step" | "ReferenceUsage"),
+                "{difference}"
+            );
+            differ.push(difference);
+        }
+    }
+    assert!(checked > 6000, "only {checked} types with parameters");
+    assert!(differ.len() <= 13, "{differ:#?}");
+}
+
+/// Arguments bind inherited parameters by position, whatever the
+/// specialization names its own: `Swapped`'s first parameter `b` stands
+/// for `Diff::a`.
+#[test]
+fn arguments_bind_by_position_not_by_name() {
+    let decls = "calc def Diff { in a; in b; a - b }
+                 calc def Swapped :> Diff { in b; in a; }
+                 calc def Renamed :> Diff { in x; in y; }";
+    assert_eq!(eval_with(decls, "Swapped(10, 3)"), Ok(int(7)));
+    assert_eq!(eval_with(decls, "Swapped(b = 10, a = 3)"), Ok(int(7)));
+    assert_eq!(eval_with(decls, "Renamed(10, 3)"), Ok(int(7)));
+    assert_eq!(eval_with(decls, "Renamed(y = 3, x = 10)"), Ok(int(7)));
+}
+
 /// Units normalize to exponent maps: derived-unit definitions expand,
 /// `*`/`/`/`**` combine exponents and cancel, reciprocals and rational
 /// powers work — still with zero unit *conversion*.
@@ -1125,10 +1271,10 @@ fn quantity_zero_identity() {
 fn chain_over_sequence_maps_and_dedups() {
     let decls = "part def E { attribute v = 304; }
                  part def P { attribute m; }
-                 part e1 : E; part e2 : E; part e3 : E;
-                 part a : P { attribute :>> m = 1; }
-                 part b : P { attribute :>> m = 2; }
-                 part s { part es = (e1, e2, e3); part ps = (a, b); }";
+                 part e1 : E[1]; part e2 : E[1]; part e3 : E[1];
+                 part a : P[1] { attribute :>> m = 1; }
+                 part b : P[1] { attribute :>> m = 2; }
+                 part s[1] { part es = (e1, e2, e3); part ps = (a, b); }";
     assert_eq!(eval_with(decls, "s.es.v"), Ok(int(304)));
     assert_eq!(
         eval_with(decls, "s.ps.m"),
@@ -1148,16 +1294,16 @@ fn featuring_context_depth_and_recursive_rollup() {
                     attribute m2 = base * 2;
                     attribute base;
                 }
-                part car : V { attribute :>> base = 10; }";
+                part car : V[1] { attribute :>> base = 10; }";
     assert_eq!(eval_with(deep, "car.total"), Ok(int(21)));
     let rollup = "part def M {
                       part subs : M [*] default null;
                       attribute mass;
                       attribute totalMass = mass + sum(subs.totalMass);
                   }
-                  part leaf1 : M { attribute :>> mass = 1; }
-                  part leaf2 : M { attribute :>> mass = 2; }
-                  part root : M {
+                  part leaf1 : M[1] { attribute :>> mass = 1; }
+                  part leaf2 : M[1] { attribute :>> mass = 2; }
+                  part root : M[1] {
                       attribute :>> mass = 5;
                       part :>> subs = (leaf1, leaf2);
                   }";
@@ -1372,8 +1518,8 @@ fn classification_operators() {
     let decls = "part def Component;
                  part def Engine :> Component;
                  part def Wheel :> Component;
-                 part e : Engine;
-                 part w : Wheel;
+                 part e : Engine[1];
+                 part w : Wheel[1];
                  part parts = (e, w);";
     // Declared conformance is a guaranteed true.
     assert_eq!(
@@ -1474,10 +1620,10 @@ fn performed_actions_rollup_evaluates() {
         "package Tally {
             private import ScalarValues::*;
             action def Chore { attribute effort : Real default 0; }
-            action c1 : Chore { attribute :>> effort = 4.0; }
-            action c2 : Chore { attribute :>> effort = 9.0; }
-            action c3 : Chore { attribute :>> effort = 100.0; }
-            part worker {
+            action c1 : Chore[1] { attribute :>> effort = 4.0; }
+            action c2 : Chore[1] { attribute :>> effort = 9.0; }
+            action c3 : Chore[1] { attribute :>> effort = 100.0; }
+            part worker[1] {
                 perform c1;
                 perform c2;
             }
@@ -1502,14 +1648,13 @@ fn performed_actions_rollup_evaluates() {
 /// else answers *indeterminate* rather than fabricating (the
 /// placeholder used to count as one element, silently mis-measuring
 /// every multi-valued feature and making `(1..size(xs)-1)->forAll`
-/// bodies vacuously true). Sequence literals containing placeholders
-/// keep their written arity, and enum literals stay closed one-element
-/// values.
+/// bodies vacuously true). Sequence literals cannot establish the arity
+/// of unknown collections, and enum literals stay closed one-element values.
 #[test]
 fn unbound_cardinality_comes_from_declared_multiplicity() {
     let decls = "
         part def D;
-        part rack {
+        part rack[1] {
             part slots[3] : D;
             part gear[1..*] : D;
             part loose[0..2] : D;
@@ -1519,7 +1664,7 @@ fn unbound_cardinality_comes_from_declared_multiplicity() {
     ";
     // Exact declared multiplicity answers.
     assert_eq!(eval_with(decls, "size(rack.slots)"), Ok(int(3)));
-    // The KerML default `[1..1]` answers for a bare feature.
+    // A structural usage inside a usage has implicit multiplicity `[1..1]`.
     assert_eq!(eval_with(decls, "size(rack.lone)"), Ok(int(1)));
     // A lower bound settles non-emptiness; the size stays unknown.
     assert_eq!(
@@ -1535,10 +1680,10 @@ fn unbound_cardinality_comes_from_declared_multiplicity() {
         eval_with(decls, "isEmpty(rack.loose)"),
         Ok(Value::Indeterminate)
     );
-    // Written arity survives placeholders inside sequence literals.
+    // Flat sequences cannot wrap unknown collections into scalar placeholders.
     assert_eq!(
         eval_with(decls, "size((rack.gear, rack.loose))"),
-        Ok(int(2))
+        Ok(Value::Indeterminate)
     );
     // Enum literals stay closed single values.
     assert_eq!(eval_with(decls, "size(Mode::ON)"), Ok(int(1)));
@@ -1569,6 +1714,244 @@ fn unbound_cardinality_comes_from_declared_multiplicity() {
     ));
 }
 
+#[test]
+fn cardinality_inherits_redefinitions_without_rounding_or_guessing() {
+    let decls = "
+        part def Rack { part slots[4]; }
+        part def Middle :> Rack { part :>> slots; }
+        part rack : Middle[1] { part :>> slots; }
+        part huge[9007199254740993];
+        part optional[0..1];
+        part def Left { part slots[2..5]; }
+        part def Right { part slots[4..7]; }
+        part both[1] { part slots :>> Left::slots, Right::slots; }
+        part missing[1] { part slots :>> Left::slots, absent; }
+        part cyclic :>> cyclic;
+        part a :>> b; part b :>> a;
+        attribute count = size(recursive);
+        part recursive[count];
+        attribute unknown;
+        part invalid[unknown] :>> Rack::slots;
+        attribute neg = -1; part negative[neg];
+    ";
+    assert_eq!(eval_with(decls, "size(rack.slots)"), Ok(int(4)));
+    assert_eq!(eval_with(decls, "size(huge)"), Ok(int(9007199254740993)));
+    assert!(matches!(
+        eval_with(decls, "huge#(9007199254740994)"),
+        Err(EvalError::Type(_))
+    ));
+    assert_eq!(eval_with(decls, "optional#(1)"), Ok(Value::Indeterminate));
+    assert_eq!(
+        eval_with(decls, "notEmpty(both.slots)"),
+        Ok(Value::Boolean(true))
+    );
+    for expr in [
+        "size(both.slots)",
+        "size(missing.slots)",
+        "size(cyclic)",
+        "size(a)",
+        "size(recursive)",
+        "size(invalid)",
+        "size(negative)",
+    ] {
+        assert_eq!(eval_with(decls, expr), Ok(Value::Indeterminate), "{expr}");
+    }
+}
+
+#[test]
+fn cardinality_defaults_follow_usage_kind_owner_and_subsetting() {
+    let mut model = Model::new();
+    model.add_source(
+        "defaults.sysml",
+        r#"
+        package P {
+            attribute a; item i; part p; port q;
+            part def D {
+                attribute a; item i; part p; port q;
+                ref item reference; in attribute input;
+                connection c; interface face; allocation alloc;
+                action act; occurrence occ; ref generic;
+                package Nested { attribute a; part p; }
+            }
+            part holder { attribute a; item i; part p; port q; }
+            part explicit[1];
+            part base[2..5]; part other[4..7];
+            part subset :> base; part intersection :> base, other;
+            part smaller[1] :> base;
+            part chain :>> subset; part mixed :> base :>> other;
+            part missing :> absent; part partial :> base, absent;
+            part cycle :> cycle; part ca :> cb; part cb :>> ca;
+            part noBound; part inheritedDefault :> noBound;
+            part Dsubset :> D::p;
+            part low[0..1]; part conflict :> base, low;
+            part def Container { part subset :> P::base; }
+        }
+    "#,
+    );
+    model.add_source(
+        "defaults.kerml",
+        "package K { feature a; class C { feature a; } }",
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    for name in [
+        "D::a",
+        "D::i",
+        "D::p",
+        "D::q",
+        "D::reference",
+        "D::input",
+        "holder::a",
+        "holder::i",
+        "holder::p",
+        "holder::q",
+        "explicit",
+        "Dsubset",
+    ] {
+        let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+        assert_eq!(r.effective_cardinality(e), Some((1, Some(1))), "{name}");
+    }
+    for name in [
+        "P::a",
+        "P::i",
+        "P::p",
+        "P::q",
+        "P::holder",
+        "P::D::c",
+        "P::D::face",
+        "P::D::alloc",
+        "P::D::act",
+        "P::D::occ",
+        "P::D::generic",
+        "P::D::Nested::a",
+        "P::D::Nested::p",
+        "P::inheritedDefault",
+        "K::a",
+        "K::C::a",
+    ] {
+        let e = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.effective_cardinality(e), Some((0, None)), "{name}");
+    }
+    for (name, bounds) in [
+        ("subset", (2, Some(5))),
+        ("intersection", (4, Some(5))),
+        ("smaller", (1, Some(1))),
+        ("chain", (2, Some(5))),
+        ("mixed", (4, Some(5))),
+        ("Container::subset", (2, Some(5))),
+    ] {
+        let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+        assert_eq!(r.effective_cardinality(e), Some(bounds), "{name}");
+    }
+    for name in ["missing", "partial", "cycle", "ca", "conflict"] {
+        let e = r.resolve_qualified(&format!("P::{name}")).unwrap();
+        assert_eq!(r.effective_cardinality(e), None, "{name}");
+    }
+}
+
+#[test]
+fn inherited_subsetting_bounds_control_collection_operations() {
+    let decls = "part base[4]; part middle :> base; part inherited :>> middle;
+        part empty[0]; part emptySubset :> empty;
+        part variable[2..5]; part variableSubset :> variable;
+        part unknown; part def D { part singleton; }";
+    assert_eq!(eval_with(decls, "size(inherited)"), Ok(int(4)));
+    assert_eq!(
+        eval_with(decls, "isEmpty(emptySubset)"),
+        Ok(Value::Boolean(true))
+    );
+    assert_eq!(
+        eval_with(decls, "notEmpty(variableSubset)"),
+        Ok(Value::Boolean(true))
+    );
+    assert_eq!(eval_with(decls, "size(unknown)"), Ok(Value::Indeterminate));
+    assert_eq!(eval_with(decls, "size(D::singleton)"), Ok(int(1)));
+    assert!(matches!(
+        eval_with(decls, "inherited#(5)"),
+        Err(EvalError::Type(_))
+    ));
+}
+
+#[test]
+fn unsupported_owned_multiplicities_and_subsettings_stay_unknown() {
+    let mut model = Model::new();
+    let unit = model.add_source(
+        "unsupported.kerml",
+        "package K {
+            feature base[2];
+            feature ranged { multiplicity [3]; }
+            feature named { multiplicity bounds [4]; }
+            feature conflicting[1] { multiplicity bounds [2]; }
+            feature inherited subsets base { multiplicity bounds [4]; }
+            feature reference references base;
+            feature receiver { feature leaf[2]; }
+            feature crossing crosses receiver.leaf;
+        }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let unit = model.add_source(
+        "enum.sysml",
+        "enum def Choice { on; off; }
+        enum root : Choice;
+        part def D { enum choice : Choice; }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    for (name, count) in [("ranged", 3), ("named", 4), ("inherited", 4)] {
+        let e = r.resolve_qualified(&format!("K::{name}")).unwrap();
+        assert_eq!(
+            r.effective_cardinality(e),
+            Some((count, Some(count))),
+            "{name}"
+        );
+    }
+    for name in ["conflicting", "reference", "crossing"] {
+        let e = r.resolve_qualified(&format!("K::{name}")).unwrap();
+        assert_eq!(r.effective_cardinality(e), None, "{name}");
+    }
+    let root = r.resolve_qualified("root").unwrap();
+    assert_eq!(r.effective_cardinality(root), Some((0, None)));
+    let member = r.resolve_qualified("D::choice").unwrap();
+    assert_eq!(r.effective_cardinality(member), Some((1, Some(1))));
+}
+
+#[test]
+fn inherited_cardinality_uses_the_redefining_context() {
+    let decls = "part def Rack { attribute count = 4; part slots[count]; }
+        part rack : Rack[1] { attribute :>> count = 6; part :>> slots; }
+        part zero[0]; part empty :>> zero;
+        part low[2..3]; part high[4..5]; part conflict :>> low, high;
+        part broad[2..8]; part narrowed[6] :>> broad;";
+    assert_eq!(eval_with(decls, "size(rack.slots)"), Ok(int(6)));
+    assert_eq!(eval_with(decls, "size(empty)"), Ok(int(0)));
+    assert_eq!(eval_with(decls, "size(narrowed)"), Ok(int(6)));
+    assert_eq!(eval_with(decls, "isEmpty(empty)"), Ok(Value::Boolean(true)));
+    assert_eq!(eval_with(decls, "size(conflict)"), Ok(Value::Indeterminate));
+}
+
+#[test]
+fn cardinality_keeps_unknown_receivers_and_shared_heritage_bounded() {
+    let decls = "part def Rack { attribute count default = 4; part slots[count]; part fixed[4]; }
+        requirement def R { subject unit : Rack[1]; }";
+    assert_eq!(
+        eval_with(decls, "size(R::unit.slots)"),
+        Ok(Value::Indeterminate)
+    );
+    assert_eq!(eval_with(decls, "size(R::unit.fixed)"), Ok(int(4)));
+
+    let mut diamond = String::from("part a0[4]; part b0[4];");
+    for n in 1..24 {
+        diamond.push_str(&format!(
+            "part a{n} :>> a{}, b{}; part b{n} :>> a{}, b{};",
+            n - 1,
+            n - 1,
+            n - 1,
+            n - 1
+        ));
+    }
+    assert_eq!(eval_with(&diamond, "size(a23)"), Ok(int(4)));
+}
+
 /// Lib-gated: verification verdict helpers evaluate — the library's
 /// pass/fail calc reduces a boolean argument to the corresponding
 /// verdict-kind enum member (not a scalar), through calc-body inlining
@@ -1885,3 +2268,269 @@ fn evaluation_budget_covers_intrinsics_and_per_item_results() {
         "{folded:?}"
     );
 }
+
+#[test]
+fn intrinsic_names_do_not_override_user_calculations() {
+    let decls = "
+        calc def sum { in x; return r = 99; }
+        calc def min { in x; in y; return r = 88; }
+        calc def '+' { in x; in y; return r = 77; }
+        alias renamed for sum;
+        calc def Call { in sum; return r = sum(1); }
+    ";
+    for expr in [
+        "sum(1)",
+        "T::sum(1)",
+        "1->sum()",
+        "1->T::sum()",
+        "renamed(1)",
+        "Call(sum)",
+    ] {
+        assert_eq!(eval_with(decls, expr), Ok(int(99)), "{expr}");
+    }
+    for expr in ["(1, 2)->reduce min", "(1, 2)->reduce T::min"] {
+        assert_eq!(eval_with(decls, expr), Ok(int(88)), "{expr}");
+    }
+    for expr in ["(1, 2)->reduce '+'", "(1, 2)->reduce T::'+'"] {
+        assert_eq!(eval_with(decls, expr), Ok(int(77)), "{expr}");
+    }
+    assert!(matches!(
+        eval("Missing::sum(1)"),
+        Err(EvalError::Unsupported(_))
+    ));
+    assert!(matches!(
+        eval("(1, 2)->Missing::reduce '+'"),
+        Err(EvalError::Unsupported(_))
+    ));
+    assert!(matches!(
+        eval_with("calc def reduce;", "(1, 2)->reduce '+'"),
+        Err(EvalError::Unsupported(_))
+    ));
+    assert!(matches!(
+        eval_with("calc def collect;", "(1, 2)->collect { in x; x }"),
+        Err(EvalError::Unsupported(_))
+    ));
+}
+
+#[test]
+fn intrinsic_dispatch_follows_library_identity_and_aliases() {
+    let mut model = Model::new();
+    for (file, source) in [
+        (
+            "numeric.kerml",
+            "standard library package NumericalFunctions { abstract function sum { in x; return r; } }",
+        ),
+        (
+            "control.kerml",
+            "standard library package ControlFunctions { abstract function reduce { in x; in fn; return r; } }",
+        ),
+        (
+            "other.kerml",
+            "standard library package Other { function sum { in x; return r = 42; } }",
+        ),
+    ] {
+        let unit = model.add_library_source(file, source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    }
+    let unit = model.add_source(
+        "user.sysml",
+        "package T {
+        alias total for NumericalFunctions::sum;
+        alias fold for ControlFunctions::reduce;
+        calc def sum { in x; return r = 99; }
+        calc def Call { in sum; return r = sum((1, 2, 3)); }
+        attribute builtin = total((1, 2, 3));
+        attribute qualified = NumericalFunctions::sum((1, 2, 3));
+        attribute arrow = (1, 2, 3)->total();
+        attribute indirect = Call(total);
+        attribute folded = (1, 2)->fold '+';
+        attribute own = sum(1);
+        attribute libraryBody = Other::sum(1);
+    }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    for (name, value) in [
+        ("builtin", 6),
+        ("qualified", 6),
+        ("arrow", 6),
+        ("indirect", 6),
+        ("folded", 3),
+        ("own", 99),
+        ("libraryBody", 42),
+    ] {
+        let e = r.resolve_qualified(&format!("T::{name}")).unwrap();
+        assert_eq!(r.evaluate(e), Ok(int(value)), "{name}");
+    }
+}
+
+#[test]
+fn standard_library_operator_aliases_reduce_by_identity() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let unit = model.add_source(
+        "t.sysml",
+        "package T {
+        alias add for DataFunctions::'+';
+        alias concatenate for StringFunctions::'+';
+        alias fold for ControlFunctions::reduce;
+        attribute numeric = (1, 2, 3)->fold add;
+        attribute text = (\"a\", \"b\")->fold concatenate;
+        attribute integer = (1, 2, 3)->fold IntegerFunctions::'+';
+        attribute scalar = (1, 2, 3)->fold ScalarFunctions::'+';
+    }",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    for name in ["numeric", "integer", "scalar"] {
+        let e = r.resolve_qualified(&format!("T::{name}")).unwrap();
+        assert_eq!(r.evaluate(e), Ok(int(6)), "{name}");
+    }
+    let text = r.resolve_qualified("T::text").unwrap();
+    assert_eq!(r.evaluate(text), Ok(Value::String("ab".into())));
+}
+
+#[test]
+fn ambiguous_intrinsic_spelling_is_not_a_missing_builtin() {
+    let decls = "package A { calc def sum { in x; return r = 1; } }
+        package B { calc def sum { in x; return r = 2; } }
+        import A::*; import B::*;";
+    assert!(matches!(
+        eval_with(decls, "sum(3)"),
+        Err(EvalError::Unsupported(_))
+    ));
+}
+
+#[test]
+fn inaccessible_intrinsic_spelling_is_not_a_missing_builtin() {
+    let decls = "package A { private calc def sum { in x; return r = 1; } } import A::*;";
+    assert!(matches!(
+        eval_with(decls, "sum(3)"),
+        Err(EvalError::Unsupported(_))
+    ));
+}
+
+#[test]
+fn unbound_collections_never_materialize_as_single_instances() {
+    let decls = "
+        part def Motor { attribute mass = 0.55; }
+        part def Rack { part motors : Motor[4]; }
+        part def Middle :> Rack { part :>> motors; }
+        part rack : Middle[1] { part :>> motors; }
+        part motors : Motor[4];
+        part optional : Motor[0..1];
+        part empty : Motor[0];
+        part m1 : Motor[1]; part m2 : Motor[1]; part m3 : Motor[1]; part m4 : Motor[1];
+        part concrete = (m1, m2, m3, m4);
+        calc def Identity { in x; return result = x; }
+    ";
+    for collection in ["motors", "rack.motors", "optional"] {
+        for expr in [
+            format!("{collection}.mass"),
+            format!("sum({collection}.mass)"),
+            format!("{collection}->collect {{ in m; m.mass }}"),
+            format!("{collection}->reduce {{ in a; in b; a }}"),
+            format!("{collection}->forAll {{ in m; m.mass == 0.55 }}"),
+            format!("{collection}->exists {{ in m; true }}"),
+            format!("size(({collection},))"),
+            format!("size({collection} as Motor)"),
+            format!("size(m1->collect {{ in m; {collection} }})"),
+            format!("sum(Identity({collection}).mass)"),
+            format!("size(tail({collection}))"),
+            format!("size(reverse({collection}))"),
+            format!("size(union({collection}, m1))"),
+            format!("head({collection}).mass"),
+            format!("last({collection}).mass"),
+            format!("max({collection})"),
+            format!("min({collection})"),
+            format!("product({collection})"),
+        ] {
+            assert_eq!(eval_with(decls, &expr), Ok(Value::Indeterminate), "{expr}");
+        }
+    }
+    for (expr, expected) in [
+        ("size(rack.motors)", int(4)),
+        ("size(concrete)", int(4)),
+        ("size((m1, m2))", int(2)),
+        ("sum(concrete->collect { in m; m.mass })", rat(11, 5)),
+        ("sum(concrete.mass)", rat(11, 20)), // existing unique dot-chain semantics
+        ("sum(empty.mass)", int(0)),
+        ("product(empty.mass)", int(1)),
+        ("size((empty, m1))", int(1)),
+        ("empty->forAll { in m; false }", Value::Boolean(true)),
+        ("empty->exists { in m; true }", Value::Boolean(false)),
+        ("size(empty->collect { in m; m.mass })", int(0)),
+    ] {
+        assert_eq!(eval_with(decls, expr), Ok(expected), "{expr}");
+    }
+}
+
+#[test]
+fn indexing_chained_collections_requires_known_flattened_positions() {
+    let declarations = "
+        part def A {
+            attribute xs[4] ordered;
+            attribute flag[1];
+            attribute items[0..*] ordered = if flag ? xs else xs;
+            attribute scalar[1];
+        }
+        part def B { attribute items[1] = 99; attribute scalar[1] = 99; }
+        part a : A[1]; part b : B[1];
+    ";
+    for expression in ["(a, b).items#(2)", "(a, b).items#(3)", "(b, a).items#(2)"] {
+        assert_eq!(
+            eval_with(declarations, expression),
+            Ok(Value::Indeterminate),
+            "{expression}"
+        );
+    }
+    // Exact singleton placeholders retain a position, even though their value
+    // remains unknown. Direct unknown collections retain their upper bounds.
+    assert!(matches!(
+        eval_with(declarations, "(a, b).scalar#(1)"),
+        Ok(Value::Unbound(_))
+    ));
+    assert_eq!(eval_with(declarations, "(a, b).scalar#(2)"), Ok(int(99)));
+    assert_eq!(
+        eval_with(declarations, "a.xs#(2)"),
+        Ok(Value::Indeterminate)
+    );
+    assert!(matches!(
+        eval_with(declarations, "a.xs#(5)"),
+        Err(EvalError::Type(_))
+    ));
+}
+
+#[test]
+fn qualified_collection_receivers_preserve_indeterminate_values() {
+    use sysmlv2_parser::ast::{Name, QualifiedName};
+    let mut model = Model::new();
+    let unit = model.add_source(
+        "t.sysml",
+        "package P {
+        part def Motor { attribute mass = 0.55; }
+        part motors : Motor[4];
+        part wrapped : Motor = (motors,);
+    }",
+    );
+    assert!(unit.diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&model);
+    let member = QualifiedName {
+        is_global: false,
+        segments: vec![Name {
+            value: "mass".into(),
+            span: Default::default(),
+        }],
+        span: Default::default(),
+    };
+    for name in ["P::motors", "P::wrapped"] {
+        let root = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.evaluate_chain(root, &[&member]), Ok(Value::Indeterminate));
+        assert_eq!(
+            r.evaluate_qualified(&format!("{name}::mass")),
+            Ok(Value::Indeterminate)
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/exposure_context.rs b/crates/sysmlv2-parser/tests/exposure_context.rs
new file mode 100644
index 0000000..f68470f
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/exposure_context.rs
@@ -0,0 +1,204 @@
+//! Compatibility view exposures retain import operation order and identity.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    base.add_library_source("views.sysml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(67).unwrap(), 67).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("views.sysml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            m.add_source("view-use.sysml", user);
+            assert!(!m.has_errors());
+            let r = ResolvedModel::build(&m);
+            (m, r)
+        })
+        .collect()
+}
+
+fn check(library: &str, user: &str, cases: &[(&str, &[&str])]) {
+    for (mode, (model, mut resolved)) in models(library, user).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        for _ in 0..2 {
+            for &(view, expected) in cases {
+                let view = resolved.resolve_qualified(view).unwrap();
+                let names: Vec<_> = resolved
+                    .view_exposed_elements(view)
+                    .into_iter()
+                    .map(|element| resolved.element_qualified_name(element).unwrap())
+                    .collect();
+                assert_eq!(names, expected, "mode={mode}");
+            }
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+        if mode == 3 {
+            assert_eq!(loaded, 0);
+        }
+    }
+}
+
+#[test]
+fn excluded_redefining_import_does_not_remove_a_valid_inherited_membership() {
+    let library = "part def A {part x;}
+        part def P :> A {part y redefines A::x; public import D::*;}
+        part def C {public import P::*;}
+        part def D :> A, C;";
+    let user = "view v {expose P::*;}";
+    for first_global in [false, true] {
+        for (mode, (model, mut r)) in models(library, user).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            let a = r.resolve_qualified("A::x").unwrap();
+            let y = r.resolve_qualified("P::y").unwrap();
+            let d = r.resolve_qualified("D").unwrap();
+            let v = r.resolve_qualified("v").unwrap();
+            assert_eq!(r.redefinition_targets(y), vec![a]);
+            let global = |r: &mut ResolvedModel| {
+                r.inherited_memberships(d, true)
+                    .into_iter()
+                    .filter_map(|membership| r.membership_member(membership))
+                    .collect::<Vec<_>>()
+            };
+            if first_global {
+                assert_eq!(global(&mut r), vec![y]);
+            }
+            for _ in 0..2 {
+                // These are identity assertions, not reconstructed name checks.
+                assert_eq!(
+                    r.view_exposed_elements(v),
+                    vec![y, a],
+                    "mode {mode}, first_global={first_global}"
+                );
+                assert_eq!(global(&mut r), vec![y]);
+            }
+            assert_eq!(model.loaded_library_unit_count(), loaded);
+        }
+    }
+}
+
+#[test]
+fn ordinary_import_projection_and_exposure_share_inherited_survival() {
+    for (_, mut r) in models(
+        "part def A {part x;} part def D :> A {part y redefines A::x;}",
+        "package P {import all D::*;} view v {expose P::*;}",
+    ) {
+        let d = r.resolve_qualified("D::y").unwrap();
+        let p = r.resolve_qualified("P").unwrap();
+        let actual: Vec<_> = r
+            .imported_memberships(p)
+            .into_iter()
+            .filter_map(|m| r.membership_member(m))
+            .collect();
+        assert_eq!(actual, vec![d]);
+        let v = r.resolve_qualified("v").unwrap();
+        assert_eq!(r.view_exposed_elements(v), vec![d]);
+    }
+}
+
+#[test]
+fn contextual_namespace_pruning_stays_at_the_namespace_result_boundary() {
+    for (_, mut r) in models(
+        "package A {part x;} package B {part x;}",
+        "package P {public import A::*; public import B::*;} view v {expose P::*;}",
+    ) {
+        let p = r.resolve_qualified("P").unwrap();
+        assert!(r.imported_memberships(p).is_empty());
+        let a = r.resolve_qualified("A::x").unwrap();
+        let b = r.resolve_qualified("B::x").unwrap();
+        let v = r.resolve_qualified("v").unwrap();
+        assert_eq!(r.view_exposed_elements(v), vec![a, b]);
+    }
+}
+
+#[test]
+fn aliases_remain_distinct_memberships_during_contextual_reduction() {
+    check(
+        "part def A {part x; alias ax for x;} part def D :> A;",
+        "view v {expose D::*;}",
+        &[("v", &[])],
+    );
+}
+
+#[test]
+fn contextual_cycles_separate_namespace_from_type_exclusions() {
+    check(
+        "part def A :> B {part x;} part def B :> A {part y;}",
+        "view v {expose A::*;}",
+        &[("v", &["A::x", "B::y"])],
+    );
+    check(
+        "package P {package N {part child;} public import D::*;} part def C {public import P::**;} part def D :> C;",
+        "view v {expose P::*;}",
+        &[("v", &["P::N", "P"])],
+    );
+}
+
+#[test]
+fn layered_diamonds_reuse_equivalent_contexts_without_duplicate_memberships() {
+    let mut library = "part def Base {part x;}".to_string();
+    let mut last = "Base".to_string();
+    for n in 0..24 {
+        library.push_str(&format!(
+            "part def L{n} :> {last}; part def R{n} :> {last}; part def Join{n} :> L{n},R{n};"
+        ));
+        last = format!("Join{n}");
+    }
+    check(
+        &library,
+        &format!("view v {{expose {last}::*;}}"),
+        &[("v", &["Base::x"])],
+    );
+}
+
+#[test]
+fn contextual_projection_preserves_previously_supported_positive_bases() {
+    check(
+        "part def Frame {part cell {attribute rating;}} part def Housing {part slot : Frame;}",
+        "part merged :> Housing::slot.cell; view v {expose merged::*;}",
+        &[("v", &["Frame::cell::rating"])],
+    );
+    check(
+        "part def A {part x;}",
+        "part def D :> A, Missing; view v {expose D::*;}",
+        &[("v", &["A::x"])],
+    );
+    for (mode, (model, mut r)) in models(
+        "package Metaobjects {metadata def SemanticMetadata {attribute baseType;}} package M {metadata def U; part def Target {part member;} metadata def Tagged :> Metaobjects::SemanticMetadata {:>> baseType = Target meta U;} #Tagged part def Annotated;}",
+        "view v {expose M::Annotated::*;}",
+    ).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        let annotated = r.resolve_qualified("M::Annotated").unwrap();
+        let member = r.resolve_qualified("M::Target::member").unwrap();
+        let view = r.resolve_qualified("v").unwrap();
+        let mut expected: Vec<_> = r.owned_relationships(annotated).into_iter()
+            .filter_map(|relationship| r.membership_member(relationship)).collect();
+        // The annotation itself is a legitimate anonymous owned member.
+        assert_eq!(expected.len(), 1);
+        assert!(r.element_qualified_name(expected[0]).is_none());
+        expected.push(member);
+        for _ in 0..2 {
+            assert_eq!(r.view_exposed_elements(view), expected, "mode {mode}");
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/exposure_memberships.rs b/crates/sysmlv2-parser/tests/exposure_memberships.rs
new file mode 100644
index 0000000..2bd1a67
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/exposure_memberships.rs
@@ -0,0 +1,233 @@
+//! Compatibility view exposures retain import operation order and identity.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    base.add_library_source("views.sysml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(67).unwrap(), 67).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("views.sysml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            m.add_source("view-use.sysml", user);
+            assert!(!m.has_errors());
+            let r = ResolvedModel::build(&m);
+            (m, r)
+        })
+        .collect()
+}
+
+fn check(library: &str, user: &str, cases: &[(&str, &[&str])]) {
+    for (mode, (model, mut resolved)) in models(library, user).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        for _ in 0..2 {
+            for &(view, expected) in cases {
+                let view = resolved
+                    .resolve_qualified(view)
+                    .unwrap_or_else(|| panic!("missing view {view}, mode={mode}"));
+                let names: Vec<_> = resolved
+                    .view_exposed_elements(view)
+                    .into_iter()
+                    .map(|element| resolved.element_qualified_name(element).unwrap_or_else(|| panic!("unnamed element {element:?}, view={view:?}, mode={mode}, json={:?}", (resolved.element_type(element), resolved.element_properties(element)))))
+                    .collect();
+                assert_eq!(names, expected, "mode={mode}");
+            }
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+        if mode == 3 {
+            assert_eq!(loaded, 0);
+        }
+    }
+}
+
+#[test]
+fn ordinary_imports_do_not_expose_and_mixed_expose_order_is_retained() {
+    check(
+        "package A {part a;} package B {part b;}",
+        "view onlyB {import A::*; expose B::*;} view inOrder {expose A::*; expose B::b; expose A::a;}",
+        &[("onlyB", &["B::b"]), ("inOrder", &["A::a", "B::b"])],
+    );
+}
+
+#[test]
+fn repeated_namespaces_keep_distinct_filter_and_recursive_paths() {
+    check(
+        "package A {part a; package N {part child;}}",
+        "view paths {expose A::*[false]; expose A::*[true];}
+         view deep {expose A::*[false]; expose A::**;}",
+        &[
+            ("paths", &["A::a", "A::N"]),
+            ("deep", &["A", "A::a", "A::N", "A::N::child"]),
+        ],
+    );
+}
+
+#[test]
+fn inherited_view_conditions_are_applied_but_private_conditions_do_not_inherit() {
+    check(
+        "package A {part a;} view def Reject {filter false;} view def Private {private filter false;}",
+        "view rejected:Reject {expose A::*;} view admitted:Private {expose A::*;}",
+        &[("rejected", &[]), ("admitted", &["A::a"])],
+    );
+}
+
+#[test]
+fn aliases_and_reexports_are_memberships_before_final_element_dedup() {
+    check(
+        "package B {part b;} package A {public import B::*; alias other for B::b;}",
+        "view onlyA {expose A::*;} view v {expose A::*; expose B::b;}",
+        &[("onlyA", &["B::b"]), ("v", &["B::b"])],
+    );
+}
+
+#[test]
+fn expose_ignores_visibility_but_filter_package_inner_import_keeps_its_policy() {
+    check(
+        "package A {private part hidden; part visible;}",
+        "view allExposure {expose A::*;} view exact {expose A::hidden;} view wrapped {expose A::*[true];}",
+        &[
+            ("allExposure", &["A::hidden", "A::visible"]),
+            ("exact", &["A::hidden"]),
+            ("wrapped", &["A::visible"]),
+        ],
+    );
+}
+
+#[test]
+fn recursive_import_cycles_terminate_without_losing_later_direct_exposures() {
+    check(
+        "package A {part a; public import B::*;} package B {part b; public import A::*;}",
+        "view onlyA {expose A::*;} view v {expose A::*; expose B::b;}",
+        &[("onlyA", &["A::a", "B::b"]), ("v", &["A::a", "B::b"])],
+    );
+}
+
+#[test]
+fn unknown_conditions_retain_compatibility_admission() {
+    check(
+        "package A {part a;}",
+        "view v {expose A::*; filter missing;}",
+        &[("v", &["A::a"])],
+    );
+}
+
+#[test]
+fn self_exposure_uses_an_empty_operation_exclusion_set() {
+    check("", "view v {part a; expose v::*;}", &[("v", &["v::a"])]);
+}
+
+#[test]
+fn imported_view_conditions_apply_including_private_imports() {
+    check(
+        "package A {part a;} package F {filter false;} view def RejectImported {public import F::*;}",
+        "view rejected {import F::*; expose A::*;}
+         view privateRejected {private import F::*; expose A::*;}
+         view inherited:RejectImported {expose A::*;}",
+        &[
+            ("rejected", &[]),
+            ("privateRejected", &[]),
+            ("inherited", &[]),
+        ],
+    );
+}
+
+#[test]
+fn exposed_type_inheritance_keeps_only_surviving_memberships() {
+    check(
+        "part def B {part x;} part def D :> B {part redefines x;} package P {public import all D::*;}",
+        "view direct {expose D::*;} view indirect {expose P::*;}",
+        &[("direct", &["D::x"]), ("indirect", &["D::x"])],
+    );
+}
+
+#[test]
+fn separate_exposes_preserve_distinct_same_named_elements() {
+    check(
+        "package A {part x;} package B {part x;}",
+        "view v {expose A::*; expose B::*;}",
+        &[("v", &["A::x", "B::x"])],
+    );
+}
+
+#[test]
+fn rejected_containers_do_not_block_matching_recursive_children() {
+    check(
+        "metadata def M; package A {package N {#M part child;}}",
+        "view v {expose A::**; filter @M;}",
+        &[("v", &["A::N::child"])],
+    );
+}
+
+#[test]
+fn inherited_back_imports_do_not_escape_current_namespace_exclusions() {
+    check(
+        "package P {package N {part child;} public import D::*;}
+         part def C {public import P::**;} part def D :> C;",
+        "view v {expose P::*;}",
+        &[("v", &["P::N", "P"])],
+    );
+}
+
+#[test]
+fn import_all_preserves_private_members_admitted_by_inherited_imports() {
+    check(
+        "package P {private part hidden;}
+         part def B {protected import all P::*;} part def D :> B;",
+        "view v {expose D::*;} view wrapped {expose D::*[true];}",
+        &[("v", &["P::hidden"]), ("wrapped", &[])],
+    );
+}
+
+#[test]
+fn qualified_metadata_attributes_require_the_cast_types_member_identity() {
+    check(
+        "metadata def Flag {attribute enabled; alias toggle for enabled;} metadata def Other {attribute enabled;}
+         package Parts {part yes {@Flag {enabled=true;}} part no {@Flag {enabled=false;}}}",
+        "view bare {expose Parts::*[@Flag and (as Flag).enabled];}
+         view qualified {expose Parts::*[@Flag and (as Flag).$::Flag::enabled];}
+         view aliased {expose Parts::*[@Flag and (as Flag).$::Flag::toggle];}
+         view unrelated {expose Parts::*[@Flag and (as Flag).$::Other::enabled];}",
+        &[
+            ("bare", &["Parts::yes"]),
+            ("qualified", &["Parts::yes"]),
+            ("aliased", &["Parts::yes"]),
+            // An unrelated declaration cannot select a same-named value.
+            // Unknown conditions retain compatibility admission.
+            ("unrelated", &["Parts::yes", "Parts::no"]),
+        ],
+    );
+}
+
+#[test]
+fn ambiguous_metadata_attribute_values_remain_unknown() {
+    check(
+        "metadata def Flag {attribute enabled;}
+         package Parts {part item1 {@Flag {enabled=false; enabled=true;}}}",
+        "view bare {expose Parts::*[@Flag and (as Flag).enabled];}
+         view qualified {expose Parts::*[@Flag and (as Flag).$::Flag::enabled];}",
+        &[
+            ("bare", &["Parts::item1"]),
+            ("qualified", &["Parts::item1"]),
+        ],
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/expression_fixed_roles.rs b/crates/sysmlv2-parser/tests/expression_fixed_roles.rs
new file mode 100644
index 0000000..391c51b
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/expression_fixed_roles.rs
@@ -0,0 +1,157 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+
+#[test]
+fn actual_library_boolean_and_invariant_roles_preserve_sysml_bases_and_source_graph() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        eprintln!("skipping: standard library unavailable");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).unwrap();
+    for (path, source) in [
+        (
+            "fixed-roles.kerml",
+            "package K { bool plain; inv true positive; inv false negative; }",
+        ),
+        (
+            "fixed-roles.sysml",
+            "package S { constraint plain {true} assert constraint positive {true} assert not constraint negative {false} }",
+        ),
+    ] {
+        let parsed = model.add_source(path, source);
+        assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    }
+    let compact = model_to_compact_json(&model);
+    let mut r = ResolvedModel::build(&model);
+    let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let evaluations = r.resolve_qualified("Performances::evaluations").unwrap();
+    let boolean = r
+        .resolve_qualified("Performances::booleanEvaluations")
+        .unwrap();
+    let system_base = r
+        .resolve_qualified("Constraints::constraintChecks")
+        .unwrap();
+    let cases: Vec<_> = [
+        (
+            "K::plain",
+            "BooleanExpression",
+            "Performances::booleanEvaluations",
+            None,
+            false,
+        ),
+        (
+            "K::positive",
+            "Invariant",
+            "Performances::trueEvaluations",
+            Some(false),
+            false,
+        ),
+        (
+            "K::negative",
+            "Invariant",
+            "Performances::falseEvaluations",
+            Some(true),
+            false,
+        ),
+        (
+            "S::plain",
+            "ConstraintUsage",
+            "Performances::booleanEvaluations",
+            None,
+            true,
+        ),
+        (
+            "S::positive",
+            "AssertConstraintUsage",
+            "Performances::trueEvaluations",
+            Some(false),
+            true,
+        ),
+        (
+            "S::negative",
+            "AssertConstraintUsage",
+            "Performances::falseEvaluations",
+            Some(true),
+            true,
+        ),
+    ]
+    .into_iter()
+    .map(|(name, ty, role, negated, sysml)| {
+        let owner = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.element_type(owner), ty);
+        (owner, r.resolve_qualified(role).unwrap(), negated, sysml)
+    })
+    .collect();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let mut ids = Vec::new();
+        for &(owner, role, negated, sysml) in &cases {
+            assert!(r.conforms_with_implied(owner, role));
+            assert!(r.conforms_with_implied(owner, boolean));
+            assert!(r.conforms_with_implied(owner, evaluations));
+            if let Some(negated) = negated {
+                assert_eq!(
+                    r.property(owner, "isNegated").unwrap(),
+                    serde_json::json!(negated)
+                );
+            }
+            let edges = r.implied_relationships(owner);
+            if sysml {
+                assert!(r.conforms_with_implied(owner, system_base));
+                // The new assert-specific role reaches constraintChecks;
+                // only plain ConstraintUsage keeps that direct requirement.
+                let direct = edges
+                    .iter()
+                    .filter(|&&edge| {
+                        r.element_properties(edge)["subsettedFeature"]["@id"]
+                            == r.element_id(system_base).to_string()
+                    })
+                    .count();
+                assert_eq!(direct, usize::from(negated.is_none()));
+            }
+            assert!(
+                !edges.iter().any(
+                    |&edge| r.element_properties(edge)["subsettedFeature"]["@id"]
+                        == r.element_id(evaluations).to_string()
+                ),
+                "redundant generic edge"
+            );
+            if role != boolean {
+                assert!(
+                    !edges.iter().any(
+                        |&edge| r.element_properties(edge)["subsettedFeature"]["@id"]
+                            == r.element_id(boolean).to_string()
+                    ),
+                    "redundant Boolean edge"
+                );
+            }
+            ids.extend(edges.into_iter().map(|edge| r.element_id(edge)));
+        }
+        if let Some(expected) = &expected {
+            assert_eq!(&ids, expected);
+        } else {
+            expected = Some(ids);
+        }
+    }
+    assert_eq!(
+        before,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(model_to_compact_json(&model), compact);
+}
diff --git a/crates/sysmlv2-parser/tests/expression_static_ancestry.rs b/crates/sysmlv2-parser/tests/expression_static_ancestry.rs
new file mode 100644
index 0000000..fba2b5c
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/expression_static_ancestry.rs
@@ -0,0 +1,193 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+
+#[test]
+fn actual_library_expression_ancestry_preserves_compact_graph_and_specific_bases() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        eprintln!("skipping: standard library unavailable");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).unwrap();
+    assert!(model.add_source("expression-static.kerml", "class C {feature slot;} feature receiver:C; feature referenced=receiver; feature chained=receiver.slot; feature body={1}; feature plus=1+2; feature indexed=receiver#(1); feature selected=receiver.?{in p; true}; feature collected=receiver.{in p; p}; expr declared; expr already subsets Performances::evaluations; bool boolean; inv true invariant {true} function F {return result;} feature invoked=F(); feature constructed=new C();").diagnostics.is_empty());
+    let compact = model_to_compact_json(&model);
+    let mut r = ResolvedModel::build(&model);
+    let target = r.resolve_qualified("Performances::evaluations").unwrap();
+    let target_id = r.element_id(target).to_string();
+    let kinds = [
+        "Expression",
+        "FeatureReferenceExpression",
+        "FeatureChainExpression",
+        "OperatorExpression",
+        "IndexExpression",
+        "SelectExpression",
+        "CollectExpression",
+        "BooleanExpression",
+        "Invariant",
+        "InvocationExpression",
+        "ConstructorExpression",
+        "LiteralInteger",
+        "LiteralBoolean",
+    ];
+    let expressions: Vec<_> = r
+        .user_elements()
+        .filter(|&e| kinds.contains(&r.element_type(e)))
+        .collect();
+    for kind in kinds {
+        assert!(
+            expressions.iter().any(|&e| r.element_type(e) == kind),
+            "missing fixture {kind}"
+        );
+    }
+    let before: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let mut edges = Vec::new();
+        for &expression in &expressions {
+            assert!(
+                r.conforms_with_implied(expression, target),
+                "{}",
+                r.element_type(expression)
+            );
+            let specific = match r.element_type(expression) {
+                "ConstructorExpression" => Some("Performances::constructorEvaluations"),
+                "LiteralInteger" => Some("Performances::literalIntegerEvaluations"),
+                "LiteralBoolean" => Some("Performances::literalBooleanEvaluations"),
+                _ => None,
+            };
+            let relationships = r.implied_relationships(expression);
+            if let Some(specific) = specific {
+                let base = r.resolve_qualified(specific).unwrap();
+                assert!(r.conforms_with_implied(expression, base));
+                assert!(
+                    !relationships
+                        .iter()
+                        .any(|&rel| r.element_properties(rel)["subsettedFeature"]["@id"]
+                            == target_id),
+                    "redundant generic base on {}",
+                    r.element_type(expression)
+                );
+            }
+            edges.extend(relationships.into_iter().map(|rel| r.element_id(rel)));
+        }
+        if let Some(expected) = &expected {
+            assert_eq!(&edges, expected);
+        } else {
+            expected = Some(edges);
+        }
+    }
+    assert_eq!(
+        before,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(model_to_compact_json(&model), compact);
+}
+
+#[test]
+fn parsed_sysml_expression_usages_keep_specific_roles_without_redundant_evaluations() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        eprintln!("skipping: standard library unavailable");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).unwrap();
+    assert!(model.add_source("expression-usages.sysml", "package P { calc calculated {1} constraint constrained {true} assert constraint asserted {true} }").diagnostics.is_empty());
+    let compact = model_to_compact_json(&model);
+    let mut r = ResolvedModel::build(&model);
+    let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let evaluations = r.resolve_qualified("Performances::evaluations").unwrap();
+    let evaluations_id = r.element_id(evaluations).to_string();
+    let usages: Vec<_> = [
+        (
+            "P::calculated",
+            "CalculationUsage",
+            "Calculations::calculations",
+        ),
+        (
+            "P::constrained",
+            "ConstraintUsage",
+            "Constraints::constraintChecks",
+        ),
+        (
+            "P::asserted",
+            "AssertConstraintUsage",
+            "Constraints::assertedConstraintChecks",
+        ),
+    ]
+    .into_iter()
+    .map(|(name, metaclass, role)| {
+        let element = r.resolve_qualified(name).unwrap();
+        assert_eq!(r.element_type(element), metaclass);
+        let role = r.resolve_qualified(role).unwrap();
+        (element, role)
+    })
+    .collect();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let mut relationship_ids = Vec::new();
+        for &(usage, role) in &usages {
+            assert!(r.conforms_with_implied(usage, role));
+            assert!(r.conforms_with_implied(usage, evaluations));
+            let role_id = r.element_id(role).to_string();
+            let relationships = r.implied_relationships(usage);
+            assert_eq!(
+                relationships
+                    .iter()
+                    .filter(|&&rel| {
+                        r.element_type(rel) == "Subsetting"
+                            && r.element_properties(rel)["subsettedFeature"]["@id"] == role_id
+                    })
+                    .count(),
+                1,
+                "specific role on {}",
+                r.element_type(usage)
+            );
+            assert!(
+                !relationships.iter().any(|&rel| {
+                    r.element_type(rel) == "Subsetting"
+                        && r.element_properties(rel)["subsettedFeature"]["@id"] == evaluations_id
+                }),
+                "redundant generic role on {}",
+                r.element_type(usage)
+            );
+            relationship_ids.extend(relationships.into_iter().map(|rel| r.element_id(rel)));
+        }
+        if let Some(expected) = &expected {
+            assert_eq!(&relationship_ids, expected);
+        } else {
+            expected = Some(relationship_ids);
+        }
+    }
+    assert_eq!(
+        source_ids,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(model_to_compact_json(&model), compact);
+}
diff --git a/crates/sysmlv2-parser/tests/feature_chain_static_typing.rs b/crates/sysmlv2-parser/tests/feature_chain_static_typing.rs
new file mode 100644
index 0000000..1f22326
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/feature_chain_static_typing.rs
@@ -0,0 +1,108 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel, model_to_compact_json},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+const LIB: &str = "standard library package ControlFunctions {function '.' {in source {feature target;} return result;}}";
+const USER: &str = "class A {feature x;} feature a:A; feature y=a.x;";
+fn refs(r: &mut ResolvedModel, e: ElementRef, property: &str) -> Vec<ElementRef> {
+    match r.derived(e, property) {
+        Derived::Value(value) => value.elements(),
+        other => panic!("{property}: {other:?}"),
+    }
+}
+#[test]
+fn fixed_chain_typing_and_input_redefinition_replay_without_promoting_function() {
+    let mut base = Model::new();
+    base.add_library_source("fixed-dot-library.kerml", LIB);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(118).unwrap(), 118).unwrap());
+    let mut expected = None;
+    for mode in 0..4 {
+        let mut model = Model::new();
+        match mode {
+            2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+            3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+            _ => {
+                model.add_library_source("fixed-dot-library.kerml", LIB);
+                if mode == 1 {
+                    model.set_library_cache(cache.clone());
+                }
+            }
+        }
+        assert!(
+            model
+                .add_source("fixed-dot-user.kerml", USER)
+                .diagnostics
+                .is_empty()
+        );
+        let compact = model_to_compact_json(&model);
+        let mut r = ResolvedModel::build(&model);
+        let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let chain = r
+            .user_elements()
+            .find(|&e| r.element_type(e) == "FeatureChainExpression")
+            .unwrap();
+        let dot = r.resolve_qualified("ControlFunctions::'.'").unwrap();
+        let source = r
+            .resolve_qualified("ControlFunctions::'.'::source")
+            .unwrap();
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            let typing: Vec<_> = r
+                .implied_relationships(chain)
+                .into_iter()
+                .filter(|&e| r.element_type(e) == "FeatureTyping")
+                .collect();
+            assert_eq!(typing.len(), 1);
+            assert_eq!(
+                r.element_properties(typing[0])["type"]["@id"],
+                r.element_id(dot).to_string()
+            );
+            let input = refs(&mut r, chain, "ownedFeature")
+                .into_iter()
+                .find(|&e| r.element_properties(e)["direction"] == "in")
+                .unwrap();
+            let redefinitions: Vec<_> = r
+                .implied_relationships(input)
+                .into_iter()
+                .filter(|&e| r.element_type(e) == "Redefinition")
+                .collect();
+            assert_eq!(redefinitions.len(), 1);
+            assert_eq!(
+                r.element_properties(redefinitions[0])["redefinedFeature"]["@id"],
+                r.element_id(source).to_string()
+            );
+            let ids = (r.element_id(typing[0]), r.element_id(redefinitions[0]));
+            if let Some(old) = expected {
+                assert_eq!(old, ids);
+            } else {
+                expected = Some(ids);
+            }
+            assert!(r.feature_type_report(chain).function.is_err());
+        }
+        assert_eq!(
+            source_ids,
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(compact, model_to_compact_json(&model));
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/feature_library_bases.rs b/crates/sysmlv2-parser/tests/feature_library_bases.rs
new file mode 100644
index 0000000..97f912d
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/feature_library_bases.rs
@@ -0,0 +1,229 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{json::ResolvedModel, model::Model};
+
+#[test]
+fn ordinary_features_inherit_the_kernel_base_members() {
+    let mut model = Model::new();
+    model.add_library_source("base.kerml", "standard library package Base { classifier Anything; feature things : Anything { feature that : Anything; } }");
+    model.add_source(
+        "features.kerml",
+        "package P { class C; feature outer : C { feature inner subsets that; } }",
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    assert!(r.unresolved_references().is_empty());
+    let that = r.resolve_qualified("Base::things::that").unwrap();
+    assert_eq!(r.resolve_qualified("P::outer::that"), Some(that));
+    assert_eq!(r.resolve_qualified("P::outer::inner::that"), Some(that));
+}
+
+#[test]
+fn occurrence_library_features_resolve_their_featuring_instance() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let r = ResolvedModel::build(&model);
+    let unresolved = r.unresolved_references();
+    let failures: Vec<_> = unresolved
+        .iter()
+        .filter(|reference| {
+            model
+                .unit(reference.unit)
+                .name
+                .ends_with("Occurrences.kerml")
+                && reference.spelling == "that"
+        })
+        .collect();
+    assert!(failures.is_empty(), "{failures:?}");
+}
+
+#[test]
+fn inherited_kernel_base_names_do_not_override_owned_names() {
+    let mut model = Model::new();
+    model.add_library_source("base.kerml", "standard library package Base { classifier Anything; feature things : Anything { feature that : Anything; } }");
+    model.add_source(
+        "features.kerml",
+        "package P { feature outer { feature that; feature inner subsets that; } }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    assert!(r.unresolved_references().is_empty());
+    let own = r.resolve_qualified("P::outer::that").unwrap();
+    assert_ne!(Some(own), r.resolve_qualified("Base::things::that"));
+    let inner = r.resolve_qualified("P::outer::inner").unwrap();
+    let subsetting = r
+        .owned_relationships(inner)
+        .into_iter()
+        .find(|&rel| r.element_type(rel) == "Subsetting")
+        .unwrap();
+    assert_eq!(
+        r.relationship_ends(subsetting).1,
+        vec![sysmlv2_parser::json::Reference::Element(own)]
+    );
+}
+
+#[test]
+fn prepared_features_preserve_inherited_kernel_members() {
+    let mut base = Model::new();
+    base.add_library_source("base.kerml", "standard library package Base { classifier Anything; feature things : Anything { feature that : Anything; } } package L { feature outer { feature inner subsets that; } }");
+    let prepared = base.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(1).unwrap(), 1)
+            .unwrap(),
+    );
+    for library in [prepared, decoded] {
+        let mut model = Model::new();
+        library.install(&mut model).unwrap();
+        model.add_source("user.kerml", "feature test subsets L::outer::that;");
+        let mut r = ResolvedModel::build(&model);
+        assert!(r.unresolved_references().is_empty());
+        assert_eq!(
+            r.resolve_qualified("L::outer::that"),
+            r.resolve_qualified("Base::things::that")
+        );
+    }
+}
+
+const PERFORMANCE_LIBRARY: &str = "standard library package Base { classifier Anything; feature things : Anything; }
+standard library package Performances { behavior Performance specializes Base::Anything { feature startShot; } step performances : Performance subsets Base::things; }";
+
+fn assert_step_base(mut r: ResolvedModel) {
+    assert!(
+        r.unresolved_references().is_empty(),
+        "{:?}",
+        r.unresolved_references()
+    );
+    let base = r.resolve_qualified("Performances::performances").unwrap();
+    let inherited = r
+        .resolve_qualified("Performances::Performance::startShot")
+        .unwrap();
+    for name in ["P::untyped", "P::indirect"] {
+        let step = r.resolve_qualified(name).unwrap();
+        assert_eq!(
+            r.resolve_qualified(&format!("{name}::startShot")),
+            Some(inherited)
+        );
+        assert!(r.conforms_with_implied(step, base));
+    }
+    let own = r.resolve_qualified("P::shadow::startShot").unwrap();
+    assert_ne!(own, inherited);
+    // A plain Feature does not gain Step's performance-specific members.
+    assert!(r.resolve_qualified("P::ordinary::startShot").is_none());
+    assert!(!r.implied_relationships(base).into_iter().any(|edge| {
+        r.element_type(edge) == "Subsetting"
+            && r.relationship_ends(edge).1 == vec![sysmlv2_parser::json::Reference::Element(base)]
+    }));
+}
+
+#[test]
+fn untyped_steps_inherit_and_materialize_the_performance_base() {
+    let mut model = Model::new();
+    model.add_library_source("performances.kerml", PERFORMANCE_LIBRARY);
+    model.add_source("steps.kerml", "package P { step untyped; step indirect subsets untyped; step shadow { feature startShot; } feature ordinary; feature use subsets untyped.startShot; }");
+    assert!(!model.has_errors());
+    assert_step_base(ResolvedModel::build(&model));
+}
+
+#[test]
+fn prepared_steps_preserve_the_performance_base() {
+    let mut base = Model::new();
+    base.add_library_source("performances.kerml", PERFORMANCE_LIBRARY);
+    base.add_library_source("steps.kerml", "package P { step untyped; step indirect subsets untyped; step shadow { feature startShot; } feature ordinary; }");
+    let prepared = base.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(1).unwrap(), 1)
+            .unwrap(),
+    );
+    for library in [prepared, decoded] {
+        let mut model = Model::new();
+        library.install(&mut model).unwrap();
+        model.add_source("use.kerml", "feature use subsets P::untyped.startShot;");
+        assert_step_base(ResolvedModel::build(&model));
+    }
+}
+
+#[test]
+fn state_performance_library_steps_resolve_their_occurrence_members() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let r = ResolvedModel::build(&model);
+    let failures: Vec<_> = r
+        .unresolved_references()
+        .into_iter()
+        .filter(|reference| {
+            model
+                .unit(reference.unit)
+                .name
+                .ends_with("StatePerformances.kerml")
+        })
+        .collect();
+    assert!(failures.is_empty(), "{failures:?}");
+}
+
+#[test]
+fn metaclasses_inherit_and_materialize_the_metaobject_base() {
+    let mut model = Model::new();
+    model.add_library_source("metaobjects.kerml", "standard library package Metaobjects { metaclass Metaobject { feature annotatedElement; } }");
+    model.add_source("metadata.kerml", "package P { metaclass M { feature annotatedElement redefines annotatedElement; } metaclass N specializes M; class Ordinary; }");
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    assert!(r.unresolved_references().is_empty());
+    let base = r.resolve_qualified("Metaobjects::Metaobject").unwrap();
+    let annotation = r
+        .resolve_qualified("Metaobjects::Metaobject::annotatedElement")
+        .unwrap();
+    let own = r.resolve_qualified("P::M::annotatedElement").unwrap();
+    assert_ne!(own, annotation);
+    assert_eq!(r.resolve_qualified("P::N::annotatedElement"), Some(own));
+    assert!(
+        r.resolve_qualified("P::Ordinary::annotatedElement")
+            .is_none()
+    );
+    for name in ["P::M", "P::N"] {
+        let metaclass = r.resolve_qualified(name).unwrap();
+        assert!(r.conforms_with_implied(metaclass, base));
+    }
+    let redefinition = r
+        .owned_relationships(own)
+        .into_iter()
+        .find(|&r0| r.element_type(r0) == "Redefinition")
+        .unwrap();
+    assert_eq!(
+        r.relationship_ends(redefinition).1,
+        vec![sysmlv2_parser::json::Reference::Element(annotation)]
+    );
+}
+
+#[test]
+fn metamodel_library_resolves_its_inherited_annotation_member() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let prepared = model.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(1).unwrap(), 1)
+            .unwrap(),
+    );
+    let mut resolved = vec![ResolvedModel::build(&model)];
+    for library in [prepared, decoded] {
+        let mut installed = Model::new();
+        library.install(&mut installed).unwrap();
+        installed.add_source(
+            "use.kerml",
+            "metaclass Example specializes KerML::Root::Annotation;",
+        );
+        resolved.push(ResolvedModel::build(&installed));
+    }
+    for r in resolved {
+        let failures: Vec<_> = r
+            .unresolved_references()
+            .into_iter()
+            .filter(|reference| reference.spelling == "annotatedElement")
+            .collect();
+        assert!(failures.is_empty(), "{failures:?}");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/feature_type_report.rs b/crates/sysmlv2-parser/tests/feature_type_report.rs
new file mode 100644
index 0000000..2d85ece
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/feature_type_report.rs
@@ -0,0 +1,119 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::{
+    json::{FeatureTypeIssue, ResolvedModel},
+    model::Model,
+};
+const LIBRARY: &str = "standard library package Base {classifier Anything; feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything; feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence; function Evaluation specializes Performance; step performances:Performance subsets Occurrences::occurrences; expr evaluations:Evaluation subsets performances;}";
+fn fixture(source: &str) -> ResolvedModel {
+    fixture_with_library(source, LIBRARY)
+}
+fn fixture_with_library(source: &str, library: &str) -> ResolvedModel {
+    let mut m = Model::new();
+    assert!(
+        m.add_library_source("type-library.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    assert!(
+        m.add_source("type-user.kerml", source)
+            .diagnostics
+            .is_empty()
+    );
+    ResolvedModel::build(&m)
+}
+#[test]
+fn complete_properties_share_one_projection_and_preserve_identity() {
+    let mut r = fixture(
+        "function F specializes Performances::Evaluation; expr e:F subsets Performances::evaluations;",
+    );
+    let e = r.resolve_qualified("e").unwrap();
+    let f = r.resolve_qualified("F").unwrap();
+    let before = r.elements().map(|e| r.element_id(e)).collect::<Vec<_>>();
+    let first = r.feature_type_report(e);
+    assert_eq!(first.types, Ok(vec![f]));
+    assert_eq!(first.behavior, Ok(vec![f]));
+    assert_eq!(first.function, Ok(Some(f)));
+    assert!(first.steps > 0);
+    for _ in 0..3 {
+        let again = r.feature_type_report(e);
+        assert_eq!(again.types, first.types);
+        assert_eq!(again.function, first.function);
+    }
+    assert_eq!(
+        r.elements().map(|e| r.element_id(e)).collect::<Vec<_>>(),
+        before
+    );
+}
+#[test]
+fn incomplete_function_and_types_are_errors_never_empty_success() {
+    let library = LIBRARY.replace(
+        "expr evaluations:Evaluation subsets performances;",
+        "expr evaluations:Evaluation;",
+    );
+    assert_ne!(library, LIBRARY);
+    // Expression's Step ancestry supplies this omitted authored edge.
+    let mut complete = fixture_with_library(
+        "function F specializes Performances::Evaluation; expr e:F;",
+        &library,
+    );
+    let e = complete.resolve_qualified("e").unwrap();
+    let f = complete.resolve_qualified("F").unwrap();
+    let report = complete.feature_type_report(e);
+    assert_eq!(report.types, Ok(vec![f]));
+    assert_eq!(report.function, Ok(Some(f)));
+
+    // Remove the required canonical Feature, not merely its authored edge.
+    // No authored endpoint is unresolved: the missing implied family itself
+    // must remain an error, rather than becoming an empty successful result.
+    let library = library.replace(
+        "step performances:Performance subsets Occurrences::occurrences;",
+        "",
+    );
+    let mut r = fixture_with_library(
+        "function F specializes Performances::Evaluation; expr e:F; feature call=F();",
+        &library,
+    );
+    assert!(r.resolve_qualified("Performances::evaluations").is_some());
+    assert!(r.resolve_qualified("Performances::performances").is_none());
+    assert!(r.resolve_qualified("Performances::Performance").is_some());
+    let e = r.resolve_qualified("e").unwrap();
+    let report = r.feature_type_report(e);
+    assert_eq!(report.types, Err(FeatureTypeIssue::MissingRequiredFamilies));
+    assert_eq!(
+        report.function,
+        Err(FeatureTypeIssue::MissingRequiredFamilies)
+    );
+    let call = r.resolve_qualified("call").unwrap();
+    let invocation = r.members_via(call, "FeatureValue")[0];
+    let report = r.feature_type_report(invocation);
+    assert!(report.types.is_err());
+    assert!(report.function.is_err());
+    let f = r.resolve_qualified("F").unwrap();
+    assert_eq!(
+        r.feature_type_report(f).types,
+        Err(FeatureTypeIssue::InvalidElement)
+    );
+}
+#[test]
+fn property_applicability_is_distinct_from_missing_evidence() {
+    let mut r = fixture("feature x:Base::Anything subsets Base::things;");
+    let x = r.resolve_qualified("x").unwrap();
+    let anything = r.resolve_qualified("Base::Anything").unwrap();
+    let report = r.feature_type_report(x);
+    assert_eq!(report.types, Ok(vec![anything]));
+    assert_eq!(report.behavior, Err(FeatureTypeIssue::NotApplicable));
+    assert_eq!(report.function, Err(FeatureTypeIssue::NotApplicable));
+    let mut m = Model::new();
+    assert!(
+        m.add_source("no-library.kerml", "feature x;")
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    let x = r.resolve_qualified("x").unwrap();
+    assert_eq!(
+        r.feature_type_report(x).types,
+        Err(FeatureTypeIssue::MissingRequiredFamilies)
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/filter_identity.rs b/crates/sysmlv2-parser/tests/filter_identity.rs
new file mode 100644
index 0000000..dc5e853
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/filter_identity.rs
@@ -0,0 +1,247 @@
+//! Filter execution and diagnostics retain declaration source across replay.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    check, json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+
+fn models(a: &str, b: &str, filters_in_library: bool) -> Vec<Model> {
+    let scalars = "package ScalarValues { datatype Integer; datatype Boolean; }";
+    let mut base = Model::new();
+    base.add_library_source("scalar.kerml", scalars);
+    if filters_in_library {
+        base.add_library_source("A.sysml", a);
+        base.add_library_source("B.sysml", b);
+    }
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("scalar.kerml", scalars);
+                    if filters_in_library {
+                        m.add_library_source("A.sysml", a);
+                        m.add_library_source("B.sysml", b);
+                    }
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            if !filters_in_library {
+                m.add_source("A.sysml", a);
+                m.add_source("B.sysml", b);
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+
+#[test]
+fn import_and_expose_filters_use_their_own_source_identity() {
+    for form in ["namespace", "membership", "standalone", "expose"] {
+        for reverse in [false, true] {
+            let filter = match form {
+                "namespace" => format!("package View {{ public import Items::*[@'{ID}']; }}"),
+                "membership" => format!("package View {{ public import Items::X[@'{ID}']; }}"),
+                "standalone" => {
+                    format!("package View {{ filter @'{ID}'; public import Items::*; }}")
+                }
+                _ => format!("view def View {{ expose Items::*[@'{ID}']; }}"),
+            };
+            let annotation = if reverse {
+                format!("'{ID}'")
+            } else {
+                "Actual".into()
+            };
+            let source = |pkg| {
+                format!(
+                    "package {pkg} {{ metadata def Actual; metadata def '{ID}'; package Items {{ #{annotation} part def X; }} {filter} }}"
+                )
+            };
+            let a = source("A");
+            let b = source("B");
+            for library in [false, true] {
+                for (mode, model) in models(&a, &b, library).into_iter().enumerate() {
+                    let mut r = ResolvedModel::build(&model);
+                    if !library {
+                        let actual = r.resolve_qualified("A::Actual").unwrap();
+                        let view = r.resolve_qualified("A::View").unwrap();
+                        let candidates = r.elements_of_metaclass("FeatureTyping");
+                        let edge = candidates
+                            .into_iter()
+                            .find(|&edge| {
+                                let mut owner = r.owner(edge);
+                                while let Some(e) = owner {
+                                    if e == view {
+                                        return true;
+                                    }
+                                    owner = r.owner(e);
+                                }
+                                false
+                            })
+                            .unwrap();
+                        r.override_ids(&HashMap::from([(
+                            r.element_id(actual),
+                            ID.parse().unwrap(),
+                        )]));
+                        let mut hints = HashMap::from([(
+                            (r.element_id(edge), "type".into()),
+                            ID.parse().unwrap(),
+                        )]);
+                        assert!(
+                            r.bind_id_spelled_references_with(&mut hints)
+                                .contains(&ID.parse().unwrap())
+                        );
+                    }
+                    for pkg in ["B", "A", "A", "B"] {
+                        let view = r.resolve_qualified(&format!("{pkg}::View")).unwrap();
+                        let members = if form == "expose" {
+                            r.view_exposed_elements(view)
+                        } else {
+                            r.imported_memberships(view)
+                        };
+                        let expected = usize::from(if library {
+                            reverse
+                        } else {
+                            (pkg == "A") != reverse
+                        });
+                        assert_eq!(
+                            members.len(),
+                            expected,
+                            "{form} reverse={reverse} library={library} mode={mode} {pkg}"
+                        );
+                    }
+                    if mode == 3 {
+                        assert_eq!(model.loaded_library_unit_count(), 0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn root_filter_diagnostics_have_their_own_unit_and_span() {
+    for (mode, mut model) in models("package A;", "package B;", false)
+        .into_iter()
+        .enumerate()
+    {
+        let bad = "filter 1; import A::*[2];";
+        let good = "filter true; import B::*[true];";
+        model.add_source("bad.kerml", bad);
+        model.add_source("good.kerml", good);
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        if mode == 3 {
+            // Root filters affect library root imports and require joint resolution.
+            assert_eq!(model.loaded_library_unit_count(), 1);
+        }
+        for _ in 0..2 {
+            let found: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                .into_iter()
+                .filter(|(_, d)| d.code == Some("validateElementFilterMembershipIsBoolean"))
+                .collect();
+            assert_eq!(found.len(), 2, "mode {mode}: {found:?}");
+            let mut values = Vec::new();
+            for (u, d) in found {
+                assert_eq!(model.unit(u).name, "bad.kerml");
+                values.push(&bad[d.span.start as usize..d.span.end as usize]);
+            }
+            values.sort();
+            assert_eq!(values, ["1", "2"]);
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 1);
+        }
+    }
+}
+
+#[test]
+fn metadata_attribute_filter_preserves_source_bound_identity() {
+    let source = |package| {
+        format!(
+            "package {package} {{ metadata def Flag {{attribute actual; attribute '{ID}';}} \
+         package Items {{part X {{@Flag {{actual=false; '{ID}'=true;}}}}}} \
+         view View {{expose Items::*[(as Flag).'{ID}'];}} }}"
+        )
+    };
+    for (mode, model) in models(&source("A"), &source("B"), false)
+        .into_iter()
+        .enumerate()
+    {
+        let loaded = model.loaded_library_unit_count();
+        let mut r = ResolvedModel::build(&model);
+        let actual = r.resolve_qualified("A::Flag::actual").unwrap();
+        let view = r.resolve_qualified("A::View").unwrap();
+        let mut members = Vec::new();
+        for edge in r.elements_of_metaclass("Membership") {
+            let Some(chain) = r.owner(edge) else { continue };
+            if r.element_type(chain) != "FeatureChainExpression" {
+                continue;
+            }
+            let mut owner = r.owner(chain);
+            while let Some(element) = owner {
+                if element == view {
+                    members.push(edge);
+                    break;
+                }
+                owner = r.owner(element);
+            }
+        }
+        assert_eq!(members.len(), 1);
+        let edge = members[0];
+        r.override_ids(&HashMap::from([(
+            r.element_id(actual),
+            ID.parse().unwrap(),
+        )]));
+        let mut hints = HashMap::from([(
+            (r.element_id(edge), "memberElement".into()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        for package in ["B", "A", "A", "B"] {
+            let view = r.resolve_qualified(&format!("{package}::View")).unwrap();
+            let exposed = r.view_exposed_elements(view);
+            // A's identical spelling/span is bound to actual=false; B keeps
+            // its lexical UUID-shaped attribute=true in its own source unit.
+            let expected = if package == "A" {
+                Vec::new()
+            } else {
+                vec![r.resolve_qualified("B::Items::X").unwrap()]
+            };
+            assert_eq!(exposed, expected, "mode {mode}, package {package}");
+        }
+        // Rebinding the target UUID must preserve A's source-site identity,
+        // while B's lexical UUID-shaped declaration stays lexical.
+        let rebound = "99999999-9999-4999-8999-999999999999".parse().unwrap();
+        r.override_ids(&HashMap::from([(ID.parse().unwrap(), rebound)]));
+        let a = r.resolve_qualified("A::View").unwrap();
+        let b = r.resolve_qualified("B::View").unwrap();
+        assert!(
+            r.view_exposed_elements(a).is_empty(),
+            "remapped mode {mode}"
+        );
+        let bx = r.resolve_qualified("B::Items::X").unwrap();
+        assert_eq!(r.view_exposed_elements(b), vec![bx], "remapped mode {mode}");
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+        if mode == 3 {
+            assert_eq!(loaded, 0);
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/fixtures/full-form-baseline.tsv b/crates/sysmlv2-parser/tests/fixtures/full-form-baseline.tsv
index 5990bc0..9a3402b 100644
--- a/crates/sysmlv2-parser/tests/fixtures/full-form-baseline.tsv
+++ b/crates/sysmlv2-parser/tests/fixtures/full-form-baseline.tsv
@@ -25,20 +25,20 @@ AcceptActionUsage	inheritedFeature	f754965b3c37d264	103	0
 AcceptActionUsage	inheritedMembership	f754965b3c37d264	103	0
 AcceptActionUsage	input	7eb87ade6e9a9f45	103	103
 AcceptActionUsage	intersectingType	f754965b3c37d264	103	0
-AcceptActionUsage	isAbstract	c8d27cdba36882f9	103	0
+AcceptActionUsage	isAbstract	d1b0bbcdf1e10a4d	103	0
 AcceptActionUsage	isComposite	2110b307b7176b78	103	103
 AcceptActionUsage	isConjugated	d1b0bbcdf1e10a4d	103	0
-AcceptActionUsage	isConstant	c8d27cdba36882f9	103	0
-AcceptActionUsage	isDerived	c8d27cdba36882f9	103	0
-AcceptActionUsage	isEnd	c8d27cdba36882f9	103	0
+AcceptActionUsage	isConstant	d1b0bbcdf1e10a4d	103	0
+AcceptActionUsage	isDerived	d1b0bbcdf1e10a4d	103	0
+AcceptActionUsage	isEnd	d1b0bbcdf1e10a4d	103	0
 AcceptActionUsage	isImpliedIncluded	2110b307b7176b78	103	103
-AcceptActionUsage	isIndividual	3bf7b4f43a417d07	103	0
+AcceptActionUsage	isIndividual	d1b0bbcdf1e10a4d	103	0
 AcceptActionUsage	isLibraryElement	d1b0bbcdf1e10a4d	103	0
-AcceptActionUsage	isOrdered	c8d27cdba36882f9	103	0
-AcceptActionUsage	isPortion	3bf7b4f43a417d07	103	0
+AcceptActionUsage	isOrdered	d1b0bbcdf1e10a4d	103	0
+AcceptActionUsage	isPortion	d1b0bbcdf1e10a4d	103	0
 AcceptActionUsage	isReference	d1b0bbcdf1e10a4d	103	0
-AcceptActionUsage	isSufficient	3bf7b4f43a417d07	103	0
-AcceptActionUsage	isUnique	e1a918c8192f14fc	103	23
+AcceptActionUsage	isSufficient	d1b0bbcdf1e10a4d	103	0
+AcceptActionUsage	isUnique	2110b307b7176b78	103	103
 AcceptActionUsage	isVariable	3bf7b4f43a417d07	103	0
 AcceptActionUsage	isVariation	d1b0bbcdf1e10a4d	103	0
 AcceptActionUsage	mayTimeVary	3bf7b4f43a417d07	103	0
@@ -57,7 +57,7 @@ AcceptActionUsage	nestedConnection	f754965b3c37d264	103	0
 AcceptActionUsage	nestedConstraint	f754965b3c37d264	103	0
 AcceptActionUsage	nestedEnumeration	f754965b3c37d264	103	0
 AcceptActionUsage	nestedFlow	f754965b3c37d264	103	0
-AcceptActionUsage	nestedInterface	7eb87ade6e9a9f45	103	103
+AcceptActionUsage	nestedInterface	f754965b3c37d264	103	0
 AcceptActionUsage	nestedItem	f754965b3c37d264	103	0
 AcceptActionUsage	nestedMetadata	f754965b3c37d264	103	0
 AcceptActionUsage	nestedOccurrence	f754965b3c37d264	103	0
@@ -139,7 +139,7 @@ ActionDefinition	intersectingType	f91e4d450b44243e	113	0
 ActionDefinition	isAbstract	e7bedd97fe920a22	113	1
 ActionDefinition	isConjugated	db5948bc0fb78dad	113	0
 ActionDefinition	isImpliedIncluded	0c4378ee77dafc8a	113	113
-ActionDefinition	isIndividual	7fcc089af57b2988	113	3
+ActionDefinition	isIndividual	1c84e3d53348c484	113	3
 ActionDefinition	isLibraryElement	db5948bc0fb78dad	113	0
 ActionDefinition	isSufficient	db5948bc0fb78dad	113	0
 ActionDefinition	isVariation	e7bedd97fe920a22	113	1
@@ -166,9 +166,9 @@ ActionDefinition	ownedEndFeature	f91e4d450b44243e	113	0
 ActionDefinition	ownedEnumeration	f91e4d450b44243e	113	0
 ActionDefinition	ownedFeature	96192dfc9055e223	113	85
 ActionDefinition	ownedFeatureMembership	1c52452c81301b43	113	85
-ActionDefinition	ownedFlow	f91e4d450b44243e	113	0
+ActionDefinition	ownedFlow	e3751925850eb1a6	113	6
 ActionDefinition	ownedImport	f91e4d450b44243e	113	0
-ActionDefinition	ownedInterface	77b7d5c5069995a3	113	62
+ActionDefinition	ownedInterface	f91e4d450b44243e	113	0
 ActionDefinition	ownedIntersecting	f91e4d450b44243e	113	0
 ActionDefinition	ownedItem	d59a676bfdd1e803	113	12
 ActionDefinition	ownedMember	4d2ee41ac99bd9fb	113	86
@@ -230,27 +230,27 @@ ActionUsage	inheritedFeature	83160429bf7fbfbb	252	0
 ActionUsage	inheritedMembership	83160429bf7fbfbb	252	0
 ActionUsage	input	a13ec9c222a737c7	252	80
 ActionUsage	intersectingType	83160429bf7fbfbb	252	0
-ActionUsage	isAbstract	083b7be0c93623d5	252	2
+ActionUsage	isAbstract	13d9dc029becc5d5	252	2
 ActionUsage	isComposite	54d9e3220d27623e	252	191
 ActionUsage	isConjugated	200b57d76fa28783	252	0
-ActionUsage	isConstant	146cf7b59cebe583	252	0
-ActionUsage	isDerived	146cf7b59cebe583	252	0
-ActionUsage	isEnd	146cf7b59cebe583	252	0
+ActionUsage	isConstant	200b57d76fa28783	252	0
+ActionUsage	isDerived	200b57d76fa28783	252	0
+ActionUsage	isEnd	200b57d76fa28783	252	0
 ActionUsage	isImpliedIncluded	86cdb2c993d1cabf	252	252
-ActionUsage	isIndividual	24278700b413069c	252	3
+ActionUsage	isIndividual	41ef235d3afc910a	252	3
 ActionUsage	isLibraryElement	563a73522982ad0d	252	2
-ActionUsage	isOrdered	146cf7b59cebe583	252	0
-ActionUsage	isPortion	f51afd36e7d18cd1	252	0
+ActionUsage	isOrdered	200b57d76fa28783	252	0
+ActionUsage	isPortion	200b57d76fa28783	252	0
 ActionUsage	isReference	4660c75d23964e04	252	61
-ActionUsage	isSufficient	f51afd36e7d18cd1	252	0
-ActionUsage	isUnique	da6dd5bddb3d9215	252	242
+ActionUsage	isSufficient	200b57d76fa28783	252	0
+ActionUsage	isUnique	86cdb2c993d1cabf	252	252
 ActionUsage	isVariable	f51afd36e7d18cd1	252	0
 ActionUsage	isVariation	13d9dc029becc5d5	252	2
 ActionUsage	mayTimeVary	f51afd36e7d18cd1	252	0
 ActionUsage	member	112c198fdecbe254	252	165
 ActionUsage	membership	bb37e91b3efc40ab	252	165
 ActionUsage	multiplicity	7f95178979e66231	252	12
-ActionUsage	name	943d7f61fc861a67	252	226
+ActionUsage	name	f6a1eff030c08b08	252	233
 ActionUsage	nestedAction	7da38668454a6bb6	252	59
 ActionUsage	nestedAllocation	83160429bf7fbfbb	252	0
 ActionUsage	nestedAnalysisCase	83160429bf7fbfbb	252	0
@@ -261,8 +261,8 @@ ActionUsage	nestedConcern	83160429bf7fbfbb	252	0
 ActionUsage	nestedConnection	818dd9fde7053e3e	252	26
 ActionUsage	nestedConstraint	f298e8c3b6def7ad	252	3
 ActionUsage	nestedEnumeration	83160429bf7fbfbb	252	0
-ActionUsage	nestedFlow	83160429bf7fbfbb	252	0
-ActionUsage	nestedInterface	a4520ff83a825556	252	72
+ActionUsage	nestedFlow	8200f85c606ffb7b	252	13
+ActionUsage	nestedInterface	83160429bf7fbfbb	252	0
 ActionUsage	nestedItem	13b0511bcd6ed6af	252	27
 ActionUsage	nestedMetadata	83160429bf7fbfbb	252	0
 ActionUsage	nestedOccurrence	fa2f7954e6291e9b	252	85
@@ -295,11 +295,11 @@ ActionUsage	ownedImport	bdf9a5be70fd2068	252	1
 ActionUsage	ownedIntersecting	83160429bf7fbfbb	252	0
 ActionUsage	ownedMember	2a79ad2ae05caaf1	252	165
 ActionUsage	ownedMembership	bb37e91b3efc40ab	252	165
-ActionUsage	ownedRedefinition	57df046aa74e6632	252	6
+ActionUsage	ownedRedefinition	217bc0b6b8c86dab	252	13
 ActionUsage	ownedReferenceSubsetting	f51afd36e7d18cd1	252	0
-ActionUsage	ownedRelationship	49546c9107034a44	252	252
-ActionUsage	ownedSpecialization	912d1948edc6bd4b	252	252
-ActionUsage	ownedSubsetting	746c4c01d514c12b	252	252
+ActionUsage	ownedRelationship	7e2494864dd75b37	252	252
+ActionUsage	ownedSpecialization	2d642fd9428ae6d4	252	252
+ActionUsage	ownedSubsetting	d4f3aab87ae7198a	252	252
 ActionUsage	ownedTypeFeaturing	83160429bf7fbfbb	252	0
 ActionUsage	ownedTyping	17f41eb886cb956f	252	102
 ActionUsage	ownedUnioning	83160429bf7fbfbb	252	0
@@ -380,9 +380,9 @@ AllocationDefinition	input	5e87d47a36afcc57	5	0
 AllocationDefinition	intersectingType	5e87d47a36afcc57	5	0
 AllocationDefinition	isAbstract	6f10b7f29ce940b6	5	0
 AllocationDefinition	isConjugated	6f10b7f29ce940b6	5	0
-AllocationDefinition	isImplied	838b8d5bc57d4c8a	5	0
+AllocationDefinition	isImplied	6f10b7f29ce940b6	5	0
 AllocationDefinition	isImpliedIncluded	249c0b5e785db74f	5	5
-AllocationDefinition	isIndividual	838b8d5bc57d4c8a	5	0
+AllocationDefinition	isIndividual	6f10b7f29ce940b6	5	0
 AllocationDefinition	isLibraryElement	6f10b7f29ce940b6	5	0
 AllocationDefinition	isSufficient	249c0b5e785db74f	5	5
 AllocationDefinition	isVariation	6f10b7f29ce940b6	5	0
@@ -411,7 +411,7 @@ AllocationDefinition	ownedFeature	072eaf52bb8a9218	5	4
 AllocationDefinition	ownedFeatureMembership	e78dae633ba12e98	5	4
 AllocationDefinition	ownedFlow	5e87d47a36afcc57	5	0
 AllocationDefinition	ownedImport	5e87d47a36afcc57	5	0
-AllocationDefinition	ownedInterface	c2cc5397928e82ed	5	3
+AllocationDefinition	ownedInterface	5e87d47a36afcc57	5	0
 AllocationDefinition	ownedIntersecting	5e87d47a36afcc57	5	0
 AllocationDefinition	ownedItem	5e87d47a36afcc57	5	0
 AllocationDefinition	ownedMember	072eaf52bb8a9218	5	4
@@ -488,14 +488,14 @@ AllocationUsage	isConjugated	69a8546c36895908	18	0
 AllocationUsage	isConstant	69a8546c36895908	18	0
 AllocationUsage	isDerived	69a8546c36895908	18	0
 AllocationUsage	isEnd	69a8546c36895908	18	0
-AllocationUsage	isImplied	dfdbdb5537dcef4c	18	0
+AllocationUsage	isImplied	69a8546c36895908	18	0
 AllocationUsage	isImpliedIncluded	7b67c269ff221dea	18	18
-AllocationUsage	isIndividual	dfdbdb5537dcef4c	18	0
+AllocationUsage	isIndividual	69a8546c36895908	18	0
 AllocationUsage	isLibraryElement	69a8546c36895908	18	0
 AllocationUsage	isOrdered	69a8546c36895908	18	0
-AllocationUsage	isPortion	dfdbdb5537dcef4c	18	0
+AllocationUsage	isPortion	69a8546c36895908	18	0
 AllocationUsage	isReference	2f68059624a07358	18	8
-AllocationUsage	isSufficient	dfdbdb5537dcef4c	18	0
+AllocationUsage	isSufficient	69a8546c36895908	18	0
 AllocationUsage	isUnique	7b67c269ff221dea	18	18
 AllocationUsage	isVariable	dfdbdb5537dcef4c	18	0
 AllocationUsage	isVariation	69a8546c36895908	18	0
@@ -516,7 +516,7 @@ AllocationUsage	nestedConnection	4ccc42c59a284210	18	6
 AllocationUsage	nestedConstraint	1a80ec4915f6f24a	18	0
 AllocationUsage	nestedEnumeration	1a80ec4915f6f24a	18	0
 AllocationUsage	nestedFlow	1a80ec4915f6f24a	18	0
-AllocationUsage	nestedInterface	b898d5564b66d43a	18	18
+AllocationUsage	nestedInterface	1a80ec4915f6f24a	18	0
 AllocationUsage	nestedItem	4ccc42c59a284210	18	6
 AllocationUsage	nestedMetadata	1a80ec4915f6f24a	18	0
 AllocationUsage	nestedOccurrence	4ccc42c59a284210	18	6
@@ -552,9 +552,9 @@ AllocationUsage	ownedMembership	7bdaeb122c7e8a2d	18	18
 AllocationUsage	ownedRedefinition	1a80ec4915f6f24a	18	0
 AllocationUsage	ownedReferenceSubsetting	dfdbdb5537dcef4c	18	0
 AllocationUsage	ownedRelatedElement	1a80ec4915f6f24a	18	0
-AllocationUsage	ownedRelationship	6889275c01b54e17	18	18
-AllocationUsage	ownedSpecialization	d75161ad409504cc	18	18
-AllocationUsage	ownedSubsetting	d465f9956ecf8c3d	18	18
+AllocationUsage	ownedRelationship	c178d2a96c0a2a72	18	18
+AllocationUsage	ownedSpecialization	b7ccffeafa892f23	18	18
+AllocationUsage	ownedSubsetting	b4e197d328c3b694	18	18
 AllocationUsage	ownedTypeFeaturing	1a80ec4915f6f24a	18	0
 AllocationUsage	ownedTyping	ea6b646fa719a329	18	5
 AllocationUsage	ownedUnioning	1a80ec4915f6f24a	18	0
@@ -570,12 +570,12 @@ AllocationUsage	owningUsage	297987131265b56e	18	10
 AllocationUsage	partDefinition	5057165c7ff00c75	18	5
 AllocationUsage	portionKind	dfdbdb5537dcef4c	18	0
 AllocationUsage	qualifiedName	012f0278028099f2	18	5
-AllocationUsage	relatedElement	1a80ec4915f6f24a	18	0
+AllocationUsage	relatedElement	7d853908124f8b08	18	18
 AllocationUsage	relatedFeature	7d853908124f8b08	18	18
 AllocationUsage	shortName	dfdbdb5537dcef4c	18	0
-AllocationUsage	source	1a80ec4915f6f24a	18	0
+AllocationUsage	source	27b24b43352158b9	18	18
 AllocationUsage	sourceFeature	31e15f6cb0019203	18	18
-AllocationUsage	target	1a80ec4915f6f24a	18	0
+AllocationUsage	target	7fa5b23c42cdace3	18	18
 AllocationUsage	targetFeature	7fa5b23c42cdace3	18	18
 AllocationUsage	textualRepresentation	1a80ec4915f6f24a	18	0
 AllocationUsage	type	5057165c7ff00c75	18	5
@@ -606,7 +606,7 @@ AnalysisCaseDefinition	intersectingType	0e00f5209eb454f5	14	0
 AnalysisCaseDefinition	isAbstract	92f0038f2d414a2b	14	0
 AnalysisCaseDefinition	isConjugated	92f0038f2d414a2b	14	0
 AnalysisCaseDefinition	isImpliedIncluded	dd78bbdb5d96cd39	14	14
-AnalysisCaseDefinition	isIndividual	6168d302567fb9e6	14	1
+AnalysisCaseDefinition	isIndividual	0c9983ea44ae1e20	14	1
 AnalysisCaseDefinition	isLibraryElement	92f0038f2d414a2b	14	0
 AnalysisCaseDefinition	isModelLevelEvaluable	92f0038f2d414a2b	14	0
 AnalysisCaseDefinition	isSufficient	92f0038f2d414a2b	14	0
@@ -637,7 +637,7 @@ AnalysisCaseDefinition	ownedFeature	d21781cffa7fbdb1	14	13
 AnalysisCaseDefinition	ownedFeatureMembership	c24a7eb347b66d28	14	13
 AnalysisCaseDefinition	ownedFlow	0e00f5209eb454f5	14	0
 AnalysisCaseDefinition	ownedImport	0e00f5209eb454f5	14	0
-AnalysisCaseDefinition	ownedInterface	c421afc4d457236e	14	13
+AnalysisCaseDefinition	ownedInterface	0e00f5209eb454f5	14	0
 AnalysisCaseDefinition	ownedIntersecting	0e00f5209eb454f5	14	0
 AnalysisCaseDefinition	ownedItem	0e00f5209eb454f5	14	0
 AnalysisCaseDefinition	ownedMember	d21781cffa7fbdb1	14	13
@@ -714,13 +714,13 @@ AnalysisCaseUsage	isConstant	1b834b0924e74284	26	0
 AnalysisCaseUsage	isDerived	1b834b0924e74284	26	0
 AnalysisCaseUsage	isEnd	1b834b0924e74284	26	0
 AnalysisCaseUsage	isImpliedIncluded	454cd1c4865fec66	26	26
-AnalysisCaseUsage	isIndividual	5a626ac698992e3b	26	1
+AnalysisCaseUsage	isIndividual	99d7ff424b321011	26	1
 AnalysisCaseUsage	isLibraryElement	1b834b0924e74284	26	0
 AnalysisCaseUsage	isModelLevelEvaluable	1b834b0924e74284	26	0
 AnalysisCaseUsage	isOrdered	1b834b0924e74284	26	0
-AnalysisCaseUsage	isPortion	ad0012fb355bd2a8	26	0
+AnalysisCaseUsage	isPortion	1b834b0924e74284	26	0
 AnalysisCaseUsage	isReference	30889b2c26d3a5fc	26	8
-AnalysisCaseUsage	isSufficient	ad0012fb355bd2a8	26	0
+AnalysisCaseUsage	isSufficient	1b834b0924e74284	26	0
 AnalysisCaseUsage	isUnique	454cd1c4865fec66	26	26
 AnalysisCaseUsage	isVariable	ad0012fb355bd2a8	26	0
 AnalysisCaseUsage	isVariation	b3509bc87b23b3a9	26	1
@@ -740,7 +740,7 @@ AnalysisCaseUsage	nestedConnection	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	nestedConstraint	dbd47bb6c59cf66a	26	17
 AnalysisCaseUsage	nestedEnumeration	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	nestedFlow	1102a4ab4ce3148e	26	0
-AnalysisCaseUsage	nestedInterface	ee7f788f3fd049c1	26	25
+AnalysisCaseUsage	nestedInterface	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	nestedItem	a8526d997688c315	26	4
 AnalysisCaseUsage	nestedMetadata	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	nestedOccurrence	7c5ae4341443ffb2	26	18
@@ -776,9 +776,9 @@ AnalysisCaseUsage	ownedMember	7703fad0d54eaf01	26	25
 AnalysisCaseUsage	ownedMembership	183f53ee90644c7b	26	25
 AnalysisCaseUsage	ownedRedefinition	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	ownedReferenceSubsetting	ad0012fb355bd2a8	26	0
-AnalysisCaseUsage	ownedRelationship	5bc5acd50277f3e9	26	26
-AnalysisCaseUsage	ownedSpecialization	11d956a4963ee80a	26	26
-AnalysisCaseUsage	ownedSubsetting	c0a52fe59b74cfd1	26	26
+AnalysisCaseUsage	ownedRelationship	efb11aab245d0e58	26	26
+AnalysisCaseUsage	ownedSpecialization	b5dc21f8bd34ac71	26	26
+AnalysisCaseUsage	ownedSubsetting	afa9a68fdff59b2e	26	26
 AnalysisCaseUsage	ownedTypeFeaturing	1102a4ab4ce3148e	26	0
 AnalysisCaseUsage	ownedTyping	4c60745f1b13e821	26	24
 AnalysisCaseUsage	ownedUnioning	1102a4ab4ce3148e	26	0
@@ -867,14 +867,14 @@ AssertConstraintUsage	isConstant	0bf7902ed2437918	47	0
 AssertConstraintUsage	isDerived	0bf7902ed2437918	47	0
 AssertConstraintUsage	isEnd	0bf7902ed2437918	47	0
 AssertConstraintUsage	isImpliedIncluded	8a26f22463eec8f3	47	47
-AssertConstraintUsage	isIndividual	5dc06dd6b7cd7634	47	0
+AssertConstraintUsage	isIndividual	0bf7902ed2437918	47	0
 AssertConstraintUsage	isLibraryElement	0bf7902ed2437918	47	0
 AssertConstraintUsage	isModelLevelEvaluable	0bf7902ed2437918	47	0
 AssertConstraintUsage	isNegated	d6321119ac5c9085	47	1
 AssertConstraintUsage	isOrdered	0bf7902ed2437918	47	0
-AssertConstraintUsage	isPortion	5dc06dd6b7cd7634	47	0
+AssertConstraintUsage	isPortion	0bf7902ed2437918	47	0
 AssertConstraintUsage	isReference	d6321119ac5c9085	47	1
-AssertConstraintUsage	isSufficient	5dc06dd6b7cd7634	47	0
+AssertConstraintUsage	isSufficient	0bf7902ed2437918	47	0
 AssertConstraintUsage	isUnique	8a26f22463eec8f3	47	47
 AssertConstraintUsage	isVariable	5dc06dd6b7cd7634	47	0
 AssertConstraintUsage	isVariation	0bf7902ed2437918	47	0
@@ -882,7 +882,7 @@ AssertConstraintUsage	mayTimeVary	5dc06dd6b7cd7634	47	0
 AssertConstraintUsage	member	d35557909a8d9ef6	47	46
 AssertConstraintUsage	membership	0b1f140fe4fab2fc	47	46
 AssertConstraintUsage	multiplicity	5dc06dd6b7cd7634	47	0
-AssertConstraintUsage	name	065fa588d8339169	47	22
+AssertConstraintUsage	name	3933e561f7283dbd	47	18
 AssertConstraintUsage	nestedAction	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedAllocation	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedAnalysisCase	d5f0937b06325883	47	0
@@ -894,7 +894,7 @@ AssertConstraintUsage	nestedConnection	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedConstraint	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedEnumeration	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedFlow	d5f0937b06325883	47	0
-AssertConstraintUsage	nestedInterface	a26623f81ef57b9e	47	11
+AssertConstraintUsage	nestedInterface	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedItem	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedMetadata	d5f0937b06325883	47	0
 AssertConstraintUsage	nestedOccurrence	d5f0937b06325883	47	0
@@ -929,9 +929,9 @@ AssertConstraintUsage	ownedMember	d35557909a8d9ef6	47	46
 AssertConstraintUsage	ownedMembership	0b1f140fe4fab2fc	47	46
 AssertConstraintUsage	ownedRedefinition	d5f0937b06325883	47	0
 AssertConstraintUsage	ownedReferenceSubsetting	c54049138148793a	47	4
-AssertConstraintUsage	ownedRelationship	0b792394529fad37	47	47
-AssertConstraintUsage	ownedSpecialization	7e25f9c560cffce0	47	47
-AssertConstraintUsage	ownedSubsetting	5df30f234034b6e8	47	47
+AssertConstraintUsage	ownedRelationship	ddbf30853bffe9df	47	47
+AssertConstraintUsage	ownedSpecialization	bfa29cdb1e49a71c	47	47
+AssertConstraintUsage	ownedSubsetting	ceec189ccf01c4b2	47	47
 AssertConstraintUsage	ownedTypeFeaturing	d5f0937b06325883	47	0
 AssertConstraintUsage	ownedTyping	b93a8ffeaa33110d	47	10
 AssertConstraintUsage	ownedUnioning	d5f0937b06325883	47	0
@@ -946,7 +946,7 @@ AssertConstraintUsage	owningUsage	82b2aaade93fcf89	47	27
 AssertConstraintUsage	parameter	e3363dd79db64143	47	10
 AssertConstraintUsage	portionKind	5dc06dd6b7cd7634	47	0
 AssertConstraintUsage	predicate	1a6684e260c178f5	47	13
-AssertConstraintUsage	qualifiedName	492d24f5a77cc852	47	22
+AssertConstraintUsage	qualifiedName	e46cb4aa34d9d2f3	47	18
 AssertConstraintUsage	result	223b71405bcf3fc9	47	0
 AssertConstraintUsage	shortName	5dc06dd6b7cd7634	47	0
 AssertConstraintUsage	textualRepresentation	75ec53f86454bb13	47	1
@@ -988,12 +988,12 @@ AssignmentActionUsage	isConstant	322f626384f3b488	27	0
 AssignmentActionUsage	isDerived	322f626384f3b488	27	0
 AssignmentActionUsage	isEnd	322f626384f3b488	27	0
 AssignmentActionUsage	isImpliedIncluded	604b65ea72c551c7	27	27
-AssignmentActionUsage	isIndividual	9b268e46e142efe0	27	0
+AssignmentActionUsage	isIndividual	322f626384f3b488	27	0
 AssignmentActionUsage	isLibraryElement	322f626384f3b488	27	0
 AssignmentActionUsage	isOrdered	322f626384f3b488	27	0
-AssignmentActionUsage	isPortion	9b268e46e142efe0	27	0
+AssignmentActionUsage	isPortion	322f626384f3b488	27	0
 AssignmentActionUsage	isReference	322f626384f3b488	27	0
-AssignmentActionUsage	isSufficient	9b268e46e142efe0	27	0
+AssignmentActionUsage	isSufficient	322f626384f3b488	27	0
 AssignmentActionUsage	isUnique	604b65ea72c551c7	27	27
 AssignmentActionUsage	isVariable	9b268e46e142efe0	27	0
 AssignmentActionUsage	isVariation	322f626384f3b488	27	0
@@ -1013,7 +1013,7 @@ AssignmentActionUsage	nestedConnection	46d58560435835ff	27	0
 AssignmentActionUsage	nestedConstraint	46d58560435835ff	27	0
 AssignmentActionUsage	nestedEnumeration	46d58560435835ff	27	0
 AssignmentActionUsage	nestedFlow	46d58560435835ff	27	0
-AssignmentActionUsage	nestedInterface	d33c8ec8c06916dc	27	27
+AssignmentActionUsage	nestedInterface	46d58560435835ff	27	0
 AssignmentActionUsage	nestedItem	46d58560435835ff	27	0
 AssignmentActionUsage	nestedMetadata	46d58560435835ff	27	0
 AssignmentActionUsage	nestedOccurrence	46d58560435835ff	27	0
@@ -1122,7 +1122,7 @@ AttributeDefinition	ownedFeature	f4fe46d33207925a	162	66
 AttributeDefinition	ownedFeatureMembership	5daeb4b25ef5f6da	162	66
 AttributeDefinition	ownedFlow	72d05f9b3a646290	162	0
 AttributeDefinition	ownedImport	72d05f9b3a646290	162	0
-AttributeDefinition	ownedInterface	e2559fae1cfbe5cc	162	20
+AttributeDefinition	ownedInterface	72d05f9b3a646290	162	0
 AttributeDefinition	ownedIntersecting	72d05f9b3a646290	162	0
 AttributeDefinition	ownedItem	91967a15f3ff6718	162	4
 AttributeDefinition	ownedMember	852af33867ea4a14	162	71
@@ -1157,12 +1157,12 @@ AttributeDefinition	usage	f4fe46d33207925a	162	66
 AttributeDefinition	variant	dabdf7454d2db87c	162	2
 AttributeDefinition	variantMembership	f94041cf68917e3a	162	2
 AttributeUsage	aliasIds	72adc62d2f0f8f4e	814	0
-AttributeUsage	attributeDefinition	1a6a54e325ec1af6	814	724
+AttributeUsage	attributeDefinition	0397bb967b58da7f	814	721
 AttributeUsage	chainingFeature	72adc62d2f0f8f4e	814	0
 AttributeUsage	crossFeature	09874d6b189080e0	814	0
 AttributeUsage	declaredName	c1fa47ab1b08f709	814	619
 AttributeUsage	declaredShortName	11e3c024c509493d	814	6
-AttributeUsage	definition	f9cd2887243430ce	814	724
+AttributeUsage	definition	e2fa8f3a79a0f057	814	721
 AttributeUsage	differencingType	72adc62d2f0f8f4e	814	0
 AttributeUsage	directedFeature	72adc62d2f0f8f4e	814	0
 AttributeUsage	directedUsage	72adc62d2f0f8f4e	814	0
@@ -1189,9 +1189,9 @@ AttributeUsage	isEnd	1c6e83d62debd810	814	0
 AttributeUsage	isImpliedIncluded	86830725770bfa5e	814	814
 AttributeUsage	isLibraryElement	3e5c731d8a3929b0	814	16
 AttributeUsage	isOrdered	597086bd364fbbb6	814	6
-AttributeUsage	isPortion	09874d6b189080e0	814	0
+AttributeUsage	isPortion	1c6e83d62debd810	814	0
 AttributeUsage	isReference	86830725770bfa5e	814	814
-AttributeUsage	isSufficient	09874d6b189080e0	814	0
+AttributeUsage	isSufficient	1c6e83d62debd810	814	0
 AttributeUsage	isUnique	d1367480eb7abf41	814	813
 AttributeUsage	isVariable	09874d6b189080e0	814	0
 AttributeUsage	isVariation	f091fe40b5478bf5	814	1
@@ -1199,7 +1199,7 @@ AttributeUsage	mayTimeVary	09874d6b189080e0	814	0
 AttributeUsage	member	227e0f870be1c71b	814	395
 AttributeUsage	membership	500fc30b6b1f6ef7	814	395
 AttributeUsage	multiplicity	7449d4f0ad3e5623	814	73
-AttributeUsage	name	4ed99a300122430d	814	810
+AttributeUsage	name	5d50bc9e0fc6b4e4	814	806
 AttributeUsage	nestedAction	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedAllocation	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedAnalysisCase	72adc62d2f0f8f4e	814	0
@@ -1211,7 +1211,7 @@ AttributeUsage	nestedConnection	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedConstraint	37663888eee9b5a8	814	2
 AttributeUsage	nestedEnumeration	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedFlow	72adc62d2f0f8f4e	814	0
-AttributeUsage	nestedInterface	f404bc2df5c0d833	814	58
+AttributeUsage	nestedInterface	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedItem	b48a992990776d6a	814	4
 AttributeUsage	nestedMetadata	72adc62d2f0f8f4e	814	0
 AttributeUsage	nestedOccurrence	79430b85505193c4	814	6
@@ -1243,11 +1243,11 @@ AttributeUsage	ownedImport	72adc62d2f0f8f4e	814	0
 AttributeUsage	ownedIntersecting	72adc62d2f0f8f4e	814	0
 AttributeUsage	ownedMember	227e0f870be1c71b	814	395
 AttributeUsage	ownedMembership	500fc30b6b1f6ef7	814	395
-AttributeUsage	ownedRedefinition	0d41cffd24441f46	814	234
+AttributeUsage	ownedRedefinition	4e0e1b5a329a09f7	814	248
 AttributeUsage	ownedReferenceSubsetting	a38a59dfbd1992bd	814	1
-AttributeUsage	ownedRelationship	c387a2d98e7428ef	814	783
-AttributeUsage	ownedSpecialization	18bd0aeb6d59e03a	814	749
-AttributeUsage	ownedSubsetting	81e59c06aebf8953	814	362
+AttributeUsage	ownedRelationship	3eb0df1864978798	814	814
+AttributeUsage	ownedSpecialization	8193d349cb611b77	814	814
+AttributeUsage	ownedSubsetting	93494447f413b66c	814	814
 AttributeUsage	ownedTypeFeaturing	72adc62d2f0f8f4e	814	0
 AttributeUsage	ownedTyping	3cfd70d5fbb42a23	814	423
 AttributeUsage	ownedUnioning	72adc62d2f0f8f4e	814	0
@@ -1259,14 +1259,99 @@ AttributeUsage	owningNamespace	d7cd4585788eddd3	814	814
 AttributeUsage	owningRelationship	cb3da7c91d75c352	814	814
 AttributeUsage	owningType	74b58833b8d2de28	814	740
 AttributeUsage	owningUsage	233a73442ea74e2d	814	325
-AttributeUsage	qualifiedName	bf07f58c5c44f977	814	803
+AttributeUsage	qualifiedName	151557e5d9df0399	814	797
 AttributeUsage	shortName	11e3c024c509493d	814	6
 AttributeUsage	textualRepresentation	72adc62d2f0f8f4e	814	0
-AttributeUsage	type	f9cd2887243430ce	814	724
+AttributeUsage	type	e2fa8f3a79a0f057	814	721
 AttributeUsage	unioningType	72adc62d2f0f8f4e	814	0
 AttributeUsage	usage	4b4e05cd33e22380	814	85
 AttributeUsage	variant	b7f95831dc9001b4	814	1
 AttributeUsage	variantMembership	d2ee77de9912926b	814	1
+BindingConnector	aliasIds	2db159e24105d502	1672	0
+BindingConnector	association	2db159e24105d502	1672	0
+BindingConnector	chainingFeature	2db159e24105d502	1672	0
+BindingConnector	connectorEnd	77fa84a798ca4382	1672	1672
+BindingConnector	crossFeature	f842e15dd7004b9a	1672	0
+BindingConnector	declaredName	f842e15dd7004b9a	1672	0
+BindingConnector	declaredShortName	f842e15dd7004b9a	1672	0
+BindingConnector	defaultFeaturingType	75c09e5a33529661	1672	580
+BindingConnector	differencingType	2db159e24105d502	1672	0
+BindingConnector	directedFeature	2db159e24105d502	1672	0
+BindingConnector	direction	f842e15dd7004b9a	1672	0
+BindingConnector	documentation	2db159e24105d502	1672	0
+BindingConnector	elementId	c8c3672c7e61d0a8	1672	1672
+BindingConnector	endFeature	77fa84a798ca4382	1672	1672
+BindingConnector	endOwningType	f842e15dd7004b9a	1672	0
+BindingConnector	feature	77fa84a798ca4382	1672	1672
+BindingConnector	featureMembership	92455c07ba83ac57	1672	1672
+BindingConnector	featureTarget	ad1d5d059cd55484	1672	0
+BindingConnector	featuringType	2db159e24105d502	1672	0
+BindingConnector	importedMembership	2db159e24105d502	1672	0
+BindingConnector	inheritedFeature	2db159e24105d502	1672	0
+BindingConnector	inheritedMembership	2db159e24105d502	1672	0
+BindingConnector	input	2db159e24105d502	1672	0
+BindingConnector	intersectingType	2db159e24105d502	1672	0
+BindingConnector	isAbstract	e04e0bcaca7b27aa	1672	0
+BindingConnector	isComposite	e04e0bcaca7b27aa	1672	0
+BindingConnector	isConjugated	e04e0bcaca7b27aa	1672	0
+BindingConnector	isConstant	e04e0bcaca7b27aa	1672	0
+BindingConnector	isDerived	e04e0bcaca7b27aa	1672	0
+BindingConnector	isEnd	e04e0bcaca7b27aa	1672	0
+BindingConnector	isImplied	02e29d3156f2a322	1672	1672
+BindingConnector	isImpliedIncluded	02e29d3156f2a322	1672	1672
+BindingConnector	isLibraryElement	e04e0bcaca7b27aa	1672	0
+BindingConnector	isOrdered	e04e0bcaca7b27aa	1672	0
+BindingConnector	isPortion	e04e0bcaca7b27aa	1672	0
+BindingConnector	isSufficient	e04e0bcaca7b27aa	1672	0
+BindingConnector	isUnique	02e29d3156f2a322	1672	1672
+BindingConnector	isVariable	e04e0bcaca7b27aa	1672	0
+BindingConnector	member	77fa84a798ca4382	1672	1672
+BindingConnector	membership	92455c07ba83ac57	1672	1672
+BindingConnector	multiplicity	f842e15dd7004b9a	1672	0
+BindingConnector	name	f842e15dd7004b9a	1672	0
+BindingConnector	output	2db159e24105d502	1672	0
+BindingConnector	ownedAnnotation	2db159e24105d502	1672	0
+BindingConnector	ownedConjugator	f842e15dd7004b9a	1672	0
+BindingConnector	ownedCrossSubsetting	f842e15dd7004b9a	1672	0
+BindingConnector	ownedDifferencing	2db159e24105d502	1672	0
+BindingConnector	ownedDisjoining	2db159e24105d502	1672	0
+BindingConnector	ownedElement	77fa84a798ca4382	1672	1672
+BindingConnector	ownedEndFeature	77fa84a798ca4382	1672	1672
+BindingConnector	ownedFeature	77fa84a798ca4382	1672	1672
+BindingConnector	ownedFeatureChaining	2db159e24105d502	1672	0
+BindingConnector	ownedFeatureInverting	2db159e24105d502	1672	0
+BindingConnector	ownedFeatureMembership	92455c07ba83ac57	1672	1672
+BindingConnector	ownedImport	2db159e24105d502	1672	0
+BindingConnector	ownedIntersecting	2db159e24105d502	1672	0
+BindingConnector	ownedMember	77fa84a798ca4382	1672	1672
+BindingConnector	ownedMembership	92455c07ba83ac57	1672	1672
+BindingConnector	ownedRedefinition	2db159e24105d502	1672	0
+BindingConnector	ownedReferenceSubsetting	f842e15dd7004b9a	1672	0
+BindingConnector	ownedRelatedElement	2db159e24105d502	1672	0
+BindingConnector	ownedRelationship	92455c07ba83ac57	1672	1672
+BindingConnector	ownedSpecialization	2db159e24105d502	1672	0
+BindingConnector	ownedSubsetting	2db159e24105d502	1672	0
+BindingConnector	ownedTypeFeaturing	2db159e24105d502	1672	0
+BindingConnector	ownedTyping	2db159e24105d502	1672	0
+BindingConnector	ownedUnioning	2db159e24105d502	1672	0
+BindingConnector	owner	7f78d09c7d9c2488	1672	1672
+BindingConnector	owningFeatureMembership	f842e15dd7004b9a	1672	0
+BindingConnector	owningMembership	ebda539ea3c21574	1672	1672
+BindingConnector	owningNamespace	7f78d09c7d9c2488	1672	1672
+BindingConnector	owningRelatedElement	f842e15dd7004b9a	1672	0
+BindingConnector	owningRelationship	ebda539ea3c21574	1672	1672
+BindingConnector	owningType	f842e15dd7004b9a	1672	0
+BindingConnector	qualifiedName	f842e15dd7004b9a	1672	0
+BindingConnector	relatedElement	38fa65048db0108f	1672	1672
+BindingConnector	relatedFeature	38fa65048db0108f	1672	1672
+BindingConnector	shortName	f842e15dd7004b9a	1672	0
+BindingConnector	source	7cdfa7de4cdc3d23	1672	1672
+BindingConnector	sourceFeature	ace83476d33be84d	1672	1672
+BindingConnector	target	1a9567e6cb9e5b34	1672	1672
+BindingConnector	targetFeature	1a9567e6cb9e5b34	1672	1672
+BindingConnector	textualRepresentation	2db159e24105d502	1672	0
+BindingConnector	type	2db159e24105d502	1672	0
+BindingConnector	unioningType	2db159e24105d502	1672	0
 BindingConnectorAsUsage	aliasIds	37663c15d33938c4	64	0
 BindingConnectorAsUsage	association	b0e9aa5dc9a44870	64	1
 BindingConnectorAsUsage	chainingFeature	37663c15d33938c4	64	0
@@ -1299,13 +1384,13 @@ BindingConnectorAsUsage	isConjugated	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isConstant	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isDerived	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isEnd	e88efd51adf12c84	64	0
-BindingConnectorAsUsage	isImplied	0462fb7a7bcc6f80	64	0
+BindingConnectorAsUsage	isImplied	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isImpliedIncluded	4d99a22b5a417384	64	64
 BindingConnectorAsUsage	isLibraryElement	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isOrdered	e88efd51adf12c84	64	0
-BindingConnectorAsUsage	isPortion	0462fb7a7bcc6f80	64	0
+BindingConnectorAsUsage	isPortion	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isReference	4d99a22b5a417384	64	64
-BindingConnectorAsUsage	isSufficient	0462fb7a7bcc6f80	64	0
+BindingConnectorAsUsage	isSufficient	e88efd51adf12c84	64	0
 BindingConnectorAsUsage	isUnique	4d99a22b5a417384	64	64
 BindingConnectorAsUsage	isVariable	0462fb7a7bcc6f80	64	0
 BindingConnectorAsUsage	isVariation	e88efd51adf12c84	64	0
@@ -1325,7 +1410,7 @@ BindingConnectorAsUsage	nestedConnection	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedConstraint	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedEnumeration	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedFlow	37663c15d33938c4	64	0
-BindingConnectorAsUsage	nestedInterface	e9a2d503a3cc224c	64	64
+BindingConnectorAsUsage	nestedInterface	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedItem	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedMetadata	37663c15d33938c4	64	0
 BindingConnectorAsUsage	nestedOccurrence	37663c15d33938c4	64	0
@@ -1360,9 +1445,9 @@ BindingConnectorAsUsage	ownedMembership	207dc956e2de6f2c	64	64
 BindingConnectorAsUsage	ownedRedefinition	37663c15d33938c4	64	0
 BindingConnectorAsUsage	ownedReferenceSubsetting	0462fb7a7bcc6f80	64	0
 BindingConnectorAsUsage	ownedRelatedElement	37663c15d33938c4	64	0
-BindingConnectorAsUsage	ownedRelationship	3a2cdad102b15433	64	64
-BindingConnectorAsUsage	ownedSpecialization	0e3e940a68df7c05	64	1
-BindingConnectorAsUsage	ownedSubsetting	37663c15d33938c4	64	0
+BindingConnectorAsUsage	ownedRelationship	d1af58dc54c6e71b	64	64
+BindingConnectorAsUsage	ownedSpecialization	3d707b35cf127301	64	64
+BindingConnectorAsUsage	ownedSubsetting	8e25a924fe2bd358	64	64
 BindingConnectorAsUsage	ownedTypeFeaturing	37663c15d33938c4	64	0
 BindingConnectorAsUsage	ownedTyping	0e3e940a68df7c05	64	1
 BindingConnectorAsUsage	ownedUnioning	37663c15d33938c4	64	0
@@ -1376,12 +1461,12 @@ BindingConnectorAsUsage	owningRelationship	7eef6826a9d58741	64	64
 BindingConnectorAsUsage	owningType	482c1a09541d5248	64	64
 BindingConnectorAsUsage	owningUsage	1890a6d8ba77a886	64	53
 BindingConnectorAsUsage	qualifiedName	0c088b3cac18971b	64	2
-BindingConnectorAsUsage	relatedElement	37663c15d33938c4	64	0
+BindingConnectorAsUsage	relatedElement	1b4aaf6f97bf758f	64	64
 BindingConnectorAsUsage	relatedFeature	1b4aaf6f97bf758f	64	64
 BindingConnectorAsUsage	shortName	0462fb7a7bcc6f80	64	0
-BindingConnectorAsUsage	source	37663c15d33938c4	64	0
+BindingConnectorAsUsage	source	5da99a7b944cfa70	64	64
 BindingConnectorAsUsage	sourceFeature	4142f795c19e7be4	64	64
-BindingConnectorAsUsage	target	37663c15d33938c4	64	0
+BindingConnectorAsUsage	target	be91df7f29f3e081	64	64
 BindingConnectorAsUsage	targetFeature	be91df7f29f3e081	64	64
 BindingConnectorAsUsage	textualRepresentation	37663c15d33938c4	64	0
 BindingConnectorAsUsage	type	b0e9aa5dc9a44870	64	1
@@ -1389,7 +1474,7 @@ BindingConnectorAsUsage	unioningType	37663c15d33938c4	64	0
 BindingConnectorAsUsage	usage	e9a2d503a3cc224c	64	64
 BindingConnectorAsUsage	variant	37663c15d33938c4	64	0
 BindingConnectorAsUsage	variantMembership	37663c15d33938c4	64	0
-CalculationDefinition	action	8acacfef06f95a1e	39	1
+CalculationDefinition	action	b6364935f4768e86	39	1
 CalculationDefinition	aliasIds	50103a747eaafebf	39	0
 CalculationDefinition	calculation	50103a747eaafebf	39	0
 CalculationDefinition	declaredName	2134c79c5b88562f	39	39
@@ -1401,8 +1486,8 @@ CalculationDefinition	documentation	38c868c80d4b5c8f	39	1
 CalculationDefinition	elementId	69a83a47219f55e4	39	39
 CalculationDefinition	endFeature	50103a747eaafebf	39	0
 CalculationDefinition	expression	c33d44dd497d32bc	39	3
-CalculationDefinition	feature	7da7aaa3d7fefce6	39	39
-CalculationDefinition	featureMembership	eb38e08e42421b9c	39	39
+CalculationDefinition	feature	fd8040633838b43e	39	39
+CalculationDefinition	featureMembership	4b7c966ed3277019	39	39
 CalculationDefinition	importedMembership	50103a747eaafebf	39	0
 CalculationDefinition	inheritedFeature	50103a747eaafebf	39	0
 CalculationDefinition	inheritedMembership	50103a747eaafebf	39	0
@@ -1411,17 +1496,17 @@ CalculationDefinition	intersectingType	50103a747eaafebf	39	0
 CalculationDefinition	isAbstract	360207e8700e7979	39	1
 CalculationDefinition	isConjugated	a7492130997751b4	39	0
 CalculationDefinition	isImpliedIncluded	f76667fa2341d9d7	39	39
-CalculationDefinition	isIndividual	b033cb227d802148	39	0
+CalculationDefinition	isIndividual	a7492130997751b4	39	0
 CalculationDefinition	isLibraryElement	a7492130997751b4	39	0
 CalculationDefinition	isModelLevelEvaluable	a7492130997751b4	39	0
 CalculationDefinition	isSufficient	a7492130997751b4	39	0
 CalculationDefinition	isVariation	a7492130997751b4	39	0
-CalculationDefinition	member	b0824e669ac46832	39	39
-CalculationDefinition	membership	df6cca43cacdf472	39	39
+CalculationDefinition	member	305ae425fafe1f8a	39	39
+CalculationDefinition	membership	3fb080245bb348ef	39	39
 CalculationDefinition	multiplicity	b033cb227d802148	39	0
 CalculationDefinition	name	2134c79c5b88562f	39	39
 CalculationDefinition	output	cd5490a1acb161c7	39	38
-CalculationDefinition	ownedAction	8acacfef06f95a1e	39	1
+CalculationDefinition	ownedAction	b6364935f4768e86	39	1
 CalculationDefinition	ownedAllocation	50103a747eaafebf	39	0
 CalculationDefinition	ownedAnalysisCase	50103a747eaafebf	39	0
 CalculationDefinition	ownedAnnotation	50103a747eaafebf	39	0
@@ -1434,24 +1519,24 @@ CalculationDefinition	ownedConnection	50103a747eaafebf	39	0
 CalculationDefinition	ownedConstraint	0dbf04a915732f2d	39	1
 CalculationDefinition	ownedDifferencing	50103a747eaafebf	39	0
 CalculationDefinition	ownedDisjoining	50103a747eaafebf	39	0
-CalculationDefinition	ownedElement	b0824e669ac46832	39	39
+CalculationDefinition	ownedElement	305ae425fafe1f8a	39	39
 CalculationDefinition	ownedEndFeature	50103a747eaafebf	39	0
 CalculationDefinition	ownedEnumeration	50103a747eaafebf	39	0
-CalculationDefinition	ownedFeature	7da7aaa3d7fefce6	39	39
-CalculationDefinition	ownedFeatureMembership	eb38e08e42421b9c	39	39
+CalculationDefinition	ownedFeature	fd8040633838b43e	39	39
+CalculationDefinition	ownedFeatureMembership	4b7c966ed3277019	39	39
 CalculationDefinition	ownedFlow	50103a747eaafebf	39	0
 CalculationDefinition	ownedImport	50103a747eaafebf	39	0
-CalculationDefinition	ownedInterface	c8c2b2025bcec621	39	39
+CalculationDefinition	ownedInterface	50103a747eaafebf	39	0
 CalculationDefinition	ownedIntersecting	50103a747eaafebf	39	0
 CalculationDefinition	ownedItem	50103a747eaafebf	39	0
-CalculationDefinition	ownedMember	b0824e669ac46832	39	39
-CalculationDefinition	ownedMembership	df6cca43cacdf472	39	39
+CalculationDefinition	ownedMember	305ae425fafe1f8a	39	39
+CalculationDefinition	ownedMembership	3fb080245bb348ef	39	39
 CalculationDefinition	ownedMetadata	50103a747eaafebf	39	0
-CalculationDefinition	ownedOccurrence	48799a239dc18a8c	39	2
+CalculationDefinition	ownedOccurrence	73e5136a8b3ebef4	39	2
 CalculationDefinition	ownedPart	50103a747eaafebf	39	0
 CalculationDefinition	ownedPort	50103a747eaafebf	39	0
 CalculationDefinition	ownedReference	c8c2b2025bcec621	39	39
-CalculationDefinition	ownedRelationship	ea3c2c40c89368f5	39	39
+CalculationDefinition	ownedRelationship	6c650d6c0effa65e	39	39
 CalculationDefinition	ownedRendering	50103a747eaafebf	39	0
 CalculationDefinition	ownedRequirement	50103a747eaafebf	39	0
 CalculationDefinition	ownedSpecialization	eac5a99aa119f42a	39	39
@@ -1459,7 +1544,7 @@ CalculationDefinition	ownedState	50103a747eaafebf	39	0
 CalculationDefinition	ownedSubclassification	eac5a99aa119f42a	39	39
 CalculationDefinition	ownedTransition	50103a747eaafebf	39	0
 CalculationDefinition	ownedUnioning	50103a747eaafebf	39	0
-CalculationDefinition	ownedUsage	01e1db165b4c669d	39	39
+CalculationDefinition	ownedUsage	7d7e90e73f03e165	39	39
 CalculationDefinition	ownedUseCase	50103a747eaafebf	39	0
 CalculationDefinition	ownedVerificationCase	50103a747eaafebf	39	0
 CalculationDefinition	ownedView	50103a747eaafebf	39	0
@@ -1472,21 +1557,21 @@ CalculationDefinition	parameter	c8c2b2025bcec621	39	39
 CalculationDefinition	qualifiedName	646b579044f2a64c	39	39
 CalculationDefinition	result	4d56237658b79573	39	38
 CalculationDefinition	shortName	b033cb227d802148	39	0
-CalculationDefinition	step	14e555c28ca8cfbd	39	3
+CalculationDefinition	step	3f953e4a176f6fd5	39	3
 CalculationDefinition	textualRepresentation	50103a747eaafebf	39	0
 CalculationDefinition	unioningType	50103a747eaafebf	39	0
-CalculationDefinition	usage	01e1db165b4c669d	39	39
+CalculationDefinition	usage	7d7e90e73f03e165	39	39
 CalculationDefinition	variant	50103a747eaafebf	39	0
 CalculationDefinition	variantMembership	50103a747eaafebf	39	0
-CalculationUsage	actionDefinition	e393c8c230c78912	31	24
+CalculationUsage	actionDefinition	24c8940a3b34a060	31	26
 CalculationUsage	aliasIds	479ee7aba08b15c9	31	0
-CalculationUsage	behavior	e393c8c230c78912	31	24
-CalculationUsage	calculationDefinition	989c02477fa81e49	31	24
+CalculationUsage	behavior	24c8940a3b34a060	31	26
+CalculationUsage	calculationDefinition	542c05f124d9cd45	31	26
 CalculationUsage	chainingFeature	479ee7aba08b15c9	31	0
 CalculationUsage	crossFeature	61dccb86435e5b92	31	0
 CalculationUsage	declaredName	1f5aa4f7968507aa	31	23
 CalculationUsage	declaredShortName	61dccb86435e5b92	31	0
-CalculationUsage	definition	e393c8c230c78912	31	24
+CalculationUsage	definition	24c8940a3b34a060	31	26
 CalculationUsage	differencingType	479ee7aba08b15c9	31	0
 CalculationUsage	directedFeature	e67a6bcb4097a58f	31	24
 CalculationUsage	directedUsage	e67a6bcb4097a58f	31	24
@@ -1499,7 +1584,7 @@ CalculationUsage	feature	7f974802bb94f0a3	31	25
 CalculationUsage	featureMembership	69bb62922d274337	31	25
 CalculationUsage	featureTarget	c5871ab881c4f4f5	31	0
 CalculationUsage	featuringType	479ee7aba08b15c9	31	0
-CalculationUsage	function	989c02477fa81e49	31	24
+CalculationUsage	function	542c05f124d9cd45	31	26
 CalculationUsage	importedMembership	479ee7aba08b15c9	31	0
 CalculationUsage	individualDefinition	61dccb86435e5b92	31	0
 CalculationUsage	inheritedFeature	479ee7aba08b15c9	31	0
@@ -1513,13 +1598,13 @@ CalculationUsage	isConstant	85878ad133f424a6	31	0
 CalculationUsage	isDerived	85878ad133f424a6	31	0
 CalculationUsage	isEnd	85878ad133f424a6	31	0
 CalculationUsage	isImpliedIncluded	be0e1619f6432621	31	31
-CalculationUsage	isIndividual	61dccb86435e5b92	31	0
+CalculationUsage	isIndividual	85878ad133f424a6	31	0
 CalculationUsage	isLibraryElement	85878ad133f424a6	31	0
 CalculationUsage	isModelLevelEvaluable	85878ad133f424a6	31	0
 CalculationUsage	isOrdered	85878ad133f424a6	31	0
-CalculationUsage	isPortion	61dccb86435e5b92	31	0
+CalculationUsage	isPortion	85878ad133f424a6	31	0
 CalculationUsage	isReference	e973e49248b381c4	31	6
-CalculationUsage	isSufficient	61dccb86435e5b92	31	0
+CalculationUsage	isSufficient	85878ad133f424a6	31	0
 CalculationUsage	isUnique	be0e1619f6432621	31	31
 CalculationUsage	isVariable	61dccb86435e5b92	31	0
 CalculationUsage	isVariation	85878ad133f424a6	31	0
@@ -1539,7 +1624,7 @@ CalculationUsage	nestedConnection	479ee7aba08b15c9	31	0
 CalculationUsage	nestedConstraint	479ee7aba08b15c9	31	0
 CalculationUsage	nestedEnumeration	479ee7aba08b15c9	31	0
 CalculationUsage	nestedFlow	479ee7aba08b15c9	31	0
-CalculationUsage	nestedInterface	994d933532b960b9	31	22
+CalculationUsage	nestedInterface	479ee7aba08b15c9	31	0
 CalculationUsage	nestedItem	443c641a879b5b7a	31	5
 CalculationUsage	nestedMetadata	479ee7aba08b15c9	31	0
 CalculationUsage	nestedOccurrence	4f66768c6ef28588	31	5
@@ -1555,7 +1640,7 @@ CalculationUsage	nestedUseCase	479ee7aba08b15c9	31	0
 CalculationUsage	nestedVerificationCase	479ee7aba08b15c9	31	0
 CalculationUsage	nestedView	479ee7aba08b15c9	31	0
 CalculationUsage	nestedViewpoint	479ee7aba08b15c9	31	0
-CalculationUsage	occurrenceDefinition	e393c8c230c78912	31	24
+CalculationUsage	occurrenceDefinition	24c8940a3b34a060	31	26
 CalculationUsage	output	02eecf78f0737214	31	18
 CalculationUsage	ownedAnnotation	479ee7aba08b15c9	31	0
 CalculationUsage	ownedConjugator	61dccb86435e5b92	31	0
@@ -1572,11 +1657,11 @@ CalculationUsage	ownedImport	479ee7aba08b15c9	31	0
 CalculationUsage	ownedIntersecting	479ee7aba08b15c9	31	0
 CalculationUsage	ownedMember	4f32468c0a56b536	31	27
 CalculationUsage	ownedMembership	6d0578db81f9ba72	31	27
-CalculationUsage	ownedRedefinition	3781d955c2d16ebc	31	6
+CalculationUsage	ownedRedefinition	68fd48e45ca17bce	31	8
 CalculationUsage	ownedReferenceSubsetting	61dccb86435e5b92	31	0
-CalculationUsage	ownedRelationship	8d7b71a592d44d08	31	31
-CalculationUsage	ownedSpecialization	349050575b88ec6d	31	31
-CalculationUsage	ownedSubsetting	fe269c102a08f31f	31	31
+CalculationUsage	ownedRelationship	2654c54891ffbbbb	31	31
+CalculationUsage	ownedSpecialization	03692a93264cfd92	31	31
+CalculationUsage	ownedSubsetting	0529e315a6f99634	31	31
 CalculationUsage	ownedTypeFeaturing	479ee7aba08b15c9	31	0
 CalculationUsage	ownedTyping	c3a5fb826af6c139	31	16
 CalculationUsage	ownedUnioning	479ee7aba08b15c9	31	0
@@ -1594,35 +1679,35 @@ CalculationUsage	qualifiedName	3c6a4ac06e43502c	31	29
 CalculationUsage	result	df328dd5acfdc99c	31	18
 CalculationUsage	shortName	61dccb86435e5b92	31	0
 CalculationUsage	textualRepresentation	479ee7aba08b15c9	31	0
-CalculationUsage	type	e393c8c230c78912	31	24
+CalculationUsage	type	24c8940a3b34a060	31	26
 CalculationUsage	unioningType	479ee7aba08b15c9	31	0
 CalculationUsage	usage	4d7b1a8edaf9f98b	31	24
 CalculationUsage	variant	479ee7aba08b15c9	31	0
 CalculationUsage	variantMembership	479ee7aba08b15c9	31	0
-Comment	aliasIds	19e603febd5fa0ab	205	0
-Comment	annotatedElement	e5d220d73a68bb7d	205	205
-Comment	annotation	07ca8c0fbfe39bc2	205	9
-Comment	body	0a5b9c0151e7aed8	205	205
-Comment	declaredName	5c58cac6dd15e53f	205	5
-Comment	declaredShortName	d6036d5fbee5a02e	205	0
-Comment	documentation	19e603febd5fa0ab	205	0
-Comment	elementId	798282a199a75c70	205	205
-Comment	isImpliedIncluded	eb6c482ab816c7d3	205	205
-Comment	isLibraryElement	05ac9b11d2f0769a	205	0
-Comment	locale	46268ddae9296944	205	2
-Comment	name	5c58cac6dd15e53f	205	5
-Comment	ownedAnnotatingRelationship	07ca8c0fbfe39bc2	205	9
-Comment	ownedAnnotation	19e603febd5fa0ab	205	0
-Comment	ownedElement	19e603febd5fa0ab	205	0
-Comment	ownedRelationship	07ca8c0fbfe39bc2	205	9
-Comment	owner	66ee8ca6a366a230	205	205
-Comment	owningAnnotatingRelationship	d6036d5fbee5a02e	205	0
-Comment	owningMembership	0e4dba1bd5c07885	205	205
-Comment	owningNamespace	66ee8ca6a366a230	205	205
-Comment	owningRelationship	0e4dba1bd5c07885	205	205
-Comment	qualifiedName	af7081cce9345202	205	5
-Comment	shortName	d6036d5fbee5a02e	205	0
-Comment	textualRepresentation	19e603febd5fa0ab	205	0
+Comment	aliasIds	7f87416cd489b0d7	205	0
+Comment	annotatedElement	aff35689889aca96	205	205
+Comment	annotation	6d6bc97dd70dabee	205	9
+Comment	body	ad824b55a129cb56	205	205
+Comment	declaredName	48f6813cc64a4a17	205	5
+Comment	declaredShortName	c2a123d5a81a0506	205	0
+Comment	documentation	7f87416cd489b0d7	205	0
+Comment	elementId	68119043410249c0	205	205
+Comment	isImpliedIncluded	537ab245a4d217af	205	205
+Comment	isLibraryElement	f86520b4aa387e36	205	0
+Comment	locale	32c44450d25dce1c	205	2
+Comment	name	48f6813cc64a4a17	205	5
+Comment	ownedAnnotatingRelationship	6d6bc97dd70dabee	205	9
+Comment	ownedAnnotation	7f87416cd489b0d7	205	0
+Comment	ownedElement	7f87416cd489b0d7	205	0
+Comment	ownedRelationship	6d6bc97dd70dabee	205	9
+Comment	owner	19630e28d3cdc4d7	205	205
+Comment	owningAnnotatingRelationship	c2a123d5a81a0506	205	0
+Comment	owningMembership	f127a125576e8165	205	205
+Comment	owningNamespace	19630e28d3cdc4d7	205	205
+Comment	owningRelationship	f127a125576e8165	205	205
+Comment	qualifiedName	9c0e3842d268b6da	205	5
+Comment	shortName	c2a123d5a81a0506	205	0
+Comment	textualRepresentation	7f87416cd489b0d7	205	0
 ConcernDefinition	actorParameter	4d3eb98c14151064	2	0
 ConcernDefinition	aliasIds	4d3eb98c14151064	2	0
 ConcernDefinition	assumedConstraint	4d3eb98c14151064	2	0
@@ -1646,7 +1731,7 @@ ConcernDefinition	intersectingType	4d3eb98c14151064	2	0
 ConcernDefinition	isAbstract	a59afe6c9d696efa	2	0
 ConcernDefinition	isConjugated	a59afe6c9d696efa	2	0
 ConcernDefinition	isImpliedIncluded	645505fd95859664	2	2
-ConcernDefinition	isIndividual	6a62c06dffa571ea	2	0
+ConcernDefinition	isIndividual	a59afe6c9d696efa	2	0
 ConcernDefinition	isLibraryElement	a59afe6c9d696efa	2	0
 ConcernDefinition	isModelLevelEvaluable	a59afe6c9d696efa	2	0
 ConcernDefinition	isSufficient	a59afe6c9d696efa	2	0
@@ -1676,7 +1761,7 @@ ConcernDefinition	ownedFeature	31e1842ec1a49ed3	2	2
 ConcernDefinition	ownedFeatureMembership	1e2fd7061bccd451	2	2
 ConcernDefinition	ownedFlow	4d3eb98c14151064	2	0
 ConcernDefinition	ownedImport	4d3eb98c14151064	2	0
-ConcernDefinition	ownedInterface	510da900e475140e	2	2
+ConcernDefinition	ownedInterface	4d3eb98c14151064	2	0
 ConcernDefinition	ownedIntersecting	4d3eb98c14151064	2	0
 ConcernDefinition	ownedItem	2ab6efb93f0813cd	2	2
 ConcernDefinition	ownedMember	79bdb4845c8ded8c	2	2
@@ -1756,13 +1841,13 @@ ConcernUsage	isConstant	0d04eff3180ee67c	11	0
 ConcernUsage	isDerived	0d04eff3180ee67c	11	0
 ConcernUsage	isEnd	0d04eff3180ee67c	11	0
 ConcernUsage	isImpliedIncluded	8853e883ecbacad3	11	11
-ConcernUsage	isIndividual	07b0700da59410cc	11	0
+ConcernUsage	isIndividual	0d04eff3180ee67c	11	0
 ConcernUsage	isLibraryElement	0d04eff3180ee67c	11	0
 ConcernUsage	isModelLevelEvaluable	0d04eff3180ee67c	11	0
 ConcernUsage	isOrdered	0d04eff3180ee67c	11	0
-ConcernUsage	isPortion	07b0700da59410cc	11	0
+ConcernUsage	isPortion	0d04eff3180ee67c	11	0
 ConcernUsage	isReference	3e704c36e32f2f48	11	4
-ConcernUsage	isSufficient	07b0700da59410cc	11	0
+ConcernUsage	isSufficient	0d04eff3180ee67c	11	0
 ConcernUsage	isUnique	8853e883ecbacad3	11	11
 ConcernUsage	isVariable	07b0700da59410cc	11	0
 ConcernUsage	isVariation	0d04eff3180ee67c	11	0
@@ -1770,7 +1855,7 @@ ConcernUsage	mayTimeVary	07b0700da59410cc	11	0
 ConcernUsage	member	812bc985132fa531	11	4
 ConcernUsage	membership	e425902157fdb702	11	4
 ConcernUsage	multiplicity	07b0700da59410cc	11	0
-ConcernUsage	name	edfd4298f26792e9	11	11
+ConcernUsage	name	2a7a6012e9726996	11	7
 ConcernUsage	nestedAction	f66764928aa76a1b	11	0
 ConcernUsage	nestedAllocation	f66764928aa76a1b	11	0
 ConcernUsage	nestedAnalysisCase	f66764928aa76a1b	11	0
@@ -1782,7 +1867,7 @@ ConcernUsage	nestedConnection	f66764928aa76a1b	11	0
 ConcernUsage	nestedConstraint	f66764928aa76a1b	11	0
 ConcernUsage	nestedEnumeration	f66764928aa76a1b	11	0
 ConcernUsage	nestedFlow	f66764928aa76a1b	11	0
-ConcernUsage	nestedInterface	5ed0f764cf144766	11	4
+ConcernUsage	nestedInterface	f66764928aa76a1b	11	0
 ConcernUsage	nestedItem	e2cb5b0777dc6a62	11	4
 ConcernUsage	nestedMetadata	f66764928aa76a1b	11	0
 ConcernUsage	nestedOccurrence	e2cb5b0777dc6a62	11	4
@@ -1834,7 +1919,7 @@ ConcernUsage	owningUsage	4524ef4ceee278c3	11	5
 ConcernUsage	parameter	70734bfe504c7d3f	11	4
 ConcernUsage	portionKind	07b0700da59410cc	11	0
 ConcernUsage	predicate	e420a1fbec28a445	11	3
-ConcernUsage	qualifiedName	3f4b71759b8d79bb	11	11
+ConcernUsage	qualifiedName	419c56b67e7edec8	11	7
 ConcernUsage	reqId	07b0700da59410cc	11	0
 ConcernUsage	requiredConstraint	f66764928aa76a1b	11	0
 ConcernUsage	requirementDefinition	e420a1fbec28a445	11	3
@@ -1866,12 +1951,12 @@ ConjugatedPortDefinition	inheritedFeature	26022f3f5c5d0029	91	0
 ConjugatedPortDefinition	inheritedMembership	26022f3f5c5d0029	91	0
 ConjugatedPortDefinition	input	26022f3f5c5d0029	91	0
 ConjugatedPortDefinition	intersectingType	26022f3f5c5d0029	91	0
-ConjugatedPortDefinition	isAbstract	722ce1aaf77f3206	91	0
+ConjugatedPortDefinition	isAbstract	131b6039e5ed8222	91	0
 ConjugatedPortDefinition	isConjugated	118e8eb459b4e651	91	91
 ConjugatedPortDefinition	isImpliedIncluded	118e8eb459b4e651	91	91
-ConjugatedPortDefinition	isIndividual	722ce1aaf77f3206	91	0
+ConjugatedPortDefinition	isIndividual	131b6039e5ed8222	91	0
 ConjugatedPortDefinition	isLibraryElement	f5ee9883cd100e2d	91	7
-ConjugatedPortDefinition	isSufficient	722ce1aaf77f3206	91	0
+ConjugatedPortDefinition	isSufficient	131b6039e5ed8222	91	0
 ConjugatedPortDefinition	isVariation	131b6039e5ed8222	91	0
 ConjugatedPortDefinition	member	26022f3f5c5d0029	91	0
 ConjugatedPortDefinition	membership	26022f3f5c5d0029	91	0
@@ -1956,7 +2041,7 @@ ConjugatedPortTyping	owningNamespace	48659858cc4fc664	48	0
 ConjugatedPortTyping	owningRelatedElement	8ce940f2166550f6	48	48
 ConjugatedPortTyping	owningRelationship	48659858cc4fc664	48	0
 ConjugatedPortTyping	owningType	8ce940f2166550f6	48	48
-ConjugatedPortTyping	portDefinition	7f3db49808563738	48	0
+ConjugatedPortTyping	portDefinition	947cf343367c55d5	48	48
 ConjugatedPortTyping	qualifiedName	48659858cc4fc664	48	0
 ConjugatedPortTyping	relatedElement	0ede60dafae7fbfd	48	48
 ConjugatedPortTyping	shortName	48659858cc4fc664	48	0
@@ -1986,9 +2071,9 @@ ConnectionDefinition	input	2eecee825df0708e	26	0
 ConnectionDefinition	intersectingType	2eecee825df0708e	26	0
 ConnectionDefinition	isAbstract	427f31df7b099f2b	26	3
 ConnectionDefinition	isConjugated	cdaac4ec44a5ce24	26	0
-ConnectionDefinition	isImplied	1623a0f20f8361b4	26	0
+ConnectionDefinition	isImplied	cdaac4ec44a5ce24	26	0
 ConnectionDefinition	isImpliedIncluded	dc3d44f060a0b58e	26	26
-ConnectionDefinition	isIndividual	1623a0f20f8361b4	26	0
+ConnectionDefinition	isIndividual	cdaac4ec44a5ce24	26	0
 ConnectionDefinition	isLibraryElement	69104f78862067c2	26	6
 ConnectionDefinition	isSufficient	dc3d44f060a0b58e	26	26
 ConnectionDefinition	isVariation	cdaac4ec44a5ce24	26	0
@@ -2017,7 +2102,7 @@ ConnectionDefinition	ownedFeature	e1c7bca6ecf99c7b	26	24
 ConnectionDefinition	ownedFeatureMembership	9a32159947847ffe	26	24
 ConnectionDefinition	ownedFlow	2eecee825df0708e	26	0
 ConnectionDefinition	ownedImport	2eecee825df0708e	26	0
-ConnectionDefinition	ownedInterface	bb1bd616dd831db7	26	12
+ConnectionDefinition	ownedInterface	2eecee825df0708e	26	0
 ConnectionDefinition	ownedIntersecting	2eecee825df0708e	26	0
 ConnectionDefinition	ownedItem	91c178ff7975f91e	26	11
 ConnectionDefinition	ownedMember	93656971beb36f37	26	24
@@ -2028,12 +2113,12 @@ ConnectionDefinition	ownedPart	76f2b7a0ff0904af	26	2
 ConnectionDefinition	ownedPort	78c81654b16ef312	26	1
 ConnectionDefinition	ownedReference	bb1bd616dd831db7	26	12
 ConnectionDefinition	ownedRelatedElement	2eecee825df0708e	26	0
-ConnectionDefinition	ownedRelationship	27aab388ecf69bfc	26	26
+ConnectionDefinition	ownedRelationship	12c6f4ec93ab09b8	26	26
 ConnectionDefinition	ownedRendering	2eecee825df0708e	26	0
 ConnectionDefinition	ownedRequirement	2eecee825df0708e	26	0
-ConnectionDefinition	ownedSpecialization	64a300e87d54f71b	26	26
+ConnectionDefinition	ownedSpecialization	d5168ce238f07631	26	26
 ConnectionDefinition	ownedState	2eecee825df0708e	26	0
-ConnectionDefinition	ownedSubclassification	64a300e87d54f71b	26	26
+ConnectionDefinition	ownedSubclassification	d5168ce238f07631	26	26
 ConnectionDefinition	ownedTransition	2eecee825df0708e	26	0
 ConnectionDefinition	ownedUnioning	2eecee825df0708e	26	0
 ConnectionDefinition	ownedUsage	e1c7bca6ecf99c7b	26	24
@@ -2093,14 +2178,14 @@ ConnectionUsage	isConjugated	98fed713b5a2470c	72	0
 ConnectionUsage	isConstant	98fed713b5a2470c	72	0
 ConnectionUsage	isDerived	98fed713b5a2470c	72	0
 ConnectionUsage	isEnd	98fed713b5a2470c	72	0
-ConnectionUsage	isImplied	6a8adab2e0cdd568	72	0
+ConnectionUsage	isImplied	98fed713b5a2470c	72	0
 ConnectionUsage	isImpliedIncluded	3e087e58a6866c44	72	72
-ConnectionUsage	isIndividual	6a8adab2e0cdd568	72	0
+ConnectionUsage	isIndividual	98fed713b5a2470c	72	0
 ConnectionUsage	isLibraryElement	6ab660996a41265d	72	5
 ConnectionUsage	isOrdered	98fed713b5a2470c	72	0
-ConnectionUsage	isPortion	6a8adab2e0cdd568	72	0
+ConnectionUsage	isPortion	98fed713b5a2470c	72	0
 ConnectionUsage	isReference	c204b92c5fd42c50	72	20
-ConnectionUsage	isSufficient	6a8adab2e0cdd568	72	0
+ConnectionUsage	isSufficient	98fed713b5a2470c	72	0
 ConnectionUsage	isUnique	6c50f4d2f1e78cf3	72	67
 ConnectionUsage	isVariable	6a8adab2e0cdd568	72	0
 ConnectionUsage	isVariation	98fed713b5a2470c	72	0
@@ -2121,7 +2206,7 @@ ConnectionUsage	nestedConnection	76c5a4cdd85efb74	72	0
 ConnectionUsage	nestedConstraint	76c5a4cdd85efb74	72	0
 ConnectionUsage	nestedEnumeration	76c5a4cdd85efb74	72	0
 ConnectionUsage	nestedFlow	76c5a4cdd85efb74	72	0
-ConnectionUsage	nestedInterface	5bae9b18bfe05fcc	72	62
+ConnectionUsage	nestedInterface	76c5a4cdd85efb74	72	0
 ConnectionUsage	nestedItem	276279a7a0b59f15	72	1
 ConnectionUsage	nestedMetadata	76c5a4cdd85efb74	72	0
 ConnectionUsage	nestedOccurrence	2c037d25570f3f2f	72	2
@@ -2157,9 +2242,9 @@ ConnectionUsage	ownedMembership	7f384a982b2c55c7	72	72
 ConnectionUsage	ownedRedefinition	76c5a4cdd85efb74	72	0
 ConnectionUsage	ownedReferenceSubsetting	6a8adab2e0cdd568	72	0
 ConnectionUsage	ownedRelatedElement	76c5a4cdd85efb74	72	0
-ConnectionUsage	ownedRelationship	2c1a24d5992b0222	72	72
-ConnectionUsage	ownedSpecialization	6d6c697cf720c591	72	72
-ConnectionUsage	ownedSubsetting	c65986d1c182832d	72	72
+ConnectionUsage	ownedRelationship	32d6a637a27d164d	72	72
+ConnectionUsage	ownedSpecialization	e035d21d44ec4c38	72	72
+ConnectionUsage	ownedSubsetting	27ed7dd7bd86998e	72	72
 ConnectionUsage	ownedTypeFeaturing	76c5a4cdd85efb74	72	0
 ConnectionUsage	ownedTyping	0265ae75aaa81548	72	19
 ConnectionUsage	ownedUnioning	76c5a4cdd85efb74	72	0
@@ -2175,13 +2260,13 @@ ConnectionUsage	owningUsage	9a263282219eef92	72	33
 ConnectionUsage	partDefinition	80f10333497fc3bd	72	19
 ConnectionUsage	portionKind	6a8adab2e0cdd568	72	0
 ConnectionUsage	qualifiedName	47e8edaccbc82990	72	13
-ConnectionUsage	relatedElement	76c5a4cdd85efb74	72	0
+ConnectionUsage	relatedElement	aa43f3ff91b9989c	72	67
 ConnectionUsage	relatedFeature	aa43f3ff91b9989c	72	67
 ConnectionUsage	shortName	6a8adab2e0cdd568	72	0
-ConnectionUsage	source	76c5a4cdd85efb74	72	0
+ConnectionUsage	source	77c91632319aec4f	72	67
 ConnectionUsage	sourceFeature	49a47fc3955e283c	72	67
-ConnectionUsage	target	76c5a4cdd85efb74	72	0
-ConnectionUsage	targetFeature	c3557ca939223617	72	67
+ConnectionUsage	target	35ed731f6f238d3f	72	67
+ConnectionUsage	targetFeature	35ed731f6f238d3f	72	67
 ConnectionUsage	textualRepresentation	76c5a4cdd85efb74	72	0
 ConnectionUsage	type	80f10333497fc3bd	72	19
 ConnectionUsage	unioningType	76c5a4cdd85efb74	72	0
@@ -2208,7 +2293,7 @@ ConstraintDefinition	intersectingType	d454915277962f88	21	0
 ConstraintDefinition	isAbstract	caa7e38c2b0f4f73	21	0
 ConstraintDefinition	isConjugated	caa7e38c2b0f4f73	21	0
 ConstraintDefinition	isImpliedIncluded	09b4e47ca24a163c	21	21
-ConstraintDefinition	isIndividual	b11350d15d380405	21	0
+ConstraintDefinition	isIndividual	caa7e38c2b0f4f73	21	0
 ConstraintDefinition	isLibraryElement	caa7e38c2b0f4f73	21	0
 ConstraintDefinition	isModelLevelEvaluable	caa7e38c2b0f4f73	21	0
 ConstraintDefinition	isSufficient	caa7e38c2b0f4f73	21	0
@@ -2238,7 +2323,7 @@ ConstraintDefinition	ownedFeature	416d99ca7ac3e286	21	20
 ConstraintDefinition	ownedFeatureMembership	d91d3603c39ff386	21	20
 ConstraintDefinition	ownedFlow	d454915277962f88	21	0
 ConstraintDefinition	ownedImport	d454915277962f88	21	0
-ConstraintDefinition	ownedInterface	3e345ff126586ab1	21	13
+ConstraintDefinition	ownedInterface	d454915277962f88	21	0
 ConstraintDefinition	ownedIntersecting	d454915277962f88	21	0
 ConstraintDefinition	ownedItem	d454915277962f88	21	0
 ConstraintDefinition	ownedMember	416d99ca7ac3e286	21	20
@@ -2275,127 +2360,127 @@ ConstraintDefinition	unioningType	d454915277962f88	21	0
 ConstraintDefinition	usage	d43b6e286e45421e	21	20
 ConstraintDefinition	variant	d454915277962f88	21	0
 ConstraintDefinition	variantMembership	d454915277962f88	21	0
-ConstraintUsage	aliasIds	6a2b31da0f5ce50c	73	0
-ConstraintUsage	behavior	0aa319825bf1482e	73	26
-ConstraintUsage	chainingFeature	6a2b31da0f5ce50c	73	0
-ConstraintUsage	constraintDefinition	85398529cbf53325	73	26
-ConstraintUsage	crossFeature	36f7fb2a22ecfc89	73	0
-ConstraintUsage	declaredName	75e6092e697966d8	73	19
-ConstraintUsage	declaredShortName	36f7fb2a22ecfc89	73	0
-ConstraintUsage	definition	0aa319825bf1482e	73	26
-ConstraintUsage	differencingType	6a2b31da0f5ce50c	73	0
-ConstraintUsage	directedFeature	2d309bfce87c5f34	73	7
-ConstraintUsage	directedUsage	2d309bfce87c5f34	73	7
-ConstraintUsage	direction	36f7fb2a22ecfc89	73	0
-ConstraintUsage	documentation	7fc519d73fbe1674	73	7
-ConstraintUsage	elementId	6b7991b4a86651cc	73	73
-ConstraintUsage	endFeature	6a2b31da0f5ce50c	73	0
-ConstraintUsage	endOwningType	36f7fb2a22ecfc89	73	0
-ConstraintUsage	feature	d1b95ed415dfd885	73	55
-ConstraintUsage	featureMembership	fe881b8f7ed0cc13	73	55
-ConstraintUsage	featureTarget	8e54cb029de968bd	73	0
-ConstraintUsage	featuringType	6a2b31da0f5ce50c	73	0
-ConstraintUsage	function	85398529cbf53325	73	26
-ConstraintUsage	importedMembership	6a2b31da0f5ce50c	73	0
-ConstraintUsage	individualDefinition	36f7fb2a22ecfc89	73	0
-ConstraintUsage	inheritedFeature	6a2b31da0f5ce50c	73	0
-ConstraintUsage	inheritedMembership	6a2b31da0f5ce50c	73	0
-ConstraintUsage	input	2d309bfce87c5f34	73	7
-ConstraintUsage	intersectingType	6a2b31da0f5ce50c	73	0
-ConstraintUsage	isAbstract	ddca65612cc45883	73	0
-ConstraintUsage	isComposite	47fe85adb0176f47	73	68
-ConstraintUsage	isConjugated	ddca65612cc45883	73	0
-ConstraintUsage	isConstant	ddca65612cc45883	73	0
-ConstraintUsage	isDerived	ddca65612cc45883	73	0
-ConstraintUsage	isEnd	ddca65612cc45883	73	0
-ConstraintUsage	isImpliedIncluded	80f7fbf90963fd90	73	73
-ConstraintUsage	isIndividual	36f7fb2a22ecfc89	73	0
-ConstraintUsage	isLibraryElement	ddca65612cc45883	73	0
-ConstraintUsage	isModelLevelEvaluable	ddca65612cc45883	73	0
-ConstraintUsage	isOrdered	ddca65612cc45883	73	0
-ConstraintUsage	isPortion	36f7fb2a22ecfc89	73	0
-ConstraintUsage	isReference	16c3dbac8610e6cc	73	5
-ConstraintUsage	isSufficient	36f7fb2a22ecfc89	73	0
-ConstraintUsage	isUnique	80f7fbf90963fd90	73	73
-ConstraintUsage	isVariable	36f7fb2a22ecfc89	73	0
-ConstraintUsage	isVariation	ddca65612cc45883	73	0
-ConstraintUsage	mayTimeVary	36f7fb2a22ecfc89	73	0
-ConstraintUsage	member	329c2821c4bec7cd	73	59
-ConstraintUsage	membership	2e565615ab0343e2	73	59
-ConstraintUsage	multiplicity	36f7fb2a22ecfc89	73	0
-ConstraintUsage	name	85e2d03eca0e6d18	73	36
-ConstraintUsage	nestedAction	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedAllocation	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedAnalysisCase	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedAttribute	61c6cd07ce177c03	73	6
-ConstraintUsage	nestedCalculation	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedCase	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedConcern	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedConnection	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedConstraint	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedEnumeration	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedFlow	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedInterface	a8b960c28d38b366	73	12
-ConstraintUsage	nestedItem	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedMetadata	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedOccurrence	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedPart	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedPort	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedReference	a8b960c28d38b366	73	12
-ConstraintUsage	nestedRendering	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedRequirement	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedState	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedTransition	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedUsage	a054fbf04bf34a5d	73	18
-ConstraintUsage	nestedUseCase	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedVerificationCase	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedView	6a2b31da0f5ce50c	73	0
-ConstraintUsage	nestedViewpoint	6a2b31da0f5ce50c	73	0
-ConstraintUsage	occurrenceDefinition	0aa319825bf1482e	73	26
-ConstraintUsage	output	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedAnnotation	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedConjugator	36f7fb2a22ecfc89	73	0
-ConstraintUsage	ownedCrossSubsetting	36f7fb2a22ecfc89	73	0
-ConstraintUsage	ownedDifferencing	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedDisjoining	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedElement	e9807409fbca29cc	73	60
-ConstraintUsage	ownedEndFeature	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedFeature	d1b95ed415dfd885	73	55
-ConstraintUsage	ownedFeatureChaining	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedFeatureInverting	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedFeatureMembership	fe881b8f7ed0cc13	73	55
-ConstraintUsage	ownedImport	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedIntersecting	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedMember	329c2821c4bec7cd	73	59
-ConstraintUsage	ownedMembership	2e565615ab0343e2	73	59
-ConstraintUsage	ownedRedefinition	3806fe84ee6dd381	73	1
-ConstraintUsage	ownedReferenceSubsetting	c8eed2f8b7e77961	73	18
-ConstraintUsage	ownedRelationship	f559333a6bc7759e	73	73
-ConstraintUsage	ownedSpecialization	0a90d0d3e8d2a442	73	73
-ConstraintUsage	ownedSubsetting	c79a321538caeb5f	73	73
-ConstraintUsage	ownedTypeFeaturing	6a2b31da0f5ce50c	73	0
-ConstraintUsage	ownedTyping	6de7442a27451473	73	12
-ConstraintUsage	ownedUnioning	6a2b31da0f5ce50c	73	0
-ConstraintUsage	owner	2b75e7e46428d03f	73	73
-ConstraintUsage	owningDefinition	d74945d39b9faa2c	73	25
-ConstraintUsage	owningFeatureMembership	7bb19becc37b4654	73	68
-ConstraintUsage	owningMembership	6a9a47ffe3b61c1c	73	73
-ConstraintUsage	owningNamespace	2b75e7e46428d03f	73	73
-ConstraintUsage	owningRelationship	6a9a47ffe3b61c1c	73	73
-ConstraintUsage	owningType	3f2e85adcc63922f	73	68
-ConstraintUsage	owningUsage	9edd3b0453b0e48c	73	43
-ConstraintUsage	parameter	2d309bfce87c5f34	73	7
-ConstraintUsage	portionKind	36f7fb2a22ecfc89	73	0
-ConstraintUsage	predicate	85398529cbf53325	73	26
-ConstraintUsage	qualifiedName	8e43279ca18afee4	73	36
-ConstraintUsage	result	8e54cb029de968bd	73	0
-ConstraintUsage	shortName	fba030b523b04d82	73	10
-ConstraintUsage	textualRepresentation	6a2b31da0f5ce50c	73	0
-ConstraintUsage	type	0aa319825bf1482e	73	26
-ConstraintUsage	unioningType	6a2b31da0f5ce50c	73	0
-ConstraintUsage	usage	a054fbf04bf34a5d	73	18
-ConstraintUsage	variant	6a2b31da0f5ce50c	73	0
-ConstraintUsage	variantMembership	6a2b31da0f5ce50c	73	0
+ConstraintUsage	aliasIds	19c68f525372542e	73	0
+ConstraintUsage	behavior	ba3e76faa006b750	73	26
+ConstraintUsage	chainingFeature	19c68f525372542e	73	0
+ConstraintUsage	constraintDefinition	4cd645fab8d7ae4f	73	26
+ConstraintUsage	crossFeature	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	declaredName	3d82c9ff565be202	73	19
+ConstraintUsage	declaredShortName	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	definition	ba3e76faa006b750	73	26
+ConstraintUsage	differencingType	19c68f525372542e	73	0
+ConstraintUsage	directedFeature	dccbf9752c91ce56	73	7
+ConstraintUsage	directedUsage	dccbf9752c91ce56	73	7
+ConstraintUsage	direction	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	documentation	2f60774f83d38596	73	7
+ConstraintUsage	elementId	801fc3420f27fc88	73	73
+ConstraintUsage	endFeature	19c68f525372542e	73	0
+ConstraintUsage	endOwningType	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	feature	8154bc4c59f547a7	73	55
+ConstraintUsage	featureMembership	ae237907c2e63b35	73	55
+ConstraintUsage	featureTarget	0de8abb89fca3f29	73	0
+ConstraintUsage	featuringType	19c68f525372542e	73	0
+ConstraintUsage	function	4cd645fab8d7ae4f	73	26
+ConstraintUsage	importedMembership	19c68f525372542e	73	0
+ConstraintUsage	individualDefinition	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	inheritedFeature	19c68f525372542e	73	0
+ConstraintUsage	inheritedMembership	19c68f525372542e	73	0
+ConstraintUsage	input	dccbf9752c91ce56	73	7
+ConstraintUsage	intersectingType	19c68f525372542e	73	0
+ConstraintUsage	isAbstract	4edb180a84e072ad	73	0
+ConstraintUsage	isComposite	2ad4025b57409651	73	68
+ConstraintUsage	isConjugated	4edb180a84e072ad	73	0
+ConstraintUsage	isConstant	4edb180a84e072ad	73	0
+ConstraintUsage	isDerived	4edb180a84e072ad	73	0
+ConstraintUsage	isEnd	4edb180a84e072ad	73	0
+ConstraintUsage	isImpliedIncluded	63cd78a6b08d249a	73	73
+ConstraintUsage	isIndividual	4edb180a84e072ad	73	0
+ConstraintUsage	isLibraryElement	4edb180a84e072ad	73	0
+ConstraintUsage	isModelLevelEvaluable	4edb180a84e072ad	73	0
+ConstraintUsage	isOrdered	4edb180a84e072ad	73	0
+ConstraintUsage	isPortion	4edb180a84e072ad	73	0
+ConstraintUsage	isReference	87d48e55de2d00f6	73	5
+ConstraintUsage	isSufficient	4edb180a84e072ad	73	0
+ConstraintUsage	isUnique	63cd78a6b08d249a	73	73
+ConstraintUsage	isVariable	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	isVariation	4edb180a84e072ad	73	0
+ConstraintUsage	mayTimeVary	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	member	e237859a08d436ef	73	59
+ConstraintUsage	membership	ddf1b38def18b304	73	59
+ConstraintUsage	multiplicity	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	name	1277bf1bcc05a579	73	37
+ConstraintUsage	nestedAction	19c68f525372542e	73	0
+ConstraintUsage	nestedAllocation	19c68f525372542e	73	0
+ConstraintUsage	nestedAnalysisCase	19c68f525372542e	73	0
+ConstraintUsage	nestedAttribute	11622a80122ceb25	73	6
+ConstraintUsage	nestedCalculation	19c68f525372542e	73	0
+ConstraintUsage	nestedCase	19c68f525372542e	73	0
+ConstraintUsage	nestedConcern	19c68f525372542e	73	0
+ConstraintUsage	nestedConnection	19c68f525372542e	73	0
+ConstraintUsage	nestedConstraint	19c68f525372542e	73	0
+ConstraintUsage	nestedEnumeration	19c68f525372542e	73	0
+ConstraintUsage	nestedFlow	19c68f525372542e	73	0
+ConstraintUsage	nestedInterface	19c68f525372542e	73	0
+ConstraintUsage	nestedItem	19c68f525372542e	73	0
+ConstraintUsage	nestedMetadata	19c68f525372542e	73	0
+ConstraintUsage	nestedOccurrence	19c68f525372542e	73	0
+ConstraintUsage	nestedPart	19c68f525372542e	73	0
+ConstraintUsage	nestedPort	19c68f525372542e	73	0
+ConstraintUsage	nestedReference	5854be3ad14e2288	73	12
+ConstraintUsage	nestedRendering	19c68f525372542e	73	0
+ConstraintUsage	nestedRequirement	19c68f525372542e	73	0
+ConstraintUsage	nestedState	19c68f525372542e	73	0
+ConstraintUsage	nestedTransition	19c68f525372542e	73	0
+ConstraintUsage	nestedUsage	4ff059689008b97f	73	18
+ConstraintUsage	nestedUseCase	19c68f525372542e	73	0
+ConstraintUsage	nestedVerificationCase	19c68f525372542e	73	0
+ConstraintUsage	nestedView	19c68f525372542e	73	0
+ConstraintUsage	nestedViewpoint	19c68f525372542e	73	0
+ConstraintUsage	occurrenceDefinition	ba3e76faa006b750	73	26
+ConstraintUsage	output	19c68f525372542e	73	0
+ConstraintUsage	ownedAnnotation	19c68f525372542e	73	0
+ConstraintUsage	ownedConjugator	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	ownedCrossSubsetting	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	ownedDifferencing	19c68f525372542e	73	0
+ConstraintUsage	ownedDisjoining	19c68f525372542e	73	0
+ConstraintUsage	ownedElement	f7f611a72d09d356	73	60
+ConstraintUsage	ownedEndFeature	19c68f525372542e	73	0
+ConstraintUsage	ownedFeature	8154bc4c59f547a7	73	55
+ConstraintUsage	ownedFeatureChaining	19c68f525372542e	73	0
+ConstraintUsage	ownedFeatureInverting	19c68f525372542e	73	0
+ConstraintUsage	ownedFeatureMembership	ae237907c2e63b35	73	55
+ConstraintUsage	ownedImport	19c68f525372542e	73	0
+ConstraintUsage	ownedIntersecting	19c68f525372542e	73	0
+ConstraintUsage	ownedMember	e237859a08d436ef	73	59
+ConstraintUsage	ownedMembership	ddf1b38def18b304	73	59
+ConstraintUsage	ownedRedefinition	e7a25bfd328342a3	73	1
+ConstraintUsage	ownedReferenceSubsetting	2cfe254885cb1adf	73	18
+ConstraintUsage	ownedRelationship	0156478ca19c512d	73	73
+ConstraintUsage	ownedSpecialization	bf3cc892e5b8d979	73	73
+ConstraintUsage	ownedSubsetting	68caf933b1f7add2	73	73
+ConstraintUsage	ownedTypeFeaturing	19c68f525372542e	73	0
+ConstraintUsage	ownedTyping	1d82a1a26b5a8395	73	12
+ConstraintUsage	ownedUnioning	19c68f525372542e	73	0
+ConstraintUsage	owner	c9e458015fe5b9b5	73	73
+ConstraintUsage	owningDefinition	9ee606a488822556	73	25
+ConstraintUsage	owningFeatureMembership	4c32defdb405cdff	73	68
+ConstraintUsage	owningMembership	3b1b8b10d440a3c7	73	73
+ConstraintUsage	owningNamespace	c9e458015fe5b9b5	73	73
+ConstraintUsage	owningRelationship	3b1b8b10d440a3c7	73	73
+ConstraintUsage	owningType	dd9cf5cac8207ba5	73	68
+ConstraintUsage	owningUsage	3d4bab214f6dce02	73	43
+ConstraintUsage	parameter	dccbf9752c91ce56	73	7
+ConstraintUsage	portionKind	fe94bbfb0fcf77b3	73	0
+ConstraintUsage	predicate	4cd645fab8d7ae4f	73	26
+ConstraintUsage	qualifiedName	bd7ad2f884e4d7a2	73	37
+ConstraintUsage	result	0de8abb89fca3f29	73	0
+ConstraintUsage	shortName	81500227bd8e28b9	73	11
+ConstraintUsage	textualRepresentation	19c68f525372542e	73	0
+ConstraintUsage	type	ba3e76faa006b750	73	26
+ConstraintUsage	unioningType	19c68f525372542e	73	0
+ConstraintUsage	usage	4ff059689008b97f	73	18
+ConstraintUsage	variant	19c68f525372542e	73	0
+ConstraintUsage	variantMembership	19c68f525372542e	73	0
 ConstructorExpression	aliasIds	f8ff85c6262ce9f1	90	0
 ConstructorExpression	argument	4b17a1302eeeaa7a	90	71
 ConstructorExpression	behavior	f8ff85c6262ce9f1	90	0
@@ -2421,20 +2506,20 @@ ConstructorExpression	inheritedMembership	f8ff85c6262ce9f1	90	0
 ConstructorExpression	input	ee66e2732b606d84	90	71
 ConstructorExpression	instantiatedType	fb341fddbabec0b4	90	90
 ConstructorExpression	intersectingType	f8ff85c6262ce9f1	90	0
-ConstructorExpression	isAbstract	1f0803963818dc65	90	0
-ConstructorExpression	isComposite	1f0803963818dc65	90	0
+ConstructorExpression	isAbstract	90352bca78f62433	90	0
+ConstructorExpression	isComposite	90352bca78f62433	90	0
 ConstructorExpression	isConjugated	90352bca78f62433	90	0
-ConstructorExpression	isConstant	1f0803963818dc65	90	0
-ConstructorExpression	isDerived	1f0803963818dc65	90	0
-ConstructorExpression	isEnd	1f0803963818dc65	90	0
+ConstructorExpression	isConstant	90352bca78f62433	90	0
+ConstructorExpression	isDerived	90352bca78f62433	90	0
+ConstructorExpression	isEnd	90352bca78f62433	90	0
 ConstructorExpression	isImpliedIncluded	aea40fc4ab0b5ded	90	90
 ConstructorExpression	isLibraryElement	90352bca78f62433	90	0
-ConstructorExpression	isModelLevelEvaluable	4e55b8b864e0e60c	90	29
-ConstructorExpression	isOrdered	1f0803963818dc65	90	0
-ConstructorExpression	isPortion	1f0803963818dc65	90	0
-ConstructorExpression	isSufficient	1f0803963818dc65	90	0
-ConstructorExpression	isUnique	1f0803963818dc65	90	0
-ConstructorExpression	isVariable	1f0803963818dc65	90	0
+ConstructorExpression	isModelLevelEvaluable	422b187bcd9ac4ea	90	27
+ConstructorExpression	isOrdered	90352bca78f62433	90	0
+ConstructorExpression	isPortion	90352bca78f62433	90	0
+ConstructorExpression	isSufficient	90352bca78f62433	90	0
+ConstructorExpression	isUnique	aea40fc4ab0b5ded	90	90
+ConstructorExpression	isVariable	90352bca78f62433	90	0
 ConstructorExpression	member	afbd0ed181ae0553	90	90
 ConstructorExpression	membership	e7a8aac0b5437d75	90	90
 ConstructorExpression	multiplicity	1f0803963818dc65	90	0
@@ -2457,9 +2542,9 @@ ConstructorExpression	ownedMember	ee66e2732b606d84	90	71
 ConstructorExpression	ownedMembership	e7a8aac0b5437d75	90	90
 ConstructorExpression	ownedRedefinition	f8ff85c6262ce9f1	90	0
 ConstructorExpression	ownedReferenceSubsetting	1f0803963818dc65	90	0
-ConstructorExpression	ownedRelationship	e7a8aac0b5437d75	90	90
-ConstructorExpression	ownedSpecialization	f8ff85c6262ce9f1	90	0
-ConstructorExpression	ownedSubsetting	f8ff85c6262ce9f1	90	0
+ConstructorExpression	ownedRelationship	5d52d444363749ed	90	90
+ConstructorExpression	ownedSpecialization	7d9a51998d21821d	90	90
+ConstructorExpression	ownedSubsetting	7d9a51998d21821d	90	90
 ConstructorExpression	ownedTypeFeaturing	f8ff85c6262ce9f1	90	0
 ConstructorExpression	ownedTyping	f8ff85c6262ce9f1	90	0
 ConstructorExpression	ownedUnioning	f8ff85c6262ce9f1	90	0
@@ -2541,12 +2626,12 @@ DecisionNode	isConstant	5b34acf0878918b1	6	0
 DecisionNode	isDerived	5b34acf0878918b1	6	0
 DecisionNode	isEnd	5b34acf0878918b1	6	0
 DecisionNode	isImpliedIncluded	2654cf9111944b77	6	6
-DecisionNode	isIndividual	a0ff21444582518b	6	0
+DecisionNode	isIndividual	5b34acf0878918b1	6	0
 DecisionNode	isLibraryElement	5b34acf0878918b1	6	0
 DecisionNode	isOrdered	5b34acf0878918b1	6	0
-DecisionNode	isPortion	a0ff21444582518b	6	0
+DecisionNode	isPortion	5b34acf0878918b1	6	0
 DecisionNode	isReference	5b34acf0878918b1	6	0
-DecisionNode	isSufficient	a0ff21444582518b	6	0
+DecisionNode	isSufficient	5b34acf0878918b1	6	0
 DecisionNode	isUnique	2654cf9111944b77	6	6
 DecisionNode	isVariable	a0ff21444582518b	6	0
 DecisionNode	isVariation	5b34acf0878918b1	6	0
@@ -2601,9 +2686,9 @@ DecisionNode	ownedMember	36431934a5be0cc3	6	0
 DecisionNode	ownedMembership	36431934a5be0cc3	6	0
 DecisionNode	ownedRedefinition	36431934a5be0cc3	6	0
 DecisionNode	ownedReferenceSubsetting	a0ff21444582518b	6	0
-DecisionNode	ownedRelationship	36431934a5be0cc3	6	0
-DecisionNode	ownedSpecialization	36431934a5be0cc3	6	0
-DecisionNode	ownedSubsetting	36431934a5be0cc3	6	0
+DecisionNode	ownedRelationship	927b27f9fd447df7	6	6
+DecisionNode	ownedSpecialization	927b27f9fd447df7	6	6
+DecisionNode	ownedSubsetting	927b27f9fd447df7	6	6
 DecisionNode	ownedTypeFeaturing	36431934a5be0cc3	6	0
 DecisionNode	ownedTyping	36431934a5be0cc3	6	0
 DecisionNode	ownedUnioning	36431934a5be0cc3	6	0
@@ -2672,7 +2757,7 @@ Definition	ownedFeature	59d458357c1a26da	2	2
 Definition	ownedFeatureMembership	1ae1e1704a0265b8	2	2
 Definition	ownedFlow	561b7c9e4010737f	2	0
 Definition	ownedImport	561b7c9e4010737f	2	0
-Definition	ownedInterface	88ed93fd4a097e41	2	1
+Definition	ownedInterface	561b7c9e4010737f	2	0
 Definition	ownedIntersecting	561b7c9e4010737f	2	0
 Definition	ownedItem	7e1689b1892db1d1	2	1
 Definition	ownedMember	7ae97b574a06c616	2	2
@@ -2792,42 +2877,42 @@ ElementFilterMembership	source	9a844c7f9b084209	26	26
 ElementFilterMembership	target	2e98b386e75a2c3f	26	26
 ElementFilterMembership	textualRepresentation	71d6deb8ce2e2308	26	0
 ElementFilterMembership	visibility	0d6e8b2c454edac8	26	26
-EndFeatureMembership	aliasIds	2712c4685b225924	1420	0
-EndFeatureMembership	declaredName	746a6baf09990a08	1420	0
-EndFeatureMembership	declaredShortName	746a6baf09990a08	1420	0
-EndFeatureMembership	documentation	2712c4685b225924	1420	0
-EndFeatureMembership	elementId	d3bd686289112b54	1420	1420
-EndFeatureMembership	isImplied	4cfcea9fe5814410	1420	0
-EndFeatureMembership	isImpliedIncluded	e754979b99ae8164	1420	1420
-EndFeatureMembership	isLibraryElement	55640232948e62a8	1420	8
-EndFeatureMembership	memberElement	1080836271a61993	1420	1420
-EndFeatureMembership	memberElementId	7e7932cb7ac4913b	1420	1420
-EndFeatureMembership	memberName	71e4ffe51e050073	1420	1412
-EndFeatureMembership	memberShortName	746a6baf09990a08	1420	0
-EndFeatureMembership	membershipOwningNamespace	8950112cee466c96	1420	1420
-EndFeatureMembership	name	746a6baf09990a08	1420	0
-EndFeatureMembership	ownedAnnotation	2712c4685b225924	1420	0
-EndFeatureMembership	ownedElement	2712c4685b225924	1420	0
-EndFeatureMembership	ownedMemberElement	1080836271a61993	1420	1420
-EndFeatureMembership	ownedMemberElementId	7e7932cb7ac4913b	1420	1420
-EndFeatureMembership	ownedMemberFeature	1080836271a61993	1420	1420
-EndFeatureMembership	ownedMemberName	71e4ffe51e050073	1420	1412
-EndFeatureMembership	ownedMemberShortName	746a6baf09990a08	1420	0
-EndFeatureMembership	ownedRelatedElement	4ae84f33fa399665	1420	1420
-EndFeatureMembership	ownedRelationship	2712c4685b225924	1420	0
-EndFeatureMembership	owner	746a6baf09990a08	1420	0
-EndFeatureMembership	owningMembership	746a6baf09990a08	1420	0
-EndFeatureMembership	owningNamespace	746a6baf09990a08	1420	0
-EndFeatureMembership	owningRelatedElement	8950112cee466c96	1420	1420
-EndFeatureMembership	owningRelationship	746a6baf09990a08	1420	0
-EndFeatureMembership	owningType	8950112cee466c96	1420	1420
-EndFeatureMembership	qualifiedName	746a6baf09990a08	1420	0
-EndFeatureMembership	relatedElement	da0d70033c49980f	1420	1420
-EndFeatureMembership	shortName	746a6baf09990a08	1420	0
-EndFeatureMembership	source	4246bc6b75f5f85a	1420	1420
-EndFeatureMembership	target	4ae84f33fa399665	1420	1420
-EndFeatureMembership	textualRepresentation	2712c4685b225924	1420	0
-EndFeatureMembership	visibility	b4efc8a5792c1320	1420	1176
+EndFeatureMembership	aliasIds	f22647be624dbc33	4764	0
+EndFeatureMembership	declaredName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	declaredShortName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	documentation	f22647be624dbc33	4764	0
+EndFeatureMembership	elementId	9699e4fdb82a5c84	4764	4764
+EndFeatureMembership	isImplied	802d4a48042d5bfb	4764	3344
+EndFeatureMembership	isImpliedIncluded	1a84f743b85a994f	4764	4764
+EndFeatureMembership	isLibraryElement	d0a43964c5285bcb	4764	8
+EndFeatureMembership	memberElement	d81bd2812536efc0	4764	4764
+EndFeatureMembership	memberElementId	2164abc6d0943eda	4764	4764
+EndFeatureMembership	memberName	75176ace9925f213	4764	4738
+EndFeatureMembership	memberShortName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	membershipOwningNamespace	77792826d32b3b9b	4764	4764
+EndFeatureMembership	name	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	ownedAnnotation	f22647be624dbc33	4764	0
+EndFeatureMembership	ownedElement	f22647be624dbc33	4764	0
+EndFeatureMembership	ownedMemberElement	d81bd2812536efc0	4764	4764
+EndFeatureMembership	ownedMemberElementId	2164abc6d0943eda	4764	4764
+EndFeatureMembership	ownedMemberFeature	d81bd2812536efc0	4764	4764
+EndFeatureMembership	ownedMemberName	edc2f8e56818d533	4764	4749
+EndFeatureMembership	ownedMemberShortName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	ownedRelatedElement	caac8f648242f38e	4764	4764
+EndFeatureMembership	ownedRelationship	f22647be624dbc33	4764	0
+EndFeatureMembership	owner	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	owningMembership	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	owningNamespace	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	owningRelatedElement	77792826d32b3b9b	4764	4764
+EndFeatureMembership	owningRelationship	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	owningType	77792826d32b3b9b	4764	4764
+EndFeatureMembership	qualifiedName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	relatedElement	b50050cbf3c1745c	4764	4764
+EndFeatureMembership	shortName	02ee5ed1c4e0df85	4764	0
+EndFeatureMembership	source	3e315629a8996fb7	4764	4764
+EndFeatureMembership	target	caac8f648242f38e	4764	4764
+EndFeatureMembership	textualRepresentation	f22647be624dbc33	4764	0
+EndFeatureMembership	visibility	35490772f68e2629	4764	4764
 EnumerationDefinition	aliasIds	c486104c609991eb	19	0
 EnumerationDefinition	declaredName	0c1eb77f1a9b9ba2	19	19
 EnumerationDefinition	declaredShortName	9a82e34d3d167a0c	19	0
@@ -2944,9 +3029,9 @@ EnumerationUsage	isEnd	be8484459cd48dd4	55	0
 EnumerationUsage	isImpliedIncluded	06bc574c8d6f8c5f	55	55
 EnumerationUsage	isLibraryElement	89140a86a36fad8c	55	8
 EnumerationUsage	isOrdered	be8484459cd48dd4	55	0
-EnumerationUsage	isPortion	cc4a9248592f7ce8	55	0
+EnumerationUsage	isPortion	be8484459cd48dd4	55	0
 EnumerationUsage	isReference	06bc574c8d6f8c5f	55	55
-EnumerationUsage	isSufficient	cc4a9248592f7ce8	55	0
+EnumerationUsage	isSufficient	be8484459cd48dd4	55	0
 EnumerationUsage	isUnique	06bc574c8d6f8c5f	55	55
 EnumerationUsage	isVariable	cc4a9248592f7ce8	55	0
 EnumerationUsage	isVariation	be8484459cd48dd4	55	0
@@ -2966,7 +3051,7 @@ EnumerationUsage	nestedConnection	387d429d75a5c0af	55	0
 EnumerationUsage	nestedConstraint	387d429d75a5c0af	55	0
 EnumerationUsage	nestedEnumeration	387d429d75a5c0af	55	0
 EnumerationUsage	nestedFlow	387d429d75a5c0af	55	0
-EnumerationUsage	nestedInterface	8acf6a2297cd12c4	55	9
+EnumerationUsage	nestedInterface	387d429d75a5c0af	55	0
 EnumerationUsage	nestedItem	387d429d75a5c0af	55	0
 EnumerationUsage	nestedMetadata	387d429d75a5c0af	55	0
 EnumerationUsage	nestedOccurrence	387d429d75a5c0af	55	0
@@ -3000,9 +3085,9 @@ EnumerationUsage	ownedMember	043fc2ad9cf41916	55	28
 EnumerationUsage	ownedMembership	575fe9461b0fe8f0	55	28
 EnumerationUsage	ownedRedefinition	387d429d75a5c0af	55	0
 EnumerationUsage	ownedReferenceSubsetting	cc4a9248592f7ce8	55	0
-EnumerationUsage	ownedRelationship	49eb1c5b966eaec0	55	55
-EnumerationUsage	ownedSpecialization	b3a66747e496cd53	55	54
-EnumerationUsage	ownedSubsetting	387d429d75a5c0af	55	0
+EnumerationUsage	ownedRelationship	f68891a28ff7949b	55	55
+EnumerationUsage	ownedSpecialization	5651798a09bc1c40	55	55
+EnumerationUsage	ownedSubsetting	4a494b2525bd792e	55	55
 EnumerationUsage	ownedTypeFeaturing	387d429d75a5c0af	55	0
 EnumerationUsage	ownedTyping	b3a66747e496cd53	55	54
 EnumerationUsage	ownedUnioning	387d429d75a5c0af	55	0
@@ -3054,12 +3139,12 @@ EventOccurrenceUsage	isConstant	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isDerived	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isEnd	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isImpliedIncluded	50078a776cb6358f	129	129
-EventOccurrenceUsage	isIndividual	421787a3009e910e	129	0
+EventOccurrenceUsage	isIndividual	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isLibraryElement	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isOrdered	8c334b651b83de2a	129	0
-EventOccurrenceUsage	isPortion	421787a3009e910e	129	0
+EventOccurrenceUsage	isPortion	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isReference	50078a776cb6358f	129	129
-EventOccurrenceUsage	isSufficient	421787a3009e910e	129	0
+EventOccurrenceUsage	isSufficient	8c334b651b83de2a	129	0
 EventOccurrenceUsage	isUnique	50078a776cb6358f	129	129
 EventOccurrenceUsage	isVariable	421787a3009e910e	129	0
 EventOccurrenceUsage	isVariation	8c334b651b83de2a	129	0
@@ -3067,7 +3152,7 @@ EventOccurrenceUsage	mayTimeVary	421787a3009e910e	129	0
 EventOccurrenceUsage	member	fde5fffe0c399999	129	55
 EventOccurrenceUsage	membership	28bc5c85d1d157b4	129	55
 EventOccurrenceUsage	multiplicity	2a0370eff469fcd5	129	46
-EventOccurrenceUsage	name	e000be09b75251bf	129	129
+EventOccurrenceUsage	name	9e84e77468f14436	129	82
 EventOccurrenceUsage	nestedAction	8f1a7602506fce47	129	0
 EventOccurrenceUsage	nestedAllocation	8f1a7602506fce47	129	0
 EventOccurrenceUsage	nestedAnalysisCase	8f1a7602506fce47	129	0
@@ -3129,7 +3214,7 @@ EventOccurrenceUsage	owningRelationship	e7010ddd421886c6	129	129
 EventOccurrenceUsage	owningType	84bd9c1cebac1077	129	129
 EventOccurrenceUsage	owningUsage	6a95f1b4a24c8fba	129	128
 EventOccurrenceUsage	portionKind	421787a3009e910e	129	0
-EventOccurrenceUsage	qualifiedName	9bfe588ef5246454	129	129
+EventOccurrenceUsage	qualifiedName	863de6f829313c5b	129	82
 EventOccurrenceUsage	shortName	421787a3009e910e	129	0
 EventOccurrenceUsage	textualRepresentation	8f1a7602506fce47	129	0
 EventOccurrenceUsage	type	f7cd9d04d826a502	129	7
@@ -3137,131 +3222,131 @@ EventOccurrenceUsage	unioningType	8f1a7602506fce47	129	0
 EventOccurrenceUsage	usage	8f1a7602506fce47	129	0
 EventOccurrenceUsage	variant	8f1a7602506fce47	129	0
 EventOccurrenceUsage	variantMembership	8f1a7602506fce47	129	0
-ExhibitStateUsage	actionDefinition	6eb4b68af6644771	29	13
-ExhibitStateUsage	aliasIds	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	behavior	6eb4b68af6644771	29	13
-ExhibitStateUsage	chainingFeature	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	crossFeature	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	declaredName	45d4b0ed17156d6a	29	19
-ExhibitStateUsage	declaredShortName	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	definition	6eb4b68af6644771	29	13
-ExhibitStateUsage	differencingType	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	directedFeature	6748e972130e2b69	29	1
-ExhibitStateUsage	directedUsage	6748e972130e2b69	29	1
-ExhibitStateUsage	direction	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	doAction	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	documentation	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	elementId	77795d014df1ed68	29	29
-ExhibitStateUsage	endFeature	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	endOwningType	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	entryAction	2e234ecf03ac8a5d	29	4
-ExhibitStateUsage	eventOccurrence	73f978b7ce9526a1	29	10
-ExhibitStateUsage	exhibitedState	73f978b7ce9526a1	29	10
-ExhibitStateUsage	exitAction	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	feature	5ef8c1e54453db84	29	9
-ExhibitStateUsage	featureMembership	a5bd54b451a12c67	29	9
-ExhibitStateUsage	featureTarget	0116a2dfc191162b	29	0
-ExhibitStateUsage	featuringType	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	importedMembership	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	individualDefinition	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	inheritedFeature	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	inheritedMembership	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	input	6748e972130e2b69	29	1
-ExhibitStateUsage	intersectingType	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	isAbstract	e3f43f31904915de	29	0
-ExhibitStateUsage	isComposite	e3f43f31904915de	29	0
-ExhibitStateUsage	isConjugated	e3f43f31904915de	29	0
-ExhibitStateUsage	isConstant	e3f43f31904915de	29	0
-ExhibitStateUsage	isDerived	e3f43f31904915de	29	0
-ExhibitStateUsage	isEnd	e3f43f31904915de	29	0
-ExhibitStateUsage	isImpliedIncluded	65e6796eeda6a607	29	29
-ExhibitStateUsage	isIndividual	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	isLibraryElement	e3f43f31904915de	29	0
-ExhibitStateUsage	isOrdered	e3f43f31904915de	29	0
-ExhibitStateUsage	isParallel	fa06cd8f97702bd8	29	2
-ExhibitStateUsage	isPortion	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	isReference	65e6796eeda6a607	29	29
-ExhibitStateUsage	isSufficient	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	isUnique	65e6796eeda6a607	29	29
-ExhibitStateUsage	isVariable	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	isVariation	e3f43f31904915de	29	0
-ExhibitStateUsage	mayTimeVary	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	member	a19338ea746f4cf5	29	12
-ExhibitStateUsage	membership	ca865e11bfb5e0e2	29	12
-ExhibitStateUsage	multiplicity	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	name	50985497b31a4a9f	29	29
-ExhibitStateUsage	nestedAction	8c708aa889090fa4	29	8
-ExhibitStateUsage	nestedAllocation	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedAnalysisCase	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedAttribute	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedCalculation	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedCase	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedConcern	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedConnection	ae9869acfecaa0b9	29	4
-ExhibitStateUsage	nestedConstraint	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedEnumeration	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedFlow	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedInterface	a156f618058611a9	29	2
-ExhibitStateUsage	nestedItem	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedMetadata	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedOccurrence	8c708aa889090fa4	29	8
-ExhibitStateUsage	nestedPart	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedPort	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedReference	a156f618058611a9	29	2
-ExhibitStateUsage	nestedRendering	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedRequirement	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedState	2041fd3d80851b38	29	8
-ExhibitStateUsage	nestedTransition	240db0978b013f16	29	3
-ExhibitStateUsage	nestedUsage	5ef8c1e54453db84	29	9
-ExhibitStateUsage	nestedUseCase	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedVerificationCase	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedView	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	nestedViewpoint	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	occurrenceDefinition	6eb4b68af6644771	29	13
-ExhibitStateUsage	output	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedAnnotation	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedConjugator	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	ownedCrossSubsetting	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	ownedDifferencing	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedDisjoining	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedElement	c4fb24dcdc81377a	29	14
-ExhibitStateUsage	ownedEndFeature	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedFeature	5ef8c1e54453db84	29	9
-ExhibitStateUsage	ownedFeatureChaining	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedFeatureInverting	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedFeatureMembership	a5bd54b451a12c67	29	9
-ExhibitStateUsage	ownedImport	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedIntersecting	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedMember	a19338ea746f4cf5	29	12
-ExhibitStateUsage	ownedMembership	ca865e11bfb5e0e2	29	12
-ExhibitStateUsage	ownedRedefinition	215e9b4459ab514f	29	8
-ExhibitStateUsage	ownedReferenceSubsetting	67fbe10d6f340abe	29	10
-ExhibitStateUsage	ownedRelationship	6201e5c93f0c453d	29	29
-ExhibitStateUsage	ownedSpecialization	a96d763a38965182	29	29
-ExhibitStateUsage	ownedSubsetting	7c2e3c2f34a93e8c	29	29
-ExhibitStateUsage	ownedTypeFeaturing	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	ownedTyping	ef8249a173d93f8f	29	6
-ExhibitStateUsage	ownedUnioning	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	owner	5a3ed4b406819608	29	29
-ExhibitStateUsage	owningDefinition	3baa54dfd1fd5683	29	14
-ExhibitStateUsage	owningFeatureMembership	1dd303701c36d6f7	29	29
-ExhibitStateUsage	owningMembership	1dd303701c36d6f7	29	29
-ExhibitStateUsage	owningNamespace	5a3ed4b406819608	29	29
-ExhibitStateUsage	owningRelationship	1dd303701c36d6f7	29	29
-ExhibitStateUsage	owningType	5a3ed4b406819608	29	29
-ExhibitStateUsage	owningUsage	41230e8f6d7b1663	29	15
-ExhibitStateUsage	parameter	6748e972130e2b69	29	1
-ExhibitStateUsage	performedAction	73f978b7ce9526a1	29	10
-ExhibitStateUsage	portionKind	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	qualifiedName	133451ec007b64b2	29	29
-ExhibitStateUsage	shortName	228e8ebb38f6d6de	29	0
-ExhibitStateUsage	stateDefinition	6eb4b68af6644771	29	13
-ExhibitStateUsage	textualRepresentation	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	type	6eb4b68af6644771	29	13
-ExhibitStateUsage	unioningType	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	usage	5ef8c1e54453db84	29	9
-ExhibitStateUsage	variant	7bc33aca39cb9e6f	29	0
-ExhibitStateUsage	variantMembership	7bc33aca39cb9e6f	29	0
+ExhibitStateUsage	actionDefinition	1b96b3501fac76d4	29	13
+ExhibitStateUsage	aliasIds	28a5378f6313cdd2	29	0
+ExhibitStateUsage	behavior	1b96b3501fac76d4	29	13
+ExhibitStateUsage	chainingFeature	28a5378f6313cdd2	29	0
+ExhibitStateUsage	crossFeature	e352cb27eee6d987	29	0
+ExhibitStateUsage	declaredName	0698ed59cd057013	29	19
+ExhibitStateUsage	declaredShortName	e352cb27eee6d987	29	0
+ExhibitStateUsage	definition	1b96b3501fac76d4	29	13
+ExhibitStateUsage	differencingType	28a5378f6313cdd2	29	0
+ExhibitStateUsage	directedFeature	142ae6373c565acc	29	1
+ExhibitStateUsage	directedUsage	142ae6373c565acc	29	1
+ExhibitStateUsage	direction	e352cb27eee6d987	29	0
+ExhibitStateUsage	doAction	e352cb27eee6d987	29	0
+ExhibitStateUsage	documentation	28a5378f6313cdd2	29	0
+ExhibitStateUsage	elementId	1f29ef52ea38b588	29	29
+ExhibitStateUsage	endFeature	28a5378f6313cdd2	29	0
+ExhibitStateUsage	endOwningType	e352cb27eee6d987	29	0
+ExhibitStateUsage	entryAction	eee78b3bb99c8d06	29	4
+ExhibitStateUsage	eventOccurrence	a1721f4c93f1d0c8	29	10
+ExhibitStateUsage	exhibitedState	a1721f4c93f1d0c8	29	10
+ExhibitStateUsage	exitAction	e352cb27eee6d987	29	0
+ExhibitStateUsage	feature	0bdabeaa6d9c0ae7	29	9
+ExhibitStateUsage	featureMembership	529f51797ae95bca	29	9
+ExhibitStateUsage	featureTarget	0e2774b2a9803f51	29	0
+ExhibitStateUsage	featuringType	28a5378f6313cdd2	29	0
+ExhibitStateUsage	importedMembership	28a5378f6313cdd2	29	0
+ExhibitStateUsage	individualDefinition	e352cb27eee6d987	29	0
+ExhibitStateUsage	inheritedFeature	28a5378f6313cdd2	29	0
+ExhibitStateUsage	inheritedMembership	28a5378f6313cdd2	29	0
+ExhibitStateUsage	input	142ae6373c565acc	29	1
+ExhibitStateUsage	intersectingType	28a5378f6313cdd2	29	0
+ExhibitStateUsage	isAbstract	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isComposite	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isConjugated	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isConstant	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isDerived	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isEnd	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isImpliedIncluded	8a34f34399a3fc86	29	29
+ExhibitStateUsage	isIndividual	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isLibraryElement	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isOrdered	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isParallel	0a57f563ef93b9df	29	2
+ExhibitStateUsage	isPortion	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isReference	8a34f34399a3fc86	29	29
+ExhibitStateUsage	isSufficient	f4456705e86ca3e5	29	0
+ExhibitStateUsage	isUnique	8a34f34399a3fc86	29	29
+ExhibitStateUsage	isVariable	e352cb27eee6d987	29	0
+ExhibitStateUsage	isVariation	f4456705e86ca3e5	29	0
+ExhibitStateUsage	mayTimeVary	e352cb27eee6d987	29	0
+ExhibitStateUsage	member	39a2f586fc314bcd	29	12
+ExhibitStateUsage	membership	d00ce05c17c17e0c	29	12
+ExhibitStateUsage	multiplicity	e352cb27eee6d987	29	0
+ExhibitStateUsage	name	c4ac3ac6b4fca466	29	29
+ExhibitStateUsage	nestedAction	3952876db2513f07	29	8
+ExhibitStateUsage	nestedAllocation	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedAnalysisCase	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedAttribute	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedCalculation	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedCase	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedConcern	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedConnection	5b7a66722812d01c	29	4
+ExhibitStateUsage	nestedConstraint	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedEnumeration	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedFlow	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedInterface	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedItem	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedMetadata	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedOccurrence	3952876db2513f07	29	8
+ExhibitStateUsage	nestedPart	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedPort	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedReference	4e38f2dd2ece410c	29	2
+ExhibitStateUsage	nestedRendering	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedRequirement	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedState	cd23fa02a9cd4a9b	29	8
+ExhibitStateUsage	nestedTransition	d0efad5cb4496e79	29	3
+ExhibitStateUsage	nestedUsage	0bdabeaa6d9c0ae7	29	9
+ExhibitStateUsage	nestedUseCase	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedVerificationCase	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedView	28a5378f6313cdd2	29	0
+ExhibitStateUsage	nestedViewpoint	28a5378f6313cdd2	29	0
+ExhibitStateUsage	occurrenceDefinition	1b96b3501fac76d4	29	13
+ExhibitStateUsage	output	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedAnnotation	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedConjugator	e352cb27eee6d987	29	0
+ExhibitStateUsage	ownedCrossSubsetting	e352cb27eee6d987	29	0
+ExhibitStateUsage	ownedDifferencing	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedDisjoining	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedElement	8003d5c02431b330	29	14
+ExhibitStateUsage	ownedEndFeature	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedFeature	0bdabeaa6d9c0ae7	29	9
+ExhibitStateUsage	ownedFeatureChaining	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedFeatureInverting	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedFeatureMembership	529f51797ae95bca	29	9
+ExhibitStateUsage	ownedImport	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedIntersecting	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedMember	39a2f586fc314bcd	29	12
+ExhibitStateUsage	ownedMembership	d00ce05c17c17e0c	29	12
+ExhibitStateUsage	ownedRedefinition	ce40980982f380b2	29	8
+ExhibitStateUsage	ownedReferenceSubsetting	e9bd640fc58e4f8e	29	10
+ExhibitStateUsage	ownedRelationship	84eb9392d82f7732	29	29
+ExhibitStateUsage	ownedSpecialization	8cce93516a6b0da4	29	29
+ExhibitStateUsage	ownedSubsetting	5f8f5946667dfaae	29	29
+ExhibitStateUsage	ownedTypeFeaturing	28a5378f6313cdd2	29	0
+ExhibitStateUsage	ownedTyping	9c6446669d216ef2	29	6
+ExhibitStateUsage	ownedUnioning	28a5378f6313cdd2	29	0
+ExhibitStateUsage	owner	6ba03d3aebfc4edd	29	29
+ExhibitStateUsage	owningDefinition	fc6e914c87ed592c	29	14
+ExhibitStateUsage	owningFeatureMembership	9292c8bfd09ba588	29	29
+ExhibitStateUsage	owningMembership	9292c8bfd09ba588	29	29
+ExhibitStateUsage	owningNamespace	6ba03d3aebfc4edd	29	29
+ExhibitStateUsage	owningRelationship	9292c8bfd09ba588	29	29
+ExhibitStateUsage	owningType	6ba03d3aebfc4edd	29	29
+ExhibitStateUsage	owningUsage	5284771652f5cf38	29	15
+ExhibitStateUsage	parameter	142ae6373c565acc	29	1
+ExhibitStateUsage	performedAction	a1721f4c93f1d0c8	29	10
+ExhibitStateUsage	portionKind	e352cb27eee6d987	29	0
+ExhibitStateUsage	qualifiedName	525baea4552fc96f	29	29
+ExhibitStateUsage	shortName	e352cb27eee6d987	29	0
+ExhibitStateUsage	stateDefinition	1b96b3501fac76d4	29	13
+ExhibitStateUsage	textualRepresentation	28a5378f6313cdd2	29	0
+ExhibitStateUsage	type	1b96b3501fac76d4	29	13
+ExhibitStateUsage	unioningType	28a5378f6313cdd2	29	0
+ExhibitStateUsage	usage	0bdabeaa6d9c0ae7	29	9
+ExhibitStateUsage	variant	28a5378f6313cdd2	29	0
+ExhibitStateUsage	variantMembership	28a5378f6313cdd2	29	0
 Expression	aliasIds	6b5e99f8af607b18	10	0
 Expression	behavior	6b5e99f8af607b18	10	0
 Expression	chainingFeature	6b5e99f8af607b18	10	0
@@ -3285,20 +3370,20 @@ Expression	inheritedFeature	6b5e99f8af607b18	10	0
 Expression	inheritedMembership	6b5e99f8af607b18	10	0
 Expression	input	8df19487f90a47cb	10	10
 Expression	intersectingType	6b5e99f8af607b18	10	0
-Expression	isAbstract	3f0b2b0aed30b606	10	0
-Expression	isComposite	3f0b2b0aed30b606	10	0
+Expression	isAbstract	54e5a1a874a917de	10	0
+Expression	isComposite	54e5a1a874a917de	10	0
 Expression	isConjugated	54e5a1a874a917de	10	0
-Expression	isConstant	3f0b2b0aed30b606	10	0
-Expression	isDerived	3f0b2b0aed30b606	10	0
-Expression	isEnd	3f0b2b0aed30b606	10	0
+Expression	isConstant	54e5a1a874a917de	10	0
+Expression	isDerived	54e5a1a874a917de	10	0
+Expression	isEnd	54e5a1a874a917de	10	0
 Expression	isImpliedIncluded	7873bdc21f354b48	10	10
 Expression	isLibraryElement	54e5a1a874a917de	10	0
 Expression	isModelLevelEvaluable	54e5a1a874a917de	10	0
-Expression	isOrdered	3f0b2b0aed30b606	10	0
-Expression	isPortion	3f0b2b0aed30b606	10	0
-Expression	isSufficient	3f0b2b0aed30b606	10	0
-Expression	isUnique	3f0b2b0aed30b606	10	0
-Expression	isVariable	3f0b2b0aed30b606	10	0
+Expression	isOrdered	54e5a1a874a917de	10	0
+Expression	isPortion	54e5a1a874a917de	10	0
+Expression	isSufficient	54e5a1a874a917de	10	0
+Expression	isUnique	7873bdc21f354b48	10	10
+Expression	isVariable	54e5a1a874a917de	10	0
 Expression	member	7cab4e6c71232bb4	10	10
 Expression	membership	832769e902390fcc	10	10
 Expression	multiplicity	3f0b2b0aed30b606	10	0
@@ -3321,9 +3406,9 @@ Expression	ownedMember	7cab4e6c71232bb4	10	10
 Expression	ownedMembership	832769e902390fcc	10	10
 Expression	ownedRedefinition	6b5e99f8af607b18	10	0
 Expression	ownedReferenceSubsetting	3f0b2b0aed30b606	10	0
-Expression	ownedRelationship	832769e902390fcc	10	10
-Expression	ownedSpecialization	6b5e99f8af607b18	10	0
-Expression	ownedSubsetting	6b5e99f8af607b18	10	0
+Expression	ownedRelationship	45878d8dda870ab8	10	10
+Expression	ownedSpecialization	6c29ee8873e82cea	10	10
+Expression	ownedSubsetting	6c29ee8873e82cea	10	10
 Expression	ownedTypeFeaturing	6b5e99f8af607b18	10	0
 Expression	ownedTyping	6b5e99f8af607b18	10	0
 Expression	ownedUnioning	6b5e99f8af607b18	10	0
@@ -3340,370 +3425,370 @@ Expression	shortName	3f0b2b0aed30b606	10	0
 Expression	textualRepresentation	6b5e99f8af607b18	10	0
 Expression	type	6b5e99f8af607b18	10	0
 Expression	unioningType	6b5e99f8af607b18	10	0
-Feature	aliasIds	2e0ba96366134a49	3333	0
-Feature	chainingFeature	7e3822cf230f6214	3333	588
-Feature	crossFeature	7860fdb3d3713efc	3333	0
-Feature	declaredName	7860fdb3d3713efc	3333	0
-Feature	declaredShortName	7860fdb3d3713efc	3333	0
-Feature	differencingType	2e0ba96366134a49	3333	0
-Feature	directedFeature	2e0ba96366134a49	3333	0
-Feature	direction	b93601c232d94f39	3333	2708
-Feature	documentation	2e0ba96366134a49	3333	0
-Feature	elementId	0a3aa20bb1a9e6d4	3333	3333
-Feature	endFeature	2e0ba96366134a49	3333	0
-Feature	endOwningType	7860fdb3d3713efc	3333	0
-Feature	feature	2e0ba96366134a49	3333	0
-Feature	featureMembership	2e0ba96366134a49	3333	0
-Feature	featureTarget	278491fcafbf30ed	3333	588
-Feature	featuringType	2e0ba96366134a49	3333	0
-Feature	importedMembership	2e0ba96366134a49	3333	0
-Feature	inheritedFeature	2e0ba96366134a49	3333	0
-Feature	inheritedMembership	2e0ba96366134a49	3333	0
-Feature	input	2e0ba96366134a49	3333	0
-Feature	intersectingType	2e0ba96366134a49	3333	0
-Feature	isAbstract	7860fdb3d3713efc	3333	0
-Feature	isComposite	7860fdb3d3713efc	3333	0
-Feature	isConjugated	9622ca34078c90b0	3333	0
-Feature	isConstant	7860fdb3d3713efc	3333	0
-Feature	isDerived	7860fdb3d3713efc	3333	0
-Feature	isEnd	7860fdb3d3713efc	3333	0
-Feature	isImpliedIncluded	76bee21979ca3ac9	3333	3333
-Feature	isLibraryElement	a176886648250a26	3333	46
-Feature	isOrdered	7860fdb3d3713efc	3333	0
-Feature	isPortion	7860fdb3d3713efc	3333	0
-Feature	isSufficient	7860fdb3d3713efc	3333	0
-Feature	isUnique	7860fdb3d3713efc	3333	0
-Feature	isVariable	7860fdb3d3713efc	3333	0
-Feature	member	3e16e99b4b2acdd3	3333	2633
-Feature	membership	19a4b097362a0410	3333	2633
-Feature	multiplicity	7860fdb3d3713efc	3333	0
-Feature	name	ae90ead7f102609a	3333	843
-Feature	output	2e0ba96366134a49	3333	0
-Feature	ownedAnnotation	2e0ba96366134a49	3333	0
-Feature	ownedConjugator	7860fdb3d3713efc	3333	0
-Feature	ownedCrossSubsetting	7860fdb3d3713efc	3333	0
-Feature	ownedDifferencing	2e0ba96366134a49	3333	0
-Feature	ownedDisjoining	2e0ba96366134a49	3333	0
-Feature	ownedElement	3e16e99b4b2acdd3	3333	2633
-Feature	ownedEndFeature	2e0ba96366134a49	3333	0
-Feature	ownedFeature	2e0ba96366134a49	3333	0
-Feature	ownedFeatureChaining	d6a6b0046f905a48	3333	588
-Feature	ownedFeatureInverting	2e0ba96366134a49	3333	0
-Feature	ownedFeatureMembership	2e0ba96366134a49	3333	0
-Feature	ownedImport	2e0ba96366134a49	3333	0
-Feature	ownedIntersecting	2e0ba96366134a49	3333	0
-Feature	ownedMember	3e16e99b4b2acdd3	3333	2633
-Feature	ownedMembership	19a4b097362a0410	3333	2633
-Feature	ownedRedefinition	6aeb5e929f5034d1	3333	18
-Feature	ownedReferenceSubsetting	7860fdb3d3713efc	3333	0
-Feature	ownedRelationship	a564ad33d1f5609e	3333	3296
-Feature	ownedSpecialization	7c5d83fce6472600	3333	93
-Feature	ownedSubsetting	6aeb5e929f5034d1	3333	18
-Feature	ownedTypeFeaturing	2e0ba96366134a49	3333	0
-Feature	ownedTyping	3f7dcecdad0a3b78	3333	75
-Feature	ownedUnioning	2e0ba96366134a49	3333	0
-Feature	owner	80dabbaca56b761e	3333	3333
-Feature	owningFeatureMembership	3728030d82a69138	3333	2745
-Feature	owningMembership	ebf8c27b80c40459	3333	2822
-Feature	owningNamespace	5f68ecafebeeb3e4	3333	2822
-Feature	owningRelationship	ca14151fc631b6d5	3333	3333
-Feature	owningType	d6bfa895be770ff6	3333	2745
-Feature	qualifiedName	613daa99e86ab95a	3333	2
-Feature	shortName	61e4f32768359ab2	3333	2
-Feature	textualRepresentation	2e0ba96366134a49	3333	0
-Feature	type	e5a66786adb39b3c	3333	468
-Feature	unioningType	2e0ba96366134a49	3333	0
-FeatureChainExpression	aliasIds	98cec053baff32ac	438	0
-FeatureChainExpression	argument	bb79f05658d4dbf9	438	438
-FeatureChainExpression	behavior	98cec053baff32ac	438	0
-FeatureChainExpression	chainingFeature	98cec053baff32ac	438	0
-FeatureChainExpression	crossFeature	506fa127847f1052	438	0
-FeatureChainExpression	declaredName	506fa127847f1052	438	0
-FeatureChainExpression	declaredShortName	506fa127847f1052	438	0
-FeatureChainExpression	differencingType	98cec053baff32ac	438	0
-FeatureChainExpression	directedFeature	9dcce3b54350db52	438	438
-FeatureChainExpression	direction	506fa127847f1052	438	0
-FeatureChainExpression	documentation	98cec053baff32ac	438	0
-FeatureChainExpression	elementId	3a3096d23cbad974	438	438
-FeatureChainExpression	endFeature	98cec053baff32ac	438	0
-FeatureChainExpression	endOwningType	506fa127847f1052	438	0
-FeatureChainExpression	feature	9dcce3b54350db52	438	438
-FeatureChainExpression	featureMembership	ade389c4be4c7411	438	438
-FeatureChainExpression	featureTarget	693fa8b853dfd56e	438	0
-FeatureChainExpression	featuringType	98cec053baff32ac	438	0
-FeatureChainExpression	function	506fa127847f1052	438	0
-FeatureChainExpression	importedMembership	98cec053baff32ac	438	0
-FeatureChainExpression	inheritedFeature	98cec053baff32ac	438	0
-FeatureChainExpression	inheritedMembership	98cec053baff32ac	438	0
-FeatureChainExpression	input	9dcce3b54350db52	438	438
-FeatureChainExpression	instantiatedType	91845df91d964fb0	438	438
-FeatureChainExpression	intersectingType	98cec053baff32ac	438	0
-FeatureChainExpression	isAbstract	506fa127847f1052	438	0
-FeatureChainExpression	isComposite	506fa127847f1052	438	0
-FeatureChainExpression	isConjugated	40cf7e8420f74896	438	0
-FeatureChainExpression	isConstant	506fa127847f1052	438	0
-FeatureChainExpression	isDerived	506fa127847f1052	438	0
-FeatureChainExpression	isEnd	506fa127847f1052	438	0
-FeatureChainExpression	isImpliedIncluded	1d908f9623ab151c	438	438
-FeatureChainExpression	isLibraryElement	40cf7e8420f74896	438	0
-FeatureChainExpression	isModelLevelEvaluable	16661cbfcb31e671	438	71
-FeatureChainExpression	isOrdered	506fa127847f1052	438	0
-FeatureChainExpression	isPortion	506fa127847f1052	438	0
-FeatureChainExpression	isSufficient	506fa127847f1052	438	0
-FeatureChainExpression	isUnique	506fa127847f1052	438	0
-FeatureChainExpression	isVariable	506fa127847f1052	438	0
-FeatureChainExpression	member	38c2b2594d6ae0ff	438	438
-FeatureChainExpression	membership	a37e7d2717dfab70	438	438
-FeatureChainExpression	multiplicity	506fa127847f1052	438	0
-FeatureChainExpression	name	506fa127847f1052	438	0
-FeatureChainExpression	operator	45e968385fe6d298	438	438
-FeatureChainExpression	output	98cec053baff32ac	438	0
-FeatureChainExpression	ownedAnnotation	98cec053baff32ac	438	0
-FeatureChainExpression	ownedConjugator	506fa127847f1052	438	0
-FeatureChainExpression	ownedCrossSubsetting	506fa127847f1052	438	0
-FeatureChainExpression	ownedDifferencing	98cec053baff32ac	438	0
-FeatureChainExpression	ownedDisjoining	98cec053baff32ac	438	0
-FeatureChainExpression	ownedElement	e318b753f6d3db5f	438	438
-FeatureChainExpression	ownedEndFeature	98cec053baff32ac	438	0
-FeatureChainExpression	ownedFeature	9dcce3b54350db52	438	438
-FeatureChainExpression	ownedFeatureChaining	98cec053baff32ac	438	0
-FeatureChainExpression	ownedFeatureInverting	98cec053baff32ac	438	0
-FeatureChainExpression	ownedFeatureMembership	ade389c4be4c7411	438	438
-FeatureChainExpression	ownedImport	98cec053baff32ac	438	0
-FeatureChainExpression	ownedIntersecting	98cec053baff32ac	438	0
-FeatureChainExpression	ownedMember	e318b753f6d3db5f	438	438
-FeatureChainExpression	ownedMembership	a37e7d2717dfab70	438	438
-FeatureChainExpression	ownedRedefinition	98cec053baff32ac	438	0
-FeatureChainExpression	ownedReferenceSubsetting	506fa127847f1052	438	0
-FeatureChainExpression	ownedRelationship	a37e7d2717dfab70	438	438
-FeatureChainExpression	ownedSpecialization	98cec053baff32ac	438	0
-FeatureChainExpression	ownedSubsetting	98cec053baff32ac	438	0
-FeatureChainExpression	ownedTypeFeaturing	98cec053baff32ac	438	0
-FeatureChainExpression	ownedTyping	98cec053baff32ac	438	0
-FeatureChainExpression	ownedUnioning	98cec053baff32ac	438	0
-FeatureChainExpression	owner	010516549ae55fb7	438	438
-FeatureChainExpression	owningFeatureMembership	ec35b0802a2dd4a7	438	14
-FeatureChainExpression	owningMembership	7cab8c0e424a6684	438	438
-FeatureChainExpression	owningNamespace	010516549ae55fb7	438	438
-FeatureChainExpression	owningRelationship	7cab8c0e424a6684	438	438
-FeatureChainExpression	owningType	0d81de1ce3ae7ae8	438	14
-FeatureChainExpression	parameter	9dcce3b54350db52	438	438
-FeatureChainExpression	qualifiedName	506fa127847f1052	438	0
-FeatureChainExpression	result	693fa8b853dfd56e	438	0
-FeatureChainExpression	shortName	506fa127847f1052	438	0
-FeatureChainExpression	targetFeature	aeb1a0f6cc3c0cff	438	438
-FeatureChainExpression	textualRepresentation	98cec053baff32ac	438	0
-FeatureChainExpression	type	98cec053baff32ac	438	0
-FeatureChainExpression	unioningType	98cec053baff32ac	438	0
-FeatureChaining	aliasIds	03d94b4d88a72e24	1331	0
-FeatureChaining	chainingFeature	588f4d9a8997fb47	1331	1331
-FeatureChaining	declaredName	6016fc3e25b13bb3	1331	0
-FeatureChaining	declaredShortName	6016fc3e25b13bb3	1331	0
-FeatureChaining	documentation	03d94b4d88a72e24	1331	0
-FeatureChaining	elementId	8adec0159c171828	1331	1331
-FeatureChaining	featureChained	aace47465ea82b29	1331	1331
-FeatureChaining	isImplied	6f2e1ab290fc1259	1331	0
-FeatureChaining	isImpliedIncluded	7fa273852bb14a50	1331	1331
-FeatureChaining	isLibraryElement	6f2e1ab290fc1259	1331	0
-FeatureChaining	name	6016fc3e25b13bb3	1331	0
-FeatureChaining	ownedAnnotation	03d94b4d88a72e24	1331	0
-FeatureChaining	ownedElement	4646d308cfc0c362	1331	31
-FeatureChaining	ownedRelatedElement	03d94b4d88a72e24	1331	0
-FeatureChaining	ownedRelationship	c0a6995cf45133fa	1331	31
-FeatureChaining	owner	6016fc3e25b13bb3	1331	0
-FeatureChaining	owningMembership	6016fc3e25b13bb3	1331	0
-FeatureChaining	owningNamespace	6016fc3e25b13bb3	1331	0
-FeatureChaining	owningRelatedElement	aace47465ea82b29	1331	1331
-FeatureChaining	owningRelationship	6016fc3e25b13bb3	1331	0
-FeatureChaining	qualifiedName	6016fc3e25b13bb3	1331	0
-FeatureChaining	relatedElement	c4a498731d2c4a20	1331	1331
-FeatureChaining	shortName	6016fc3e25b13bb3	1331	0
-FeatureChaining	source	3317cceb0582437f	1331	1331
-FeatureChaining	target	5e87f6a115b6278d	1331	1331
-FeatureChaining	textualRepresentation	4646d308cfc0c362	1331	31
-FeatureMembership	aliasIds	00360b795a3051cc	4966	0
-FeatureMembership	declaredName	81c848f417c72bee	4966	0
-FeatureMembership	declaredShortName	81c848f417c72bee	4966	0
-FeatureMembership	documentation	00360b795a3051cc	4966	0
-FeatureMembership	elementId	31797c7c205ffe1c	4966	4966
-FeatureMembership	isImplied	41bff65fd52f06d6	4966	0
-FeatureMembership	isImpliedIncluded	1aa8bff1b702a654	4966	4966
-FeatureMembership	isLibraryElement	2000b8b038a5d1fa	4966	76
-FeatureMembership	memberElement	c9dda260344fcc1c	4966	4966
-FeatureMembership	memberElementId	38d725a374eaba0e	4966	4966
-FeatureMembership	memberName	feacd1658f16e7a0	4966	4353
-FeatureMembership	memberShortName	4b81c985b774e202	4966	17
-FeatureMembership	membershipOwningNamespace	e38ccc516b0607a9	4966	4966
-FeatureMembership	name	81c848f417c72bee	4966	0
-FeatureMembership	ownedAnnotation	00360b795a3051cc	4966	0
-FeatureMembership	ownedElement	00360b795a3051cc	4966	0
-FeatureMembership	ownedMemberElement	c9dda260344fcc1c	4966	4966
-FeatureMembership	ownedMemberElementId	38d725a374eaba0e	4966	4966
-FeatureMembership	ownedMemberFeature	c9dda260344fcc1c	4966	4966
-FeatureMembership	ownedMemberName	feacd1658f16e7a0	4966	4353
-FeatureMembership	ownedMemberShortName	3c6ed9324144d64c	4966	19
-FeatureMembership	ownedRelatedElement	da70b04f0fe04230	4966	4966
-FeatureMembership	ownedRelationship	00360b795a3051cc	4966	0
-FeatureMembership	owner	81c848f417c72bee	4966	0
-FeatureMembership	owningMembership	81c848f417c72bee	4966	0
-FeatureMembership	owningNamespace	81c848f417c72bee	4966	0
-FeatureMembership	owningRelatedElement	e38ccc516b0607a9	4966	4966
-FeatureMembership	owningRelationship	81c848f417c72bee	4966	0
-FeatureMembership	owningType	e38ccc516b0607a9	4966	4966
-FeatureMembership	qualifiedName	81c848f417c72bee	4966	0
-FeatureMembership	relatedElement	4b25bc0dd3260ff5	4966	4966
-FeatureMembership	shortName	81c848f417c72bee	4966	0
-FeatureMembership	source	1ed5bd519be71dbf	4966	4966
-FeatureMembership	target	da70b04f0fe04230	4966	4966
-FeatureMembership	textualRepresentation	00360b795a3051cc	4966	0
-FeatureMembership	visibility	6560e9fcf4ef119e	4966	4719
-FeatureReferenceExpression	aliasIds	192b663fba555fc2	1722	0
-FeatureReferenceExpression	behavior	192b663fba555fc2	1722	0
-FeatureReferenceExpression	chainingFeature	192b663fba555fc2	1722	0
-FeatureReferenceExpression	crossFeature	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	declaredName	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	declaredShortName	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	differencingType	192b663fba555fc2	1722	0
-FeatureReferenceExpression	directedFeature	37973ce2eafc430a	1722	37
-FeatureReferenceExpression	direction	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	documentation	192b663fba555fc2	1722	0
-FeatureReferenceExpression	elementId	435d55d8be101d44	1722	1722
-FeatureReferenceExpression	endFeature	192b663fba555fc2	1722	0
-FeatureReferenceExpression	endOwningType	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	feature	37973ce2eafc430a	1722	37
-FeatureReferenceExpression	featureMembership	b6d59856d9d634c3	1722	37
-FeatureReferenceExpression	featureTarget	42bb219e2edd6fe2	1722	0
-FeatureReferenceExpression	featuringType	192b663fba555fc2	1722	0
-FeatureReferenceExpression	function	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	importedMembership	192b663fba555fc2	1722	0
-FeatureReferenceExpression	inheritedFeature	192b663fba555fc2	1722	0
-FeatureReferenceExpression	inheritedMembership	192b663fba555fc2	1722	0
-FeatureReferenceExpression	input	192b663fba555fc2	1722	0
-FeatureReferenceExpression	intersectingType	192b663fba555fc2	1722	0
-FeatureReferenceExpression	isAbstract	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isComposite	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isConjugated	55577cc4a95915a0	1722	0
-FeatureReferenceExpression	isConstant	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isDerived	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isEnd	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isImpliedIncluded	c16a64ad16821262	1722	1722
-FeatureReferenceExpression	isLibraryElement	55577cc4a95915a0	1722	0
-FeatureReferenceExpression	isModelLevelEvaluable	e45718ef9b5f77d2	1722	570
-FeatureReferenceExpression	isOrdered	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isPortion	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isSufficient	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isUnique	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	isVariable	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	member	218dd2b2674f8b42	1722	1722
-FeatureReferenceExpression	membership	0abc42d4c3bdc51b	1722	1722
-FeatureReferenceExpression	multiplicity	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	name	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	output	37973ce2eafc430a	1722	37
-FeatureReferenceExpression	ownedAnnotation	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedConjugator	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	ownedCrossSubsetting	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	ownedDifferencing	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedDisjoining	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedElement	2e32c29b3add8dc4	1722	42
-FeatureReferenceExpression	ownedEndFeature	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedFeature	37973ce2eafc430a	1722	37
-FeatureReferenceExpression	ownedFeatureChaining	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedFeatureInverting	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedFeatureMembership	b6d59856d9d634c3	1722	37
-FeatureReferenceExpression	ownedImport	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedIntersecting	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedMember	2e32c29b3add8dc4	1722	42
-FeatureReferenceExpression	ownedMembership	0abc42d4c3bdc51b	1722	1722
-FeatureReferenceExpression	ownedRedefinition	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedReferenceSubsetting	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	ownedRelationship	0abc42d4c3bdc51b	1722	1722
-FeatureReferenceExpression	ownedSpecialization	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedSubsetting	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedTypeFeaturing	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedTyping	192b663fba555fc2	1722	0
-FeatureReferenceExpression	ownedUnioning	192b663fba555fc2	1722	0
-FeatureReferenceExpression	owner	e19043dfdcb5f69c	1722	1722
-FeatureReferenceExpression	owningFeatureMembership	24f412663649be37	1722	2
-FeatureReferenceExpression	owningMembership	e5be20a5906ce5d0	1722	1722
-FeatureReferenceExpression	owningNamespace	e19043dfdcb5f69c	1722	1722
-FeatureReferenceExpression	owningRelationship	e5be20a5906ce5d0	1722	1722
-FeatureReferenceExpression	owningType	1e417441717b750d	1722	2
-FeatureReferenceExpression	parameter	37973ce2eafc430a	1722	37
-FeatureReferenceExpression	qualifiedName	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	referent	85e7b4c00be174ba	1722	1685
-FeatureReferenceExpression	result	3463dc3dd02f4542	1722	37
-FeatureReferenceExpression	shortName	ca4b41d63c6a6c6c	1722	0
-FeatureReferenceExpression	textualRepresentation	192b663fba555fc2	1722	0
-FeatureReferenceExpression	type	192b663fba555fc2	1722	0
-FeatureReferenceExpression	unioningType	192b663fba555fc2	1722	0
-FeatureTyping	aliasIds	76eefbeb35b84dfc	2739	0
-FeatureTyping	declaredName	9c7606770f3ff527	2739	0
-FeatureTyping	declaredShortName	9c7606770f3ff527	2739	0
-FeatureTyping	documentation	76eefbeb35b84dfc	2739	0
-FeatureTyping	elementId	f6e83c2e0a7f55cc	2739	2739
-FeatureTyping	general	167dd08dec56c4db	2739	2739
-FeatureTyping	isImplied	19d87771ff382417	2739	62
-FeatureTyping	isImpliedIncluded	b4acbaa2b8c7cc18	2739	2739
-FeatureTyping	isLibraryElement	5e8d088e9e0e45db	2739	114
-FeatureTyping	name	9c7606770f3ff527	2739	0
-FeatureTyping	ownedAnnotation	76eefbeb35b84dfc	2739	0
-FeatureTyping	ownedElement	76eefbeb35b84dfc	2739	0
-FeatureTyping	ownedRelatedElement	76eefbeb35b84dfc	2739	0
-FeatureTyping	ownedRelationship	76eefbeb35b84dfc	2739	0
-FeatureTyping	owner	9c7606770f3ff527	2739	0
-FeatureTyping	owningFeature	789149465074186e	2739	2739
-FeatureTyping	owningMembership	9c7606770f3ff527	2739	0
-FeatureTyping	owningNamespace	9c7606770f3ff527	2739	0
-FeatureTyping	owningRelatedElement	789149465074186e	2739	2739
-FeatureTyping	owningRelationship	9c7606770f3ff527	2739	0
-FeatureTyping	owningType	789149465074186e	2739	2739
-FeatureTyping	qualifiedName	9c7606770f3ff527	2739	0
-FeatureTyping	relatedElement	7d1b2ce1bee7fbb5	2739	2739
-FeatureTyping	shortName	9c7606770f3ff527	2739	0
-FeatureTyping	source	1aa60fac6e3edc4a	2739	2739
-FeatureTyping	specific	789149465074186e	2739	2739
-FeatureTyping	target	117b013c5778b059	2739	2739
-FeatureTyping	textualRepresentation	76eefbeb35b84dfc	2739	0
-FeatureTyping	type	167dd08dec56c4db	2739	2739
-FeatureTyping	typedFeature	789149465074186e	2739	2739
-FeatureValue	aliasIds	5e28329b811d25a1	3825	0
-FeatureValue	declaredName	3b234e6df5c8b944	3825	0
-FeatureValue	declaredShortName	3b234e6df5c8b944	3825	0
-FeatureValue	documentation	5e28329b811d25a1	3825	0
-FeatureValue	elementId	3fb18c686b049520	3825	3825
-FeatureValue	featureWithValue	84c0df2219480413	3825	3825
-FeatureValue	isDefault	413b35144ffa45f2	3825	18
-FeatureValue	isImplied	7b6547276ae1cd8c	3825	0
-FeatureValue	isImpliedIncluded	10739a101a5312f9	3825	3825
-FeatureValue	isInitial	2742bb665c1ae290	3825	8
-FeatureValue	isLibraryElement	ae59f51d9f343f5e	3825	50
-FeatureValue	memberElement	6af83bfd821ea8f1	3825	3825
-FeatureValue	memberElementId	9cfa3b2933747ee6	3825	3825
-FeatureValue	memberName	3b234e6df5c8b944	3825	0
-FeatureValue	memberShortName	3b234e6df5c8b944	3825	0
-FeatureValue	membershipOwningNamespace	84c0df2219480413	3825	3825
-FeatureValue	name	3b234e6df5c8b944	3825	0
-FeatureValue	ownedAnnotation	5e28329b811d25a1	3825	0
-FeatureValue	ownedElement	5e28329b811d25a1	3825	0
-FeatureValue	ownedMemberElement	6af83bfd821ea8f1	3825	3825
-FeatureValue	ownedMemberElementId	9cfa3b2933747ee6	3825	3825
-FeatureValue	ownedMemberName	3b234e6df5c8b944	3825	0
-FeatureValue	ownedMemberShortName	3b234e6df5c8b944	3825	0
-FeatureValue	ownedRelatedElement	94eb609abf456509	3825	3825
-FeatureValue	ownedRelationship	5e28329b811d25a1	3825	0
-FeatureValue	owner	3b234e6df5c8b944	3825	0
-FeatureValue	owningMembership	3b234e6df5c8b944	3825	0
-FeatureValue	owningNamespace	3b234e6df5c8b944	3825	0
-FeatureValue	owningRelatedElement	84c0df2219480413	3825	3825
-FeatureValue	owningRelationship	3b234e6df5c8b944	3825	0
-FeatureValue	qualifiedName	3b234e6df5c8b944	3825	0
-FeatureValue	relatedElement	a10391775c8fb9c5	3825	3825
-FeatureValue	shortName	3b234e6df5c8b944	3825	0
-FeatureValue	source	a9bc0bd6c8537bfb	3825	3825
-FeatureValue	target	94eb609abf456509	3825	3825
-FeatureValue	textualRepresentation	5e28329b811d25a1	3825	0
-FeatureValue	value	6af83bfd821ea8f1	3825	3825
-FeatureValue	visibility	3b234e6df5c8b944	3825	0
+Feature	aliasIds	08fdef968309d8d9	8349	0
+Feature	chainingFeature	9ea4997f601948c7	8349	588
+Feature	crossFeature	35de15f5671ce938	8349	0
+Feature	declaredName	35de15f5671ce938	8349	0
+Feature	declaredShortName	35de15f5671ce938	8349	0
+Feature	differencingType	08fdef968309d8d9	8349	0
+Feature	directedFeature	08fdef968309d8d9	8349	0
+Feature	direction	df0c7fc3e9ea8189	8349	4380
+Feature	documentation	08fdef968309d8d9	8349	0
+Feature	elementId	add6da9c303dbb58	8349	8349
+Feature	endFeature	08fdef968309d8d9	8349	0
+Feature	endOwningType	8f46d1f1684e4494	8349	3344
+Feature	feature	08fdef968309d8d9	8349	0
+Feature	featureMembership	08fdef968309d8d9	8349	0
+Feature	featureTarget	398f28d1ef5de350	8349	588
+Feature	featuringType	08fdef968309d8d9	8349	0
+Feature	importedMembership	08fdef968309d8d9	8349	0
+Feature	inheritedFeature	08fdef968309d8d9	8349	0
+Feature	inheritedMembership	08fdef968309d8d9	8349	0
+Feature	input	08fdef968309d8d9	8349	0
+Feature	intersectingType	08fdef968309d8d9	8349	0
+Feature	isAbstract	c45fe7524429f700	8349	0
+Feature	isComposite	c45fe7524429f700	8349	0
+Feature	isConjugated	c45fe7524429f700	8349	0
+Feature	isConstant	c45fe7524429f700	8349	0
+Feature	isDerived	c45fe7524429f700	8349	0
+Feature	isEnd	59299c00d2a52bb8	8349	3344
+Feature	isImpliedIncluded	f736a01a7eb55679	8349	8349
+Feature	isLibraryElement	cfb3a58484c27076	8349	46
+Feature	isOrdered	c45fe7524429f700	8349	0
+Feature	isPortion	c45fe7524429f700	8349	0
+Feature	isSufficient	c45fe7524429f700	8349	0
+Feature	isUnique	f736a01a7eb55679	8349	8349
+Feature	isVariable	c45fe7524429f700	8349	0
+Feature	member	4aece082c55ab523	8349	2633
+Feature	membership	f446ec485cfd1b49	8349	2633
+Feature	multiplicity	35de15f5671ce938	8349	0
+Feature	name	acee6a02f53eaba4	8349	5291
+Feature	output	08fdef968309d8d9	8349	0
+Feature	ownedAnnotation	08fdef968309d8d9	8349	0
+Feature	ownedConjugator	35de15f5671ce938	8349	0
+Feature	ownedCrossSubsetting	35de15f5671ce938	8349	0
+Feature	ownedDifferencing	08fdef968309d8d9	8349	0
+Feature	ownedDisjoining	08fdef968309d8d9	8349	0
+Feature	ownedElement	4aece082c55ab523	8349	2633
+Feature	ownedEndFeature	08fdef968309d8d9	8349	0
+Feature	ownedFeature	08fdef968309d8d9	8349	0
+Feature	ownedFeatureChaining	31ade8275ebd38ef	8349	588
+Feature	ownedFeatureInverting	08fdef968309d8d9	8349	0
+Feature	ownedFeatureMembership	08fdef968309d8d9	8349	0
+Feature	ownedImport	08fdef968309d8d9	8349	0
+Feature	ownedIntersecting	08fdef968309d8d9	8349	0
+Feature	ownedMember	4aece082c55ab523	8349	2633
+Feature	ownedMembership	f446ec485cfd1b49	8349	2633
+Feature	ownedRedefinition	383f0f27ca17c9a5	8349	2199
+Feature	ownedReferenceSubsetting	b069eabb1b2485cd	8349	3344
+Feature	ownedRelationship	0c0af2bdf9ad4aca	8349	8349
+Feature	ownedSpecialization	47e12d186c93aad5	8349	7768
+Feature	ownedSubsetting	e36b0103a92f3f3a	8349	7768
+Feature	ownedTypeFeaturing	5c52592131fe07f2	8349	5016
+Feature	ownedTyping	1a701500ca00ca08	8349	75
+Feature	ownedUnioning	08fdef968309d8d9	8349	0
+Feature	owner	76c230a0ec49d56e	8349	8349
+Feature	owningFeatureMembership	e42c4a9acc68426c	8349	7761
+Feature	owningMembership	9401f0b3f6a71cf2	8349	7838
+Feature	owningNamespace	c191402160bae764	8349	7838
+Feature	owningRelationship	220c0f45bcee65b0	8349	8349
+Feature	owningType	861d6a79b819e2b6	8349	7761
+Feature	qualifiedName	35de15f5671ce938	8349	0
+Feature	shortName	35de15f5671ce938	8349	0
+Feature	textualRepresentation	08fdef968309d8d9	8349	0
+Feature	type	9eece9277cb0e50a	8349	5277
+Feature	unioningType	08fdef968309d8d9	8349	0
+FeatureChainExpression	aliasIds	514b44ff705e5c1a	438	0
+FeatureChainExpression	argument	f546fa3c466ba69b	438	438
+FeatureChainExpression	behavior	db9eaa72c8d87736	438	438
+FeatureChainExpression	chainingFeature	514b44ff705e5c1a	438	0
+FeatureChainExpression	crossFeature	5b1cd7afb3301848	438	0
+FeatureChainExpression	declaredName	5b1cd7afb3301848	438	0
+FeatureChainExpression	declaredShortName	5b1cd7afb3301848	438	0
+FeatureChainExpression	differencingType	514b44ff705e5c1a	438	0
+FeatureChainExpression	directedFeature	cea597b250675667	438	438
+FeatureChainExpression	direction	5b1cd7afb3301848	438	0
+FeatureChainExpression	documentation	514b44ff705e5c1a	438	0
+FeatureChainExpression	elementId	98ba9c961389322c	438	438
+FeatureChainExpression	endFeature	514b44ff705e5c1a	438	0
+FeatureChainExpression	endOwningType	5b1cd7afb3301848	438	0
+FeatureChainExpression	feature	cea597b250675667	438	438
+FeatureChainExpression	featureMembership	910860263a400cd8	438	438
+FeatureChainExpression	featureTarget	d83f9179e35a2eb6	438	0
+FeatureChainExpression	featuringType	514b44ff705e5c1a	438	0
+FeatureChainExpression	function	69d7690ddd4db2da	438	438
+FeatureChainExpression	importedMembership	514b44ff705e5c1a	438	0
+FeatureChainExpression	inheritedFeature	514b44ff705e5c1a	438	0
+FeatureChainExpression	inheritedMembership	514b44ff705e5c1a	438	0
+FeatureChainExpression	input	cea597b250675667	438	438
+FeatureChainExpression	instantiatedType	69d7690ddd4db2da	438	438
+FeatureChainExpression	intersectingType	514b44ff705e5c1a	438	0
+FeatureChainExpression	isAbstract	24208242697f5a94	438	0
+FeatureChainExpression	isComposite	24208242697f5a94	438	0
+FeatureChainExpression	isConjugated	24208242697f5a94	438	0
+FeatureChainExpression	isConstant	24208242697f5a94	438	0
+FeatureChainExpression	isDerived	24208242697f5a94	438	0
+FeatureChainExpression	isEnd	24208242697f5a94	438	0
+FeatureChainExpression	isImpliedIncluded	60de12ccd833dc82	438	438
+FeatureChainExpression	isLibraryElement	24208242697f5a94	438	0
+FeatureChainExpression	isModelLevelEvaluable	f9b7207e13b9f86f	438	71
+FeatureChainExpression	isOrdered	24208242697f5a94	438	0
+FeatureChainExpression	isPortion	24208242697f5a94	438	0
+FeatureChainExpression	isSufficient	24208242697f5a94	438	0
+FeatureChainExpression	isUnique	60de12ccd833dc82	438	438
+FeatureChainExpression	isVariable	24208242697f5a94	438	0
+FeatureChainExpression	member	e3dd6ef868183bfc	438	438
+FeatureChainExpression	membership	3eba885743f5672b	438	438
+FeatureChainExpression	multiplicity	5b1cd7afb3301848	438	0
+FeatureChainExpression	name	5b1cd7afb3301848	438	0
+FeatureChainExpression	operator	7a9f01fa6028af92	438	438
+FeatureChainExpression	output	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedAnnotation	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedConjugator	5b1cd7afb3301848	438	0
+FeatureChainExpression	ownedCrossSubsetting	5b1cd7afb3301848	438	0
+FeatureChainExpression	ownedDifferencing	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedDisjoining	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedElement	2e88da30248960e8	438	438
+FeatureChainExpression	ownedEndFeature	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedFeature	cea597b250675667	438	438
+FeatureChainExpression	ownedFeatureChaining	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedFeatureInverting	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedFeatureMembership	910860263a400cd8	438	438
+FeatureChainExpression	ownedImport	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedIntersecting	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedMember	2e88da30248960e8	438	438
+FeatureChainExpression	ownedMembership	3eba885743f5672b	438	438
+FeatureChainExpression	ownedRedefinition	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedReferenceSubsetting	5b1cd7afb3301848	438	0
+FeatureChainExpression	ownedRelationship	18744a75c3bd4ab2	438	438
+FeatureChainExpression	ownedSpecialization	2fee0473c8ba9ca9	438	438
+FeatureChainExpression	ownedSubsetting	937e5b806cbd1da1	438	438
+FeatureChainExpression	ownedTypeFeaturing	514b44ff705e5c1a	438	0
+FeatureChainExpression	ownedTyping	66db7a08303d9866	438	438
+FeatureChainExpression	ownedUnioning	514b44ff705e5c1a	438	0
+FeatureChainExpression	owner	c50013153d86d2e6	438	438
+FeatureChainExpression	owningFeatureMembership	f6e2e70858dedc9d	438	14
+FeatureChainExpression	owningMembership	93561e7810d67cbd	438	438
+FeatureChainExpression	owningNamespace	c50013153d86d2e6	438	438
+FeatureChainExpression	owningRelationship	93561e7810d67cbd	438	438
+FeatureChainExpression	owningType	182f14a5125f82de	438	14
+FeatureChainExpression	parameter	cea597b250675667	438	438
+FeatureChainExpression	qualifiedName	5b1cd7afb3301848	438	0
+FeatureChainExpression	result	d83f9179e35a2eb6	438	0
+FeatureChainExpression	shortName	5b1cd7afb3301848	438	0
+FeatureChainExpression	targetFeature	34de3835f0659193	438	438
+FeatureChainExpression	textualRepresentation	514b44ff705e5c1a	438	0
+FeatureChainExpression	type	db9eaa72c8d87736	438	438
+FeatureChainExpression	unioningType	514b44ff705e5c1a	438	0
+FeatureChaining	aliasIds	f63d3b34eaef41e9	1331	0
+FeatureChaining	chainingFeature	4dbd45d894e4de3d	1331	1331
+FeatureChaining	declaredName	682850a60ca7e06a	1331	0
+FeatureChaining	declaredShortName	682850a60ca7e06a	1331	0
+FeatureChaining	documentation	f63d3b34eaef41e9	1331	0
+FeatureChaining	elementId	ebec02f7aa78280c	1331	1331
+FeatureChaining	featureChained	febb910134b481ef	1331	1331
+FeatureChaining	isImplied	93e5a048c92fcd72	1331	0
+FeatureChaining	isImpliedIncluded	23312c38935afab1	1331	1331
+FeatureChaining	isLibraryElement	93e5a048c92fcd72	1331	0
+FeatureChaining	name	682850a60ca7e06a	1331	0
+FeatureChaining	ownedAnnotation	f63d3b34eaef41e9	1331	0
+FeatureChaining	ownedElement	85ef08ba7a2b54e2	1331	11
+FeatureChaining	ownedRelatedElement	f63d3b34eaef41e9	1331	0
+FeatureChaining	ownedRelationship	6ef9b7f849a1e748	1331	11
+FeatureChaining	owner	682850a60ca7e06a	1331	0
+FeatureChaining	owningMembership	682850a60ca7e06a	1331	0
+FeatureChaining	owningNamespace	682850a60ca7e06a	1331	0
+FeatureChaining	owningRelatedElement	febb910134b481ef	1331	1331
+FeatureChaining	owningRelationship	682850a60ca7e06a	1331	0
+FeatureChaining	qualifiedName	682850a60ca7e06a	1331	0
+FeatureChaining	relatedElement	dacb1acc02bb97c5	1331	1331
+FeatureChaining	shortName	682850a60ca7e06a	1331	0
+FeatureChaining	source	d43165ddc936bf37	1331	1331
+FeatureChaining	target	6ffa7d98dc452ad1	1331	1331
+FeatureChaining	textualRepresentation	85ef08ba7a2b54e2	1331	11
+FeatureMembership	aliasIds	777c3aca302f1053	4966	0
+FeatureMembership	declaredName	4f0ffbe895ec9b53	4966	0
+FeatureMembership	declaredShortName	4f0ffbe895ec9b53	4966	0
+FeatureMembership	documentation	777c3aca302f1053	4966	0
+FeatureMembership	elementId	c773081379960214	4966	4966
+FeatureMembership	isImplied	05eb0f49021bb2e9	4966	0
+FeatureMembership	isImpliedIncluded	4ac24e0e908521a7	4966	4966
+FeatureMembership	isLibraryElement	e42bd19965927e0d	4966	76
+FeatureMembership	memberElement	abe44766822424d6	4966	4966
+FeatureMembership	memberElementId	34c467be65e3bdae	4966	4966
+FeatureMembership	memberName	33aefda19b9a9520	4966	4295
+FeatureMembership	memberShortName	18c97c7a359a5167	4966	17
+FeatureMembership	membershipOwningNamespace	a4bed2c557fffbd7	4966	4966
+FeatureMembership	name	4f0ffbe895ec9b53	4966	0
+FeatureMembership	ownedAnnotation	777c3aca302f1053	4966	0
+FeatureMembership	ownedElement	777c3aca302f1053	4966	0
+FeatureMembership	ownedMemberElement	abe44766822424d6	4966	4966
+FeatureMembership	ownedMemberElementId	34c467be65e3bdae	4966	4966
+FeatureMembership	ownedMemberFeature	abe44766822424d6	4966	4966
+FeatureMembership	ownedMemberName	da05bf3248d20751	4966	4300
+FeatureMembership	ownedMemberShortName	c5cb41aad2307f88	4966	18
+FeatureMembership	ownedRelatedElement	f87f40b099b93cd4	4966	4966
+FeatureMembership	ownedRelationship	777c3aca302f1053	4966	0
+FeatureMembership	owner	4f0ffbe895ec9b53	4966	0
+FeatureMembership	owningMembership	4f0ffbe895ec9b53	4966	0
+FeatureMembership	owningNamespace	4f0ffbe895ec9b53	4966	0
+FeatureMembership	owningRelatedElement	a4bed2c557fffbd7	4966	4966
+FeatureMembership	owningRelationship	4f0ffbe895ec9b53	4966	0
+FeatureMembership	owningType	a4bed2c557fffbd7	4966	4966
+FeatureMembership	qualifiedName	4f0ffbe895ec9b53	4966	0
+FeatureMembership	relatedElement	e791b6cf85ccb6a4	4966	4966
+FeatureMembership	shortName	4f0ffbe895ec9b53	4966	0
+FeatureMembership	source	9db2d731f9455dc7	4966	4966
+FeatureMembership	target	f87f40b099b93cd4	4966	4966
+FeatureMembership	textualRepresentation	777c3aca302f1053	4966	0
+FeatureMembership	visibility	b259cb0636c38181	4966	4966
+FeatureReferenceExpression	aliasIds	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	behavior	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	chainingFeature	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	crossFeature	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	declaredName	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	declaredShortName	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	differencingType	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	directedFeature	0e929474845e94b7	1722	1709
+FeatureReferenceExpression	direction	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	documentation	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	elementId	43948c3f3dc6234c	1722	1722
+FeatureReferenceExpression	endFeature	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	endOwningType	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	feature	0e929474845e94b7	1722	1709
+FeatureReferenceExpression	featureMembership	c9b2417dcaa2a0a6	1722	1709
+FeatureReferenceExpression	featureTarget	0ca4671b1f877b98	1722	0
+FeatureReferenceExpression	featuringType	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	function	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	importedMembership	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	inheritedFeature	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	inheritedMembership	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	input	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	intersectingType	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	isAbstract	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isComposite	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isConjugated	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isConstant	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isDerived	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isEnd	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isImpliedIncluded	8210c997d3190b87	1722	1722
+FeatureReferenceExpression	isLibraryElement	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isModelLevelEvaluable	749cbebc41759523	1722	566
+FeatureReferenceExpression	isOrdered	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isPortion	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isSufficient	13027d3741b6266d	1722	0
+FeatureReferenceExpression	isUnique	8210c997d3190b87	1722	1722
+FeatureReferenceExpression	isVariable	13027d3741b6266d	1722	0
+FeatureReferenceExpression	member	1ed3e30de0804573	1722	1722
+FeatureReferenceExpression	membership	0f3ad7680556838b	1722	1722
+FeatureReferenceExpression	multiplicity	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	name	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	output	0e929474845e94b7	1722	1709
+FeatureReferenceExpression	ownedAnnotation	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedConjugator	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	ownedCrossSubsetting	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	ownedDifferencing	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedDisjoining	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedElement	98ad0b2a1c55d719	1722	1714
+FeatureReferenceExpression	ownedEndFeature	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedFeature	0e929474845e94b7	1722	1709
+FeatureReferenceExpression	ownedFeatureChaining	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedFeatureInverting	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedFeatureMembership	c9b2417dcaa2a0a6	1722	1709
+FeatureReferenceExpression	ownedImport	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedIntersecting	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedMember	98ad0b2a1c55d719	1722	1714
+FeatureReferenceExpression	ownedMembership	0f3ad7680556838b	1722	1722
+FeatureReferenceExpression	ownedRedefinition	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedReferenceSubsetting	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	ownedRelationship	f82e7276e461483c	1722	1722
+FeatureReferenceExpression	ownedSpecialization	5521fd9d34f3f762	1722	1722
+FeatureReferenceExpression	ownedSubsetting	5521fd9d34f3f762	1722	1722
+FeatureReferenceExpression	ownedTypeFeaturing	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedTyping	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	ownedUnioning	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	owner	169ff926f9638316	1722	1722
+FeatureReferenceExpression	owningFeatureMembership	2e9fd44747a0fc1a	1722	2
+FeatureReferenceExpression	owningMembership	4f195cd70f2dd69b	1722	1722
+FeatureReferenceExpression	owningNamespace	169ff926f9638316	1722	1722
+FeatureReferenceExpression	owningRelationship	4f195cd70f2dd69b	1722	1722
+FeatureReferenceExpression	owningType	27ed362282d2b2f0	1722	2
+FeatureReferenceExpression	parameter	0e929474845e94b7	1722	1709
+FeatureReferenceExpression	qualifiedName	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	referent	68410f6f4a07f2fd	1722	1685
+FeatureReferenceExpression	result	e58ca4af2c66df7a	1722	1709
+FeatureReferenceExpression	shortName	d3f703b74dc1aa4f	1722	0
+FeatureReferenceExpression	textualRepresentation	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	type	69d2f0ad7e289a43	1722	0
+FeatureReferenceExpression	unioningType	69d2f0ad7e289a43	1722	0
+FeatureTyping	aliasIds	6924c52b65f37744	3177	0
+FeatureTyping	declaredName	e8f382af7ca4a611	3177	0
+FeatureTyping	declaredShortName	e8f382af7ca4a611	3177	0
+FeatureTyping	documentation	6924c52b65f37744	3177	0
+FeatureTyping	elementId	b9f794fdba53db80	3177	3177
+FeatureTyping	general	8f727bab529de733	3177	3177
+FeatureTyping	isImplied	1c44b0166b43f087	3177	500
+FeatureTyping	isImpliedIncluded	b718f34724d39888	3177	3177
+FeatureTyping	isLibraryElement	893ae11284a49ad5	3177	114
+FeatureTyping	name	e8f382af7ca4a611	3177	0
+FeatureTyping	ownedAnnotation	6924c52b65f37744	3177	0
+FeatureTyping	ownedElement	6924c52b65f37744	3177	0
+FeatureTyping	ownedRelatedElement	6924c52b65f37744	3177	0
+FeatureTyping	ownedRelationship	6924c52b65f37744	3177	0
+FeatureTyping	owner	e8f382af7ca4a611	3177	0
+FeatureTyping	owningFeature	881447a8306245dc	3177	3177
+FeatureTyping	owningMembership	e8f382af7ca4a611	3177	0
+FeatureTyping	owningNamespace	e8f382af7ca4a611	3177	0
+FeatureTyping	owningRelatedElement	881447a8306245dc	3177	3177
+FeatureTyping	owningRelationship	e8f382af7ca4a611	3177	0
+FeatureTyping	owningType	881447a8306245dc	3177	3177
+FeatureTyping	qualifiedName	e8f382af7ca4a611	3177	0
+FeatureTyping	relatedElement	271ba7884f2bc4ab	3177	3177
+FeatureTyping	shortName	e8f382af7ca4a611	3177	0
+FeatureTyping	source	847cfbf9cc6e40f4	3177	3177
+FeatureTyping	specific	881447a8306245dc	3177	3177
+FeatureTyping	target	40b2887395176085	3177	3177
+FeatureTyping	textualRepresentation	6924c52b65f37744	3177	0
+FeatureTyping	type	8f727bab529de733	3177	3177
+FeatureTyping	typedFeature	881447a8306245dc	3177	3177
+FeatureValue	aliasIds	d560a0331166764c	3825	0
+FeatureValue	declaredName	379ddaf802139941	3825	0
+FeatureValue	declaredShortName	379ddaf802139941	3825	0
+FeatureValue	documentation	d560a0331166764c	3825	0
+FeatureValue	elementId	a3aa642b95994c74	3825	3825
+FeatureValue	featureWithValue	84ca3064c3422836	3825	3825
+FeatureValue	isDefault	3cf5ddf7178d10b5	3825	18
+FeatureValue	isImplied	45d9e10f9e52234b	3825	0
+FeatureValue	isImpliedIncluded	709964816af1aa58	3825	3825
+FeatureValue	isInitial	22fd644923adad53	3825	8
+FeatureValue	isLibraryElement	78ce8f05d2a4951d	3825	50
+FeatureValue	memberElement	aff5aa3e0a215dc5	3825	3825
+FeatureValue	memberElementId	649eefa333565d44	3825	3825
+FeatureValue	memberName	379ddaf802139941	3825	0
+FeatureValue	memberShortName	379ddaf802139941	3825	0
+FeatureValue	membershipOwningNamespace	84ca3064c3422836	3825	3825
+FeatureValue	name	379ddaf802139941	3825	0
+FeatureValue	ownedAnnotation	d560a0331166764c	3825	0
+FeatureValue	ownedElement	d560a0331166764c	3825	0
+FeatureValue	ownedMemberElement	aff5aa3e0a215dc5	3825	3825
+FeatureValue	ownedMemberElementId	649eefa333565d44	3825	3825
+FeatureValue	ownedMemberName	379ddaf802139941	3825	0
+FeatureValue	ownedMemberShortName	379ddaf802139941	3825	0
+FeatureValue	ownedRelatedElement	c97c7ce98b6f086b	3825	3825
+FeatureValue	ownedRelationship	d560a0331166764c	3825	0
+FeatureValue	owner	379ddaf802139941	3825	0
+FeatureValue	owningMembership	379ddaf802139941	3825	0
+FeatureValue	owningNamespace	379ddaf802139941	3825	0
+FeatureValue	owningRelatedElement	84ca3064c3422836	3825	3825
+FeatureValue	owningRelationship	379ddaf802139941	3825	0
+FeatureValue	qualifiedName	379ddaf802139941	3825	0
+FeatureValue	relatedElement	d90d74e79cf4f007	3825	3825
+FeatureValue	shortName	379ddaf802139941	3825	0
+FeatureValue	source	8295a79be47e339e	3825	3825
+FeatureValue	target	c97c7ce98b6f086b	3825	3825
+FeatureValue	textualRepresentation	d560a0331166764c	3825	0
+FeatureValue	value	aff5aa3e0a215dc5	3825	3825
+FeatureValue	visibility	35531b8f8ba28937	3825	3825
 FlowDefinition	action	73ed7ac011b51a56	2	0
 FlowDefinition	aliasIds	73ed7ac011b51a56	2	0
 FlowDefinition	associationEnd	e657db3a4d47d937	2	1
@@ -3725,9 +3810,9 @@ FlowDefinition	input	73ed7ac011b51a56	2	0
 FlowDefinition	intersectingType	73ed7ac011b51a56	2	0
 FlowDefinition	isAbstract	2236eed276b5a889	2	1
 FlowDefinition	isConjugated	e60a57699af4fb3c	2	0
-FlowDefinition	isImplied	5b23f978dbddce70	2	0
+FlowDefinition	isImplied	e60a57699af4fb3c	2	0
 FlowDefinition	isImpliedIncluded	49bd6578d1fdce96	2	2
-FlowDefinition	isIndividual	5b23f978dbddce70	2	0
+FlowDefinition	isIndividual	e60a57699af4fb3c	2	0
 FlowDefinition	isLibraryElement	e60a57699af4fb3c	2	0
 FlowDefinition	isSufficient	e60a57699af4fb3c	2	0
 FlowDefinition	isVariation	e60a57699af4fb3c	2	0
@@ -3756,7 +3841,7 @@ FlowDefinition	ownedFeature	0f446d3e75caf2c3	2	1
 FlowDefinition	ownedFeatureMembership	6271ff984992efc7	2	1
 FlowDefinition	ownedFlow	73ed7ac011b51a56	2	0
 FlowDefinition	ownedImport	73ed7ac011b51a56	2	0
-FlowDefinition	ownedInterface	87b1c51e2b41a670	2	1
+FlowDefinition	ownedInterface	73ed7ac011b51a56	2	0
 FlowDefinition	ownedIntersecting	73ed7ac011b51a56	2	0
 FlowDefinition	ownedItem	73ed7ac011b51a56	2	0
 FlowDefinition	ownedMember	0f446d3e75caf2c3	2	1
@@ -3806,59 +3891,59 @@ FlowEnd	crossFeature	25cd5efbce3d8323	244	0
 FlowEnd	declaredName	25cd5efbce3d8323	244	0
 FlowEnd	declaredShortName	25cd5efbce3d8323	244	0
 FlowEnd	differencingType	d33c02dbe74d73b9	244	0
-FlowEnd	directedFeature	da830443e6ef0931	244	244
+FlowEnd	directedFeature	ce8e8364e5b7afad	244	244
 FlowEnd	direction	25cd5efbce3d8323	244	0
 FlowEnd	documentation	d33c02dbe74d73b9	244	0
 FlowEnd	elementId	82837509e5aa6f90	244	244
 FlowEnd	endFeature	d33c02dbe74d73b9	244	0
 FlowEnd	endOwningType	d196619903ea3c4d	244	244
-FlowEnd	feature	da830443e6ef0931	244	244
-FlowEnd	featureMembership	82447bc3c6cdf1bd	244	244
+FlowEnd	feature	ce8e8364e5b7afad	244	244
+FlowEnd	featureMembership	bd41eed1a66f0dec	244	244
 FlowEnd	featureTarget	302c1692db0491ce	244	0
 FlowEnd	featuringType	d33c02dbe74d73b9	244	0
 FlowEnd	importedMembership	d33c02dbe74d73b9	244	0
 FlowEnd	inheritedFeature	d33c02dbe74d73b9	244	0
 FlowEnd	inheritedMembership	d33c02dbe74d73b9	244	0
-FlowEnd	input	0b90fb40e9036ae1	244	122
+FlowEnd	input	829855a8c469705f	244	122
 FlowEnd	intersectingType	d33c02dbe74d73b9	244	0
-FlowEnd	isAbstract	25cd5efbce3d8323	244	0
-FlowEnd	isComposite	25cd5efbce3d8323	244	0
+FlowEnd	isAbstract	8fab66a7f94cbb51	244	0
+FlowEnd	isComposite	8fab66a7f94cbb51	244	0
 FlowEnd	isConjugated	8fab66a7f94cbb51	244	0
-FlowEnd	isConstant	25cd5efbce3d8323	244	0
-FlowEnd	isDerived	25cd5efbce3d8323	244	0
+FlowEnd	isConstant	8fab66a7f94cbb51	244	0
+FlowEnd	isDerived	8fab66a7f94cbb51	244	0
 FlowEnd	isEnd	042f7984909630fd	244	244
 FlowEnd	isImpliedIncluded	042f7984909630fd	244	244
 FlowEnd	isLibraryElement	8fab66a7f94cbb51	244	0
-FlowEnd	isOrdered	25cd5efbce3d8323	244	0
-FlowEnd	isPortion	25cd5efbce3d8323	244	0
-FlowEnd	isSufficient	25cd5efbce3d8323	244	0
-FlowEnd	isUnique	25cd5efbce3d8323	244	0
-FlowEnd	isVariable	25cd5efbce3d8323	244	0
-FlowEnd	member	da830443e6ef0931	244	244
-FlowEnd	membership	82447bc3c6cdf1bd	244	244
+FlowEnd	isOrdered	8fab66a7f94cbb51	244	0
+FlowEnd	isPortion	8fab66a7f94cbb51	244	0
+FlowEnd	isSufficient	8fab66a7f94cbb51	244	0
+FlowEnd	isUnique	042f7984909630fd	244	244
+FlowEnd	isVariable	8fab66a7f94cbb51	244	0
+FlowEnd	member	ce8e8364e5b7afad	244	244
+FlowEnd	membership	bd41eed1a66f0dec	244	244
 FlowEnd	multiplicity	25cd5efbce3d8323	244	0
-FlowEnd	name	72066bb8dc8a0f47	244	244
-FlowEnd	output	a22e0bdee5391209	244	122
+FlowEnd	name	cec1e4fd864482e3	244	244
+FlowEnd	output	1f323098089bb307	244	122
 FlowEnd	ownedAnnotation	d33c02dbe74d73b9	244	0
 FlowEnd	ownedConjugator	25cd5efbce3d8323	244	0
 FlowEnd	ownedCrossSubsetting	25cd5efbce3d8323	244	0
 FlowEnd	ownedDifferencing	d33c02dbe74d73b9	244	0
 FlowEnd	ownedDisjoining	d33c02dbe74d73b9	244	0
-FlowEnd	ownedElement	ec7a6284ae317529	244	244
+FlowEnd	ownedElement	e085e1a5acfa1ba5	244	244
 FlowEnd	ownedEndFeature	d33c02dbe74d73b9	244	0
-FlowEnd	ownedFeature	da830443e6ef0931	244	244
+FlowEnd	ownedFeature	ce8e8364e5b7afad	244	244
 FlowEnd	ownedFeatureChaining	d33c02dbe74d73b9	244	0
 FlowEnd	ownedFeatureInverting	d33c02dbe74d73b9	244	0
-FlowEnd	ownedFeatureMembership	82447bc3c6cdf1bd	244	244
+FlowEnd	ownedFeatureMembership	bd41eed1a66f0dec	244	244
 FlowEnd	ownedImport	d33c02dbe74d73b9	244	0
 FlowEnd	ownedIntersecting	d33c02dbe74d73b9	244	0
-FlowEnd	ownedMember	da830443e6ef0931	244	244
-FlowEnd	ownedMembership	82447bc3c6cdf1bd	244	244
-FlowEnd	ownedRedefinition	d33c02dbe74d73b9	244	0
+FlowEnd	ownedMember	ce8e8364e5b7afad	244	244
+FlowEnd	ownedMembership	bd41eed1a66f0dec	244	244
+FlowEnd	ownedRedefinition	06ef8a93098c6f2e	244	244
 FlowEnd	ownedReferenceSubsetting	3db53c7a5c0712ae	244	241
-FlowEnd	ownedRelationship	54dec9590d81e07f	244	244
-FlowEnd	ownedSpecialization	993151fb47a6c0a9	244	241
-FlowEnd	ownedSubsetting	993151fb47a6c0a9	244	241
+FlowEnd	ownedRelationship	56993abd416accc0	244	244
+FlowEnd	ownedSpecialization	39abf6a0bf063195	244	244
+FlowEnd	ownedSubsetting	39abf6a0bf063195	244	244
 FlowEnd	ownedTypeFeaturing	d33c02dbe74d73b9	244	0
 FlowEnd	ownedTyping	d33c02dbe74d73b9	244	0
 FlowEnd	ownedUnioning	d33c02dbe74d73b9	244	0
@@ -3871,7 +3956,7 @@ FlowEnd	owningType	d196619903ea3c4d	244	244
 FlowEnd	qualifiedName	0b8ee48708915493	244	130
 FlowEnd	shortName	25cd5efbce3d8323	244	0
 FlowEnd	textualRepresentation	d33c02dbe74d73b9	244	0
-FlowEnd	type	ad0aec8ad828297e	244	146
+FlowEnd	type	43f6dace803e4b99	244	148
 FlowEnd	unioningType	d33c02dbe74d73b9	244	0
 FlowUsage	actionDefinition	437960690ffe330c	138	8
 FlowUsage	aliasIds	6739ccf89892f02c	138	0
@@ -3882,7 +3967,7 @@ FlowUsage	connectorEnd	42c1571e01dacb32	138	124
 FlowUsage	crossFeature	89c8c45b24c6263a	138	0
 FlowUsage	declaredName	da7d5235f935e5f3	138	65
 FlowUsage	declaredShortName	89c8c45b24c6263a	138	0
-FlowUsage	defaultFeaturingType	acc6b6fcf35b1f2e	138	109
+FlowUsage	defaultFeaturingType	57e32e1ca85c22f4	138	116
 FlowUsage	definition	437960690ffe330c	138	8
 FlowUsage	differencingType	6739ccf89892f02c	138	0
 FlowUsage	directedFeature	6739ccf89892f02c	138	0
@@ -3911,14 +3996,14 @@ FlowUsage	isConjugated	7a1270115d01d5aa	138	0
 FlowUsage	isConstant	7a1270115d01d5aa	138	0
 FlowUsage	isDerived	7a1270115d01d5aa	138	0
 FlowUsage	isEnd	7a1270115d01d5aa	138	0
-FlowUsage	isImplied	89c8c45b24c6263a	138	0
+FlowUsage	isImplied	7a1270115d01d5aa	138	0
 FlowUsage	isImpliedIncluded	f627069ebe32b304	138	138
-FlowUsage	isIndividual	89c8c45b24c6263a	138	0
+FlowUsage	isIndividual	7a1270115d01d5aa	138	0
 FlowUsage	isLibraryElement	7a1270115d01d5aa	138	0
 FlowUsage	isOrdered	7a1270115d01d5aa	138	0
-FlowUsage	isPortion	89c8c45b24c6263a	138	0
+FlowUsage	isPortion	7a1270115d01d5aa	138	0
 FlowUsage	isReference	99438362109b06d7	138	1
-FlowUsage	isSufficient	89c8c45b24c6263a	138	0
+FlowUsage	isSufficient	7a1270115d01d5aa	138	0
 FlowUsage	isUnique	f627069ebe32b304	138	138
 FlowUsage	isVariable	89c8c45b24c6263a	138	0
 FlowUsage	isVariation	7a1270115d01d5aa	138	0
@@ -3938,7 +4023,7 @@ FlowUsage	nestedConnection	a2eb4766917e87d9	138	6
 FlowUsage	nestedConstraint	6739ccf89892f02c	138	0
 FlowUsage	nestedEnumeration	6739ccf89892f02c	138	0
 FlowUsage	nestedFlow	6739ccf89892f02c	138	0
-FlowUsage	nestedInterface	69132218dd8d81a9	138	6
+FlowUsage	nestedInterface	6739ccf89892f02c	138	0
 FlowUsage	nestedItem	6739ccf89892f02c	138	0
 FlowUsage	nestedMetadata	6739ccf89892f02c	138	0
 FlowUsage	nestedOccurrence	b8861b160213ad64	138	6
@@ -3974,9 +4059,9 @@ FlowUsage	ownedMembership	6bb18ba4238467fb	138	138
 FlowUsage	ownedRedefinition	0c87338fdbb15b85	138	18
 FlowUsage	ownedReferenceSubsetting	89c8c45b24c6263a	138	0
 FlowUsage	ownedRelatedElement	6739ccf89892f02c	138	0
-FlowUsage	ownedRelationship	e20ecd2288f07b69	138	138
-FlowUsage	ownedSpecialization	4b74c9c1f1d2344c	138	138
-FlowUsage	ownedSubsetting	a16416c631d677da	138	138
+FlowUsage	ownedRelationship	603e15fbe03883f2	138	138
+FlowUsage	ownedSpecialization	c4b2820b123f8b6b	138	138
+FlowUsage	ownedSubsetting	0652ea7989ee3c3d	138	138
 FlowUsage	ownedTypeFeaturing	6739ccf89892f02c	138	0
 FlowUsage	ownedTyping	415b512cf0e3f1a6	138	8
 FlowUsage	ownedUnioning	6739ccf89892f02c	138	0
@@ -3994,15 +4079,15 @@ FlowUsage	payloadFeature	22bb18fc9945bab5	138	48
 FlowUsage	payloadType	bc3a5d0dad93b44e	138	48
 FlowUsage	portionKind	89c8c45b24c6263a	138	0
 FlowUsage	qualifiedName	07e283f4f48a7269	138	83
-FlowUsage	relatedElement	6739ccf89892f02c	138	0
-FlowUsage	relatedFeature	9cad2a98bbb1865c	138	123
+FlowUsage	relatedElement	2b7c61e951505408	138	123
+FlowUsage	relatedFeature	2b7c61e951505408	138	123
 FlowUsage	shortName	89c8c45b24c6263a	138	0
-FlowUsage	source	6739ccf89892f02c	138	0
-FlowUsage	sourceFeature	c33d72208adb8a13	138	123
-FlowUsage	sourceOutputFeature	16e567f0bc2060de	138	118
-FlowUsage	target	6739ccf89892f02c	138	0
-FlowUsage	targetFeature	284b4d7ed50074f4	138	122
-FlowUsage	targetInputFeature	5c62620893ff0261	138	118
+FlowUsage	source	02a36b251592ec04	138	122
+FlowUsage	sourceFeature	6fba96803d484f7e	138	122
+FlowUsage	sourceOutputFeature	2bf0c62e3c975e98	138	118
+FlowUsage	target	bca6aff55a6aaf18	138	123
+FlowUsage	targetFeature	bca6aff55a6aaf18	138	123
+FlowUsage	targetInputFeature	746772367fb97aef	138	118
 FlowUsage	textualRepresentation	6739ccf89892f02c	138	0
 FlowUsage	type	437960690ffe330c	138	8
 FlowUsage	unioningType	6739ccf89892f02c	138	0
@@ -4043,12 +4128,12 @@ ForLoopActionUsage	isConstant	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isDerived	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isEnd	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isImpliedIncluded	e7326f3db2eba311	3	3
-ForLoopActionUsage	isIndividual	6b10aaef4bb1be9a	3	0
+ForLoopActionUsage	isIndividual	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isLibraryElement	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isOrdered	7e3168b194ad2d22	3	0
-ForLoopActionUsage	isPortion	6b10aaef4bb1be9a	3	0
+ForLoopActionUsage	isPortion	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isReference	7e3168b194ad2d22	3	0
-ForLoopActionUsage	isSufficient	6b10aaef4bb1be9a	3	0
+ForLoopActionUsage	isSufficient	7e3168b194ad2d22	3	0
 ForLoopActionUsage	isUnique	e7326f3db2eba311	3	3
 ForLoopActionUsage	isVariable	6b10aaef4bb1be9a	3	0
 ForLoopActionUsage	isVariation	7e3168b194ad2d22	3	0
@@ -4069,7 +4154,7 @@ ForLoopActionUsage	nestedConnection	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedConstraint	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedEnumeration	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedFlow	4629922cff854cc1	3	0
-ForLoopActionUsage	nestedInterface	7efd02c3451dc694	3	3
+ForLoopActionUsage	nestedInterface	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedItem	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedMetadata	4629922cff854cc1	3	0
 ForLoopActionUsage	nestedOccurrence	be4971dde3085df4	3	3
@@ -4162,12 +4247,12 @@ ForkNode	isConstant	2bf97b4033fd3a35	6	0
 ForkNode	isDerived	2bf97b4033fd3a35	6	0
 ForkNode	isEnd	2bf97b4033fd3a35	6	0
 ForkNode	isImpliedIncluded	631f361abb2e9b03	6	6
-ForkNode	isIndividual	aada5e3e378a1fbf	6	0
+ForkNode	isIndividual	2bf97b4033fd3a35	6	0
 ForkNode	isLibraryElement	2bf97b4033fd3a35	6	0
 ForkNode	isOrdered	2bf97b4033fd3a35	6	0
-ForkNode	isPortion	aada5e3e378a1fbf	6	0
+ForkNode	isPortion	2bf97b4033fd3a35	6	0
 ForkNode	isReference	2bf97b4033fd3a35	6	0
-ForkNode	isSufficient	aada5e3e378a1fbf	6	0
+ForkNode	isSufficient	2bf97b4033fd3a35	6	0
 ForkNode	isUnique	631f361abb2e9b03	6	6
 ForkNode	isVariable	aada5e3e378a1fbf	6	0
 ForkNode	isVariation	2bf97b4033fd3a35	6	0
@@ -4187,7 +4272,7 @@ ForkNode	nestedConnection	9cf4bcb75b9f414f	6	0
 ForkNode	nestedConstraint	9cf4bcb75b9f414f	6	0
 ForkNode	nestedEnumeration	9cf4bcb75b9f414f	6	0
 ForkNode	nestedFlow	9cf4bcb75b9f414f	6	0
-ForkNode	nestedInterface	5ccb746fea7c29b2	6	1
+ForkNode	nestedInterface	9cf4bcb75b9f414f	6	0
 ForkNode	nestedItem	9cf4bcb75b9f414f	6	0
 ForkNode	nestedMetadata	9cf4bcb75b9f414f	6	0
 ForkNode	nestedOccurrence	9cf4bcb75b9f414f	6	0
@@ -4222,9 +4307,9 @@ ForkNode	ownedMember	5ccb746fea7c29b2	6	1
 ForkNode	ownedMembership	0c7a8e51f9c34c1d	6	1
 ForkNode	ownedRedefinition	9cf4bcb75b9f414f	6	0
 ForkNode	ownedReferenceSubsetting	aada5e3e378a1fbf	6	0
-ForkNode	ownedRelationship	0c7a8e51f9c34c1d	6	1
-ForkNode	ownedSpecialization	9cf4bcb75b9f414f	6	0
-ForkNode	ownedSubsetting	9cf4bcb75b9f414f	6	0
+ForkNode	ownedRelationship	ee8989e9406c158f	6	6
+ForkNode	ownedSpecialization	a59e0138126c0547	6	6
+ForkNode	ownedSubsetting	a59e0138126c0547	6	6
 ForkNode	ownedTypeFeaturing	9cf4bcb75b9f414f	6	0
 ForkNode	ownedTyping	9cf4bcb75b9f414f	6	0
 ForkNode	ownedUnioning	9cf4bcb75b9f414f	6	0
@@ -4257,7 +4342,7 @@ FramedConcernMembership	isLibraryElement	ff9aadd898cafaa4	6	0
 FramedConcernMembership	kind	047f164288eb8814	6	6
 FramedConcernMembership	memberElement	d7996c61dae29b03	6	6
 FramedConcernMembership	memberElementId	28bde858a00a36fd	6	6
-FramedConcernMembership	memberName	2d20a1b21cce4cc6	6	6
+FramedConcernMembership	memberName	abf17348c9b229e9	6	2
 FramedConcernMembership	memberShortName	7f81a799e40f0b08	6	0
 FramedConcernMembership	membershipOwningNamespace	bf2daf7bd43752f1	6	6
 FramedConcernMembership	name	7f81a799e40f0b08	6	0
@@ -4268,7 +4353,7 @@ FramedConcernMembership	ownedElement	d54ed67d945ec95a	6	0
 FramedConcernMembership	ownedMemberElement	d7996c61dae29b03	6	6
 FramedConcernMembership	ownedMemberElementId	28bde858a00a36fd	6	6
 FramedConcernMembership	ownedMemberFeature	d7996c61dae29b03	6	6
-FramedConcernMembership	ownedMemberName	2d20a1b21cce4cc6	6	6
+FramedConcernMembership	ownedMemberName	abf17348c9b229e9	6	2
 FramedConcernMembership	ownedMemberShortName	7f81a799e40f0b08	6	0
 FramedConcernMembership	ownedRelatedElement	ffe0171847f840e9	6	6
 FramedConcernMembership	ownedRelationship	d54ed67d945ec95a	6	0
@@ -4322,12 +4407,12 @@ IfActionUsage	isConstant	245045b624acc607	4	0
 IfActionUsage	isDerived	245045b624acc607	4	0
 IfActionUsage	isEnd	245045b624acc607	4	0
 IfActionUsage	isImpliedIncluded	ff56baad27eba373	4	4
-IfActionUsage	isIndividual	61a209a68fdfa1d5	4	0
+IfActionUsage	isIndividual	245045b624acc607	4	0
 IfActionUsage	isLibraryElement	245045b624acc607	4	0
 IfActionUsage	isOrdered	245045b624acc607	4	0
-IfActionUsage	isPortion	61a209a68fdfa1d5	4	0
+IfActionUsage	isPortion	245045b624acc607	4	0
 IfActionUsage	isReference	245045b624acc607	4	0
-IfActionUsage	isSufficient	61a209a68fdfa1d5	4	0
+IfActionUsage	isSufficient	245045b624acc607	4	0
 IfActionUsage	isUnique	ff56baad27eba373	4	4
 IfActionUsage	isVariable	61a209a68fdfa1d5	4	0
 IfActionUsage	isVariation	245045b624acc607	4	0
@@ -4347,7 +4432,7 @@ IfActionUsage	nestedConnection	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedConstraint	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedEnumeration	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedFlow	f08edf5fbb89c3af	4	0
-IfActionUsage	nestedInterface	7255426307f0f962	4	4
+IfActionUsage	nestedInterface	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedItem	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedMetadata	f08edf5fbb89c3af	4	0
 IfActionUsage	nestedOccurrence	2da7b3a27cff3602	4	4
@@ -4407,136 +4492,136 @@ IfActionUsage	unioningType	f08edf5fbb89c3af	4	0
 IfActionUsage	usage	c05aa7cc835ea16f	4	4
 IfActionUsage	variant	f08edf5fbb89c3af	4	0
 IfActionUsage	variantMembership	f08edf5fbb89c3af	4	0
-IncludeUseCaseUsage	actionDefinition	3e758271a694f9dc	13	7
-IncludeUseCaseUsage	actorParameter	c82d6e266d54dcf3	13	7
-IncludeUseCaseUsage	aliasIds	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	behavior	3e758271a694f9dc	13	7
-IncludeUseCaseUsage	calculationDefinition	1f8e79bd9d262ece	13	7
-IncludeUseCaseUsage	caseDefinition	1f8e79bd9d262ece	13	7
-IncludeUseCaseUsage	chainingFeature	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	crossFeature	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	declaredName	928c369701eb33b6	13	6
-IncludeUseCaseUsage	declaredShortName	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	definition	3e758271a694f9dc	13	7
-IncludeUseCaseUsage	differencingType	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	directedFeature	7d2a60c7b22dcd59	13	7
-IncludeUseCaseUsage	directedUsage	7d2a60c7b22dcd59	13	7
-IncludeUseCaseUsage	direction	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	documentation	47de40d3f0b85781	13	1
-IncludeUseCaseUsage	elementId	a440721a0e019830	13	13
-IncludeUseCaseUsage	endFeature	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	endOwningType	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	eventOccurrence	f923e57c5eb4118d	13	7
-IncludeUseCaseUsage	feature	7e10746bc13e6a9b	13	7
-IncludeUseCaseUsage	featureMembership	2a43b04f29aea7cb	13	7
-IncludeUseCaseUsage	featureTarget	53daf70a8f6476c9	13	0
-IncludeUseCaseUsage	featuringType	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	function	1f8e79bd9d262ece	13	7
-IncludeUseCaseUsage	importedMembership	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	includedUseCase	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	individualDefinition	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	inheritedFeature	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	inheritedMembership	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	input	7d2a60c7b22dcd59	13	7
-IncludeUseCaseUsage	intersectingType	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	isAbstract	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isComposite	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isConjugated	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isConstant	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isDerived	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isEnd	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isImpliedIncluded	8abd2a443fde5cd8	13	13
-IncludeUseCaseUsage	isIndividual	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	isLibraryElement	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isModelLevelEvaluable	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isOrdered	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	isPortion	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	isReference	8abd2a443fde5cd8	13	13
-IncludeUseCaseUsage	isSufficient	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	isUnique	8abd2a443fde5cd8	13	13
-IncludeUseCaseUsage	isVariable	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	isVariation	7fb527c91ec55027	13	0
-IncludeUseCaseUsage	mayTimeVary	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	member	197e9e6b454cf2b3	13	9
-IncludeUseCaseUsage	membership	a7fd15aeae31f7cc	13	9
-IncludeUseCaseUsage	multiplicity	f581ea49959aa764	13	4
-IncludeUseCaseUsage	name	a7beda9558fbd3c5	13	13
-IncludeUseCaseUsage	nestedAction	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedAllocation	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedAnalysisCase	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedAttribute	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedCalculation	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedCase	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedConcern	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedConnection	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedConstraint	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedEnumeration	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedFlow	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedInterface	17533a8a35ddd2f2	13	7
-IncludeUseCaseUsage	nestedItem	c82d6e266d54dcf3	13	7
-IncludeUseCaseUsage	nestedMetadata	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedOccurrence	c82d6e266d54dcf3	13	7
-IncludeUseCaseUsage	nestedPart	c82d6e266d54dcf3	13	7
-IncludeUseCaseUsage	nestedPort	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedReference	17533a8a35ddd2f2	13	7
-IncludeUseCaseUsage	nestedRendering	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedRequirement	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedState	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedTransition	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedUsage	7e10746bc13e6a9b	13	7
-IncludeUseCaseUsage	nestedUseCase	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedVerificationCase	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedView	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	nestedViewpoint	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	objectiveRequirement	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	occurrenceDefinition	3e758271a694f9dc	13	7
-IncludeUseCaseUsage	output	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedAnnotation	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedConjugator	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	ownedCrossSubsetting	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	ownedDifferencing	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedDisjoining	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedElement	6802b866db7ad29d	13	10
-IncludeUseCaseUsage	ownedEndFeature	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedFeature	7e10746bc13e6a9b	13	7
-IncludeUseCaseUsage	ownedFeatureChaining	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedFeatureInverting	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedFeatureMembership	2a43b04f29aea7cb	13	7
-IncludeUseCaseUsage	ownedImport	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedIntersecting	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedMember	197e9e6b454cf2b3	13	9
-IncludeUseCaseUsage	ownedMembership	a7fd15aeae31f7cc	13	9
-IncludeUseCaseUsage	ownedRedefinition	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedReferenceSubsetting	9239c0f2ce297089	13	7
-IncludeUseCaseUsage	ownedRelationship	12a95946cbd5b9f2	13	13
-IncludeUseCaseUsage	ownedSpecialization	be267379ed2f5c78	13	13
-IncludeUseCaseUsage	ownedSubsetting	775dfcc6e81f7e3e	13	13
-IncludeUseCaseUsage	ownedTypeFeaturing	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	ownedTyping	c2d61a80d5c1b198	13	3
-IncludeUseCaseUsage	ownedUnioning	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	owner	2e558a38b08e38f7	13	13
-IncludeUseCaseUsage	owningDefinition	e0e9d6f7ed70e25d	13	4
-IncludeUseCaseUsage	owningFeatureMembership	6d0c7b2ab26cae25	13	13
-IncludeUseCaseUsage	owningMembership	6d0c7b2ab26cae25	13	13
-IncludeUseCaseUsage	owningNamespace	2e558a38b08e38f7	13	13
-IncludeUseCaseUsage	owningRelationship	6d0c7b2ab26cae25	13	13
-IncludeUseCaseUsage	owningType	2e558a38b08e38f7	13	13
-IncludeUseCaseUsage	owningUsage	7c47bf376b70aecb	13	9
-IncludeUseCaseUsage	parameter	7d2a60c7b22dcd59	13	7
-IncludeUseCaseUsage	performedAction	f923e57c5eb4118d	13	7
-IncludeUseCaseUsage	portionKind	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	qualifiedName	e41447295eb719f6	13	13
-IncludeUseCaseUsage	result	53daf70a8f6476c9	13	0
-IncludeUseCaseUsage	shortName	2edc0bf6a8535831	13	0
-IncludeUseCaseUsage	subjectParameter	7dd516e4167e0470	13	7
-IncludeUseCaseUsage	textualRepresentation	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	type	3e758271a694f9dc	13	7
-IncludeUseCaseUsage	unioningType	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	usage	7e10746bc13e6a9b	13	7
-IncludeUseCaseUsage	useCaseDefinition	1f8e79bd9d262ece	13	7
-IncludeUseCaseUsage	useCaseIncluded	f923e57c5eb4118d	13	7
-IncludeUseCaseUsage	variant	8309d3eb1e1bc03c	13	0
-IncludeUseCaseUsage	variantMembership	8309d3eb1e1bc03c	13	0
+IncludeUseCaseUsage	actionDefinition	ef0a04de7e57a671	13	7
+IncludeUseCaseUsage	actorParameter	8f802e7195778a70	13	7
+IncludeUseCaseUsage	aliasIds	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	behavior	ef0a04de7e57a671	13	7
+IncludeUseCaseUsage	calculationDefinition	d708ffcf0cb924b7	13	7
+IncludeUseCaseUsage	caseDefinition	d708ffcf0cb924b7	13	7
+IncludeUseCaseUsage	chainingFeature	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	crossFeature	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	declaredName	778baa9527efc421	13	6
+IncludeUseCaseUsage	declaredShortName	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	definition	ef0a04de7e57a671	13	7
+IncludeUseCaseUsage	differencingType	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	directedFeature	447d2112da507ad6	13	7
+IncludeUseCaseUsage	directedUsage	447d2112da507ad6	13	7
+IncludeUseCaseUsage	direction	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	documentation	0f31011f18db04fe	13	1
+IncludeUseCaseUsage	elementId	da3f123ed6a727a4	13	13
+IncludeUseCaseUsage	endFeature	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	endOwningType	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	eventOccurrence	becb83f05b3c2260	13	7
+IncludeUseCaseUsage	feature	456334b6e9611818	13	7
+IncludeUseCaseUsage	featureMembership	f196709a51d15548	13	7
+IncludeUseCaseUsage	featureTarget	f64ecc07de158093	13	0
+IncludeUseCaseUsage	featuringType	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	function	d708ffcf0cb924b7	13	7
+IncludeUseCaseUsage	importedMembership	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	includedUseCase	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	individualDefinition	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	inheritedFeature	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	inheritedMembership	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	input	447d2112da507ad6	13	7
+IncludeUseCaseUsage	intersectingType	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	isAbstract	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isComposite	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isConjugated	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isConstant	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isDerived	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isEnd	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isImpliedIncluded	d6d72cb78e179381	13	13
+IncludeUseCaseUsage	isIndividual	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isLibraryElement	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isModelLevelEvaluable	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isOrdered	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isPortion	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isReference	d6d72cb78e179381	13	13
+IncludeUseCaseUsage	isSufficient	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	isUnique	d6d72cb78e179381	13	13
+IncludeUseCaseUsage	isVariable	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	isVariation	31fb14cdd0012590	13	0
+IncludeUseCaseUsage	mayTimeVary	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	member	e0d15eb66d6fa030	13	9
+IncludeUseCaseUsage	membership	6f4fd5f9d654a549	13	9
+IncludeUseCaseUsage	multiplicity	da815e47bb9f37cf	13	4
+IncludeUseCaseUsage	name	a7ae35a1e3cc049a	13	13
+IncludeUseCaseUsage	nestedAction	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedAllocation	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedAnalysisCase	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedAttribute	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedCalculation	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedCase	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedConcern	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedConnection	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedConstraint	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedEnumeration	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedFlow	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedInterface	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedItem	8f802e7195778a70	13	7
+IncludeUseCaseUsage	nestedMetadata	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedOccurrence	8f802e7195778a70	13	7
+IncludeUseCaseUsage	nestedPart	8f802e7195778a70	13	7
+IncludeUseCaseUsage	nestedPort	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedReference	dea5fad55e00806f	13	7
+IncludeUseCaseUsage	nestedRendering	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedRequirement	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedState	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedTransition	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedUsage	456334b6e9611818	13	7
+IncludeUseCaseUsage	nestedUseCase	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedVerificationCase	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedView	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	nestedViewpoint	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	objectiveRequirement	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	occurrenceDefinition	ef0a04de7e57a671	13	7
+IncludeUseCaseUsage	output	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedAnnotation	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedConjugator	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	ownedCrossSubsetting	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	ownedDifferencing	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedDisjoining	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedElement	8591cad7611b4746	13	10
+IncludeUseCaseUsage	ownedEndFeature	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedFeature	456334b6e9611818	13	7
+IncludeUseCaseUsage	ownedFeatureChaining	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedFeatureInverting	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedFeatureMembership	f196709a51d15548	13	7
+IncludeUseCaseUsage	ownedImport	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedIntersecting	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedMember	e0d15eb66d6fa030	13	9
+IncludeUseCaseUsage	ownedMembership	6f4fd5f9d654a549	13	9
+IncludeUseCaseUsage	ownedRedefinition	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedReferenceSubsetting	1df5572c885ed90f	13	7
+IncludeUseCaseUsage	ownedRelationship	2d8603000c10ec32	13	13
+IncludeUseCaseUsage	ownedSpecialization	d9031d332d6a8eb8	13	13
+IncludeUseCaseUsage	ownedSubsetting	923aa680285ab07e	13	13
+IncludeUseCaseUsage	ownedTypeFeaturing	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	ownedTyping	8a28dacbfde45f15	13	3
+IncludeUseCaseUsage	ownedUnioning	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	owner	71013e5fe09fdaf0	13	13
+IncludeUseCaseUsage	owningDefinition	c5e94af6137572c8	13	4
+IncludeUseCaseUsage	owningFeatureMembership	27a25bf8bcfa193b	13	13
+IncludeUseCaseUsage	owningMembership	27a25bf8bcfa193b	13	13
+IncludeUseCaseUsage	owningNamespace	71013e5fe09fdaf0	13	13
+IncludeUseCaseUsage	owningRelationship	27a25bf8bcfa193b	13	13
+IncludeUseCaseUsage	owningType	71013e5fe09fdaf0	13	13
+IncludeUseCaseUsage	owningUsage	bef3735e9b8250c4	13	9
+IncludeUseCaseUsage	parameter	447d2112da507ad6	13	7
+IncludeUseCaseUsage	performedAction	becb83f05b3c2260	13	7
+IncludeUseCaseUsage	portionKind	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	qualifiedName	2d8e458b46149077	13	13
+IncludeUseCaseUsage	result	f64ecc07de158093	13	0
+IncludeUseCaseUsage	shortName	13db7ff4ce57e89c	13	0
+IncludeUseCaseUsage	subjectParameter	2048ebe1652f0e3a	13	7
+IncludeUseCaseUsage	textualRepresentation	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	type	ef0a04de7e57a671	13	7
+IncludeUseCaseUsage	unioningType	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	usage	456334b6e9611818	13	7
+IncludeUseCaseUsage	useCaseDefinition	d708ffcf0cb924b7	13	7
+IncludeUseCaseUsage	useCaseIncluded	becb83f05b3c2260	13	7
+IncludeUseCaseUsage	variant	4a5c9436463e6db9	13	0
+IncludeUseCaseUsage	variantMembership	4a5c9436463e6db9	13	0
 IndexExpression	aliasIds	8d84f1a5bb420eea	35	0
 IndexExpression	argument	785c5dab7f958abd	35	35
 IndexExpression	behavior	8d84f1a5bb420eea	35	0
@@ -4562,20 +4647,20 @@ IndexExpression	inheritedMembership	8d84f1a5bb420eea	35	0
 IndexExpression	input	f00738a8b1e51522	35	35
 IndexExpression	instantiatedType	29910b2407a08669	35	35
 IndexExpression	intersectingType	8d84f1a5bb420eea	35	0
-IndexExpression	isAbstract	f6423f3a7dd34afd	35	0
-IndexExpression	isComposite	f6423f3a7dd34afd	35	0
+IndexExpression	isAbstract	76eeaea60a48e147	35	0
+IndexExpression	isComposite	76eeaea60a48e147	35	0
 IndexExpression	isConjugated	76eeaea60a48e147	35	0
-IndexExpression	isConstant	f6423f3a7dd34afd	35	0
-IndexExpression	isDerived	f6423f3a7dd34afd	35	0
-IndexExpression	isEnd	f6423f3a7dd34afd	35	0
+IndexExpression	isConstant	76eeaea60a48e147	35	0
+IndexExpression	isDerived	76eeaea60a48e147	35	0
+IndexExpression	isEnd	76eeaea60a48e147	35	0
 IndexExpression	isImpliedIncluded	6d4d08bca8d51816	35	35
 IndexExpression	isLibraryElement	76eeaea60a48e147	35	0
 IndexExpression	isModelLevelEvaluable	76eeaea60a48e147	35	0
-IndexExpression	isOrdered	f6423f3a7dd34afd	35	0
-IndexExpression	isPortion	f6423f3a7dd34afd	35	0
-IndexExpression	isSufficient	f6423f3a7dd34afd	35	0
-IndexExpression	isUnique	f6423f3a7dd34afd	35	0
-IndexExpression	isVariable	f6423f3a7dd34afd	35	0
+IndexExpression	isOrdered	76eeaea60a48e147	35	0
+IndexExpression	isPortion	76eeaea60a48e147	35	0
+IndexExpression	isSufficient	76eeaea60a48e147	35	0
+IndexExpression	isUnique	6d4d08bca8d51816	35	35
+IndexExpression	isVariable	76eeaea60a48e147	35	0
 IndexExpression	member	f00738a8b1e51522	35	35
 IndexExpression	membership	affa8a4e0578eb49	35	35
 IndexExpression	multiplicity	f6423f3a7dd34afd	35	0
@@ -4599,9 +4684,9 @@ IndexExpression	ownedMember	f00738a8b1e51522	35	35
 IndexExpression	ownedMembership	affa8a4e0578eb49	35	35
 IndexExpression	ownedRedefinition	8d84f1a5bb420eea	35	0
 IndexExpression	ownedReferenceSubsetting	f6423f3a7dd34afd	35	0
-IndexExpression	ownedRelationship	affa8a4e0578eb49	35	35
-IndexExpression	ownedSpecialization	8d84f1a5bb420eea	35	0
-IndexExpression	ownedSubsetting	8d84f1a5bb420eea	35	0
+IndexExpression	ownedRelationship	f4ef655c3a49ea51	35	35
+IndexExpression	ownedSpecialization	f4fbc08d05a50932	35	35
+IndexExpression	ownedSubsetting	f4fbc08d05a50932	35	35
 IndexExpression	ownedTypeFeaturing	8d84f1a5bb420eea	35	0
 IndexExpression	ownedTyping	8d84f1a5bb420eea	35	0
 IndexExpression	ownedUnioning	8d84f1a5bb420eea	35	0
@@ -4639,9 +4724,9 @@ InterfaceDefinition	interfaceEnd	fe274ce111df54dd	17	17
 InterfaceDefinition	intersectingType	cdd316f60d465388	17	0
 InterfaceDefinition	isAbstract	b93f9d6bd757a4f7	17	0
 InterfaceDefinition	isConjugated	b93f9d6bd757a4f7	17	0
-InterfaceDefinition	isImplied	0fc8f25e5dc93029	17	0
+InterfaceDefinition	isImplied	b93f9d6bd757a4f7	17	0
 InterfaceDefinition	isImpliedIncluded	07e3af908712af7c	17	17
-InterfaceDefinition	isIndividual	0fc8f25e5dc93029	17	0
+InterfaceDefinition	isIndividual	b93f9d6bd757a4f7	17	0
 InterfaceDefinition	isLibraryElement	b93f9d6bd757a4f7	17	0
 InterfaceDefinition	isSufficient	07e3af908712af7c	17	17
 InterfaceDefinition	isVariation	b93f9d6bd757a4f7	17	0
@@ -4668,9 +4753,9 @@ InterfaceDefinition	ownedEndFeature	fe274ce111df54dd	17	17
 InterfaceDefinition	ownedEnumeration	cdd316f60d465388	17	0
 InterfaceDefinition	ownedFeature	9107a47da6fe9c9e	17	17
 InterfaceDefinition	ownedFeatureMembership	157e8e4cb1155bfb	17	17
-InterfaceDefinition	ownedFlow	cdd316f60d465388	17	0
+InterfaceDefinition	ownedFlow	6464e2abe56e1877	17	4
 InterfaceDefinition	ownedImport	cdd316f60d465388	17	0
-InterfaceDefinition	ownedInterface	d4d6b4d9eef20514	17	1
+InterfaceDefinition	ownedInterface	20dce6b015ca7812	17	1
 InterfaceDefinition	ownedIntersecting	cdd316f60d465388	17	0
 InterfaceDefinition	ownedItem	542ed0e9b6b61ebf	17	3
 InterfaceDefinition	ownedMember	b0e3e34922aa7509	17	17
@@ -4681,12 +4766,12 @@ InterfaceDefinition	ownedPart	542ed0e9b6b61ebf	17	3
 InterfaceDefinition	ownedPort	fe274ce111df54dd	17	17
 InterfaceDefinition	ownedReference	d4d6b4d9eef20514	17	1
 InterfaceDefinition	ownedRelatedElement	cdd316f60d465388	17	0
-InterfaceDefinition	ownedRelationship	bec165e008bfd124	17	17
+InterfaceDefinition	ownedRelationship	10b298355c9ff586	17	17
 InterfaceDefinition	ownedRendering	cdd316f60d465388	17	0
 InterfaceDefinition	ownedRequirement	cdd316f60d465388	17	0
-InterfaceDefinition	ownedSpecialization	195d2872265ee10f	17	17
+InterfaceDefinition	ownedSpecialization	1cf5b103dc119ded	17	17
 InterfaceDefinition	ownedState	cdd316f60d465388	17	0
-InterfaceDefinition	ownedSubclassification	195d2872265ee10f	17	17
+InterfaceDefinition	ownedSubclassification	1cf5b103dc119ded	17	17
 InterfaceDefinition	ownedTransition	cdd316f60d465388	17	0
 InterfaceDefinition	ownedUnioning	cdd316f60d465388	17	0
 InterfaceDefinition	ownedUsage	9107a47da6fe9c9e	17	17
@@ -4720,7 +4805,7 @@ InterfaceUsage	connectorEnd	e258a3d69e834776	37	37
 InterfaceUsage	crossFeature	3b5455fa8be77898	37	0
 InterfaceUsage	declaredName	6ad2558b8344896e	37	27
 InterfaceUsage	declaredShortName	3b5455fa8be77898	37	0
-InterfaceUsage	defaultFeaturingType	e49ab3d55b3abc62	37	26
+InterfaceUsage	defaultFeaturingType	4f0e8f864c91b338	37	26
 InterfaceUsage	definition	6cf65744fc9a1dd2	37	28
 InterfaceUsage	differencingType	be44f1f924740e21	37	0
 InterfaceUsage	directedFeature	be44f1f924740e21	37	0
@@ -4730,8 +4815,8 @@ InterfaceUsage	documentation	be44f1f924740e21	37	0
 InterfaceUsage	elementId	9cbe5c8a2f6b177c	37	37
 InterfaceUsage	endFeature	e258a3d69e834776	37	37
 InterfaceUsage	endOwningType	3b5455fa8be77898	37	0
-InterfaceUsage	feature	243909b86f859720	37	37
-InterfaceUsage	featureMembership	d250b7b74faa7e4d	37	37
+InterfaceUsage	feature	2296d012b6fca06e	37	37
+InterfaceUsage	featureMembership	52010745ddb4342c	37	37
 InterfaceUsage	featureTarget	49fbe7de47ac48db	37	0
 InterfaceUsage	featuringType	be44f1f924740e21	37	0
 InterfaceUsage	importedMembership	be44f1f924740e21	37	0
@@ -4747,24 +4832,24 @@ InterfaceUsage	isConjugated	be36ba913f9e1718	37	0
 InterfaceUsage	isConstant	be36ba913f9e1718	37	0
 InterfaceUsage	isDerived	be36ba913f9e1718	37	0
 InterfaceUsage	isEnd	be36ba913f9e1718	37	0
-InterfaceUsage	isImplied	3b5455fa8be77898	37	0
+InterfaceUsage	isImplied	be36ba913f9e1718	37	0
 InterfaceUsage	isImpliedIncluded	6a94c47cb64977b9	37	37
-InterfaceUsage	isIndividual	3b5455fa8be77898	37	0
+InterfaceUsage	isIndividual	be36ba913f9e1718	37	0
 InterfaceUsage	isLibraryElement	be36ba913f9e1718	37	0
 InterfaceUsage	isOrdered	be36ba913f9e1718	37	0
-InterfaceUsage	isPortion	3b5455fa8be77898	37	0
+InterfaceUsage	isPortion	be36ba913f9e1718	37	0
 InterfaceUsage	isReference	e71f94c5c2d73b42	37	10
-InterfaceUsage	isSufficient	3b5455fa8be77898	37	0
+InterfaceUsage	isSufficient	be36ba913f9e1718	37	0
 InterfaceUsage	isUnique	6a94c47cb64977b9	37	37
 InterfaceUsage	isVariable	3b5455fa8be77898	37	0
 InterfaceUsage	isVariation	be36ba913f9e1718	37	0
 InterfaceUsage	itemDefinition	6cf65744fc9a1dd2	37	28
 InterfaceUsage	mayTimeVary	3b5455fa8be77898	37	0
-InterfaceUsage	member	00301aa49aeedc08	37	37
-InterfaceUsage	membership	d6b48f4d440be473	37	37
+InterfaceUsage	member	fe8de0fee265e556	37	37
+InterfaceUsage	membership	5664dedbd2159a52	37	37
 InterfaceUsage	multiplicity	97a6dec603fdfda0	37	1
 InterfaceUsage	name	6ad2558b8344896e	37	27
-InterfaceUsage	nestedAction	57c3e14b52c381c8	37	8
+InterfaceUsage	nestedAction	9224f19583dde0ba	37	8
 InterfaceUsage	nestedAllocation	be44f1f924740e21	37	0
 InterfaceUsage	nestedAnalysisCase	be44f1f924740e21	37	0
 InterfaceUsage	nestedAttribute	20af68e84d145844	37	3
@@ -4774,11 +4859,11 @@ InterfaceUsage	nestedConcern	be44f1f924740e21	37	0
 InterfaceUsage	nestedConnection	b54445d8c5458681	37	9
 InterfaceUsage	nestedConstraint	be44f1f924740e21	37	0
 InterfaceUsage	nestedEnumeration	be44f1f924740e21	37	0
-InterfaceUsage	nestedFlow	be44f1f924740e21	37	0
-InterfaceUsage	nestedInterface	b83fff065e20a550	37	1
+InterfaceUsage	nestedFlow	e43fef9afaaca6fe	37	7
+InterfaceUsage	nestedInterface	28df52912bcc4422	37	2
 InterfaceUsage	nestedItem	28df52912bcc4422	37	2
 InterfaceUsage	nestedMetadata	be44f1f924740e21	37	0
-InterfaceUsage	nestedOccurrence	2446ff678cde6686	37	37
+InterfaceUsage	nestedOccurrence	22a4c5c1d4556fd4	37	37
 InterfaceUsage	nestedPart	28df52912bcc4422	37	2
 InterfaceUsage	nestedPort	e258a3d69e834776	37	37
 InterfaceUsage	nestedReference	b83fff065e20a550	37	1
@@ -4786,7 +4871,7 @@ InterfaceUsage	nestedRendering	be44f1f924740e21	37	0
 InterfaceUsage	nestedRequirement	be44f1f924740e21	37	0
 InterfaceUsage	nestedState	be44f1f924740e21	37	0
 InterfaceUsage	nestedTransition	be44f1f924740e21	37	0
-InterfaceUsage	nestedUsage	243909b86f859720	37	37
+InterfaceUsage	nestedUsage	2296d012b6fca06e	37	37
 InterfaceUsage	nestedUseCase	be44f1f924740e21	37	0
 InterfaceUsage	nestedVerificationCase	be44f1f924740e21	37	0
 InterfaceUsage	nestedView	be44f1f924740e21	37	0
@@ -4798,22 +4883,22 @@ InterfaceUsage	ownedConjugator	3b5455fa8be77898	37	0
 InterfaceUsage	ownedCrossSubsetting	3b5455fa8be77898	37	0
 InterfaceUsage	ownedDifferencing	be44f1f924740e21	37	0
 InterfaceUsage	ownedDisjoining	be44f1f924740e21	37	0
-InterfaceUsage	ownedElement	00301aa49aeedc08	37	37
+InterfaceUsage	ownedElement	fe8de0fee265e556	37	37
 InterfaceUsage	ownedEndFeature	e258a3d69e834776	37	37
-InterfaceUsage	ownedFeature	243909b86f859720	37	37
+InterfaceUsage	ownedFeature	2296d012b6fca06e	37	37
 InterfaceUsage	ownedFeatureChaining	be44f1f924740e21	37	0
 InterfaceUsage	ownedFeatureInverting	be44f1f924740e21	37	0
-InterfaceUsage	ownedFeatureMembership	d250b7b74faa7e4d	37	37
+InterfaceUsage	ownedFeatureMembership	52010745ddb4342c	37	37
 InterfaceUsage	ownedImport	be44f1f924740e21	37	0
 InterfaceUsage	ownedIntersecting	be44f1f924740e21	37	0
-InterfaceUsage	ownedMember	00301aa49aeedc08	37	37
-InterfaceUsage	ownedMembership	d6b48f4d440be473	37	37
+InterfaceUsage	ownedMember	fe8de0fee265e556	37	37
+InterfaceUsage	ownedMembership	5664dedbd2159a52	37	37
 InterfaceUsage	ownedRedefinition	be44f1f924740e21	37	0
 InterfaceUsage	ownedReferenceSubsetting	3b5455fa8be77898	37	0
 InterfaceUsage	ownedRelatedElement	be44f1f924740e21	37	0
-InterfaceUsage	ownedRelationship	a3a8d11c7b20150c	37	37
-InterfaceUsage	ownedSpecialization	11bf8f4de52ad67a	37	37
-InterfaceUsage	ownedSubsetting	a4c633c56c9805e0	37	37
+InterfaceUsage	ownedRelationship	74b5d3ecb26e8347	37	37
+InterfaceUsage	ownedSpecialization	f1c92826897b0e7a	37	37
+InterfaceUsage	ownedSubsetting	ad9613865034bc10	37	37
 InterfaceUsage	ownedTypeFeaturing	be44f1f924740e21	37	0
 InterfaceUsage	ownedTyping	c97c3499e97bb3bd	37	24
 InterfaceUsage	ownedUnioning	be44f1f924740e21	37	0
@@ -4829,17 +4914,17 @@ InterfaceUsage	owningUsage	340b3221cf78abdd	37	25
 InterfaceUsage	partDefinition	6cf65744fc9a1dd2	37	28
 InterfaceUsage	portionKind	3b5455fa8be77898	37	0
 InterfaceUsage	qualifiedName	050bcfedd8d88886	37	27
-InterfaceUsage	relatedElement	be44f1f924740e21	37	0
+InterfaceUsage	relatedElement	4e2596684b4146dd	37	37
 InterfaceUsage	relatedFeature	4e2596684b4146dd	37	37
 InterfaceUsage	shortName	3b5455fa8be77898	37	0
-InterfaceUsage	source	be44f1f924740e21	37	0
+InterfaceUsage	source	63af4dd35536ec33	37	37
 InterfaceUsage	sourceFeature	499e96ad0266e043	37	37
-InterfaceUsage	target	be44f1f924740e21	37	0
+InterfaceUsage	target	ed197c85ff3f9fbf	37	37
 InterfaceUsage	targetFeature	ed197c85ff3f9fbf	37	37
 InterfaceUsage	textualRepresentation	be44f1f924740e21	37	0
 InterfaceUsage	type	6cf65744fc9a1dd2	37	28
 InterfaceUsage	unioningType	be44f1f924740e21	37	0
-InterfaceUsage	usage	243909b86f859720	37	37
+InterfaceUsage	usage	2296d012b6fca06e	37	37
 InterfaceUsage	variant	be44f1f924740e21	37	0
 InterfaceUsage	variantMembership	be44f1f924740e21	37	0
 InvocationExpression	aliasIds	d09c16696a9ac033	91	0
@@ -4867,20 +4952,20 @@ InvocationExpression	inheritedMembership	d09c16696a9ac033	91	0
 InvocationExpression	input	9816015eb00a7763	91	91
 InvocationExpression	instantiatedType	c0b11b2c2dc6116e	91	91
 InvocationExpression	intersectingType	d09c16696a9ac033	91	0
-InvocationExpression	isAbstract	34c14dcbd1fd3948	91	0
-InvocationExpression	isComposite	34c14dcbd1fd3948	91	0
+InvocationExpression	isAbstract	d5beed57138bbcac	91	0
+InvocationExpression	isComposite	d5beed57138bbcac	91	0
 InvocationExpression	isConjugated	d5beed57138bbcac	91	0
-InvocationExpression	isConstant	34c14dcbd1fd3948	91	0
-InvocationExpression	isDerived	34c14dcbd1fd3948	91	0
-InvocationExpression	isEnd	34c14dcbd1fd3948	91	0
+InvocationExpression	isConstant	d5beed57138bbcac	91	0
+InvocationExpression	isDerived	d5beed57138bbcac	91	0
+InvocationExpression	isEnd	d5beed57138bbcac	91	0
 InvocationExpression	isImpliedIncluded	92f3314f864a3953	91	91
 InvocationExpression	isLibraryElement	d5beed57138bbcac	91	0
 InvocationExpression	isModelLevelEvaluable	d5beed57138bbcac	91	0
-InvocationExpression	isOrdered	34c14dcbd1fd3948	91	0
-InvocationExpression	isPortion	34c14dcbd1fd3948	91	0
-InvocationExpression	isSufficient	34c14dcbd1fd3948	91	0
-InvocationExpression	isUnique	34c14dcbd1fd3948	91	0
-InvocationExpression	isVariable	34c14dcbd1fd3948	91	0
+InvocationExpression	isOrdered	d5beed57138bbcac	91	0
+InvocationExpression	isPortion	d5beed57138bbcac	91	0
+InvocationExpression	isSufficient	d5beed57138bbcac	91	0
+InvocationExpression	isUnique	92f3314f864a3953	91	91
+InvocationExpression	isVariable	d5beed57138bbcac	91	0
 InvocationExpression	member	0aa8570be68c2e74	91	91
 InvocationExpression	membership	935f4b6c643b35ca	91	91
 InvocationExpression	multiplicity	34c14dcbd1fd3948	91	0
@@ -4903,9 +4988,9 @@ InvocationExpression	ownedMember	bec99a9adc1b4656	91	91
 InvocationExpression	ownedMembership	935f4b6c643b35ca	91	91
 InvocationExpression	ownedRedefinition	d09c16696a9ac033	91	0
 InvocationExpression	ownedReferenceSubsetting	34c14dcbd1fd3948	91	0
-InvocationExpression	ownedRelationship	935f4b6c643b35ca	91	91
-InvocationExpression	ownedSpecialization	d09c16696a9ac033	91	0
-InvocationExpression	ownedSubsetting	d09c16696a9ac033	91	0
+InvocationExpression	ownedRelationship	82c57efd1661d540	91	91
+InvocationExpression	ownedSpecialization	dcb6d621f9f1ef69	91	91
+InvocationExpression	ownedSubsetting	dcb6d621f9f1ef69	91	91
 InvocationExpression	ownedTypeFeaturing	d09c16696a9ac033	91	0
 InvocationExpression	ownedTyping	d09c16696a9ac033	91	0
 InvocationExpression	ownedUnioning	d09c16696a9ac033	91	0
@@ -4941,7 +5026,7 @@ ItemDefinition	intersectingType	1a63a02d78eb1205	84	0
 ItemDefinition	isAbstract	620b68edc0d3b402	84	1
 ItemDefinition	isConjugated	dcb5c65d4252c06d	84	0
 ItemDefinition	isImpliedIncluded	a4c72d5d1d11fa79	84	84
-ItemDefinition	isIndividual	469d72fec831effb	84	6
+ItemDefinition	isIndividual	f825e11917dfcf6b	84	6
 ItemDefinition	isLibraryElement	f7373fe65668a2df	84	2
 ItemDefinition	isSufficient	dcb5c65d4252c06d	84	0
 ItemDefinition	isVariation	dcb5c65d4252c06d	84	0
@@ -4970,7 +5055,7 @@ ItemDefinition	ownedFeature	f1e71cf28cb9b00d	84	31
 ItemDefinition	ownedFeatureMembership	8661fe1ac80c73c7	84	31
 ItemDefinition	ownedFlow	1a63a02d78eb1205	84	0
 ItemDefinition	ownedImport	1a63a02d78eb1205	84	0
-ItemDefinition	ownedInterface	c06d7633bad641a7	84	8
+ItemDefinition	ownedInterface	1a63a02d78eb1205	84	0
 ItemDefinition	ownedIntersecting	1a63a02d78eb1205	84	0
 ItemDefinition	ownedItem	aa05bd6ca224473c	84	13
 ItemDefinition	ownedMember	61785f08d7e461a6	84	32
@@ -4980,12 +5065,12 @@ ItemDefinition	ownedOccurrence	747c2e4758cdaaa9	84	17
 ItemDefinition	ownedPart	181598126e47a3d6	84	9
 ItemDefinition	ownedPort	1a63a02d78eb1205	84	0
 ItemDefinition	ownedReference	c06d7633bad641a7	84	8
-ItemDefinition	ownedRelationship	c4bf27b5d48d064a	84	84
+ItemDefinition	ownedRelationship	40ab092dce016af9	84	84
 ItemDefinition	ownedRendering	1a63a02d78eb1205	84	0
 ItemDefinition	ownedRequirement	1a63a02d78eb1205	84	0
-ItemDefinition	ownedSpecialization	cfb1b562b85ee292	84	84
+ItemDefinition	ownedSpecialization	d0d3ae81a17c1795	84	84
 ItemDefinition	ownedState	1a63a02d78eb1205	84	0
-ItemDefinition	ownedSubclassification	cfb1b562b85ee292	84	84
+ItemDefinition	ownedSubclassification	d0d3ae81a17c1795	84	84
 ItemDefinition	ownedTransition	1a63a02d78eb1205	84	0
 ItemDefinition	ownedUnioning	1a63a02d78eb1205	84	0
 ItemDefinition	ownedUsage	f1e71cf28cb9b00d	84	31
@@ -5009,7 +5094,7 @@ ItemUsage	chainingFeature	c416504ade11b787	190	0
 ItemUsage	crossFeature	f527f61415a911eb	190	2
 ItemUsage	declaredName	3dd045aa16560b6e	190	153
 ItemUsage	declaredShortName	9e1d6a1b166fcab7	190	0
-ItemUsage	definition	19253040d2445f61	190	146
+ItemUsage	definition	f3ab64006ca71c71	190	182
 ItemUsage	differencingType	c416504ade11b787	190	0
 ItemUsage	directedFeature	c416504ade11b787	190	0
 ItemUsage	directedUsage	c416504ade11b787	190	0
@@ -5035,21 +5120,21 @@ ItemUsage	isConstant	f6cd9320a3aaae0c	190	19
 ItemUsage	isDerived	f011248f589614ad	190	0
 ItemUsage	isEnd	f6cd9320a3aaae0c	190	19
 ItemUsage	isImpliedIncluded	d187f95f3fceb6d3	190	190
-ItemUsage	isIndividual	4d4df075aabf88af	190	4
+ItemUsage	isIndividual	395fed8c1558fb31	190	4
 ItemUsage	isLibraryElement	9388d1f79c50f197	190	2
 ItemUsage	isOrdered	f011248f589614ad	190	0
-ItemUsage	isPortion	9e1d6a1b166fcab7	190	0
+ItemUsage	isPortion	f011248f589614ad	190	0
 ItemUsage	isReference	3dd74fcf882b8c1f	190	138
-ItemUsage	isSufficient	9e1d6a1b166fcab7	190	0
+ItemUsage	isSufficient	f011248f589614ad	190	0
 ItemUsage	isUnique	2e104bf6fc13d9e9	190	188
 ItemUsage	isVariable	7fbe2209ea5f5dcc	190	19
 ItemUsage	isVariation	f011248f589614ad	190	0
-ItemUsage	itemDefinition	1d96a02a0e2b3204	190	143
+ItemUsage	itemDefinition	f81cd3e9a88def14	190	179
 ItemUsage	mayTimeVary	7fbe2209ea5f5dcc	190	19
 ItemUsage	member	9a4db4ce0c44e102	190	82
 ItemUsage	membership	e45e190600fb6d48	190	82
 ItemUsage	multiplicity	9fab231a5f836be1	190	39
-ItemUsage	name	0ab0b3c341dea380	190	185
+ItemUsage	name	9f8fa4c481c5bca9	190	189
 ItemUsage	nestedAction	c416504ade11b787	190	0
 ItemUsage	nestedAllocation	c416504ade11b787	190	0
 ItemUsage	nestedAnalysisCase	c416504ade11b787	190	0
@@ -5061,7 +5146,7 @@ ItemUsage	nestedConnection	c416504ade11b787	190	0
 ItemUsage	nestedConstraint	c416504ade11b787	190	0
 ItemUsage	nestedEnumeration	c416504ade11b787	190	0
 ItemUsage	nestedFlow	c416504ade11b787	190	0
-ItemUsage	nestedInterface	41bb748f726a8b18	190	16
+ItemUsage	nestedInterface	c416504ade11b787	190	0
 ItemUsage	nestedItem	23c7573babf4d30b	190	7
 ItemUsage	nestedMetadata	c416504ade11b787	190	0
 ItemUsage	nestedOccurrence	23c7573babf4d30b	190	7
@@ -5077,7 +5162,7 @@ ItemUsage	nestedUseCase	c416504ade11b787	190	0
 ItemUsage	nestedVerificationCase	c416504ade11b787	190	0
 ItemUsage	nestedView	c416504ade11b787	190	0
 ItemUsage	nestedViewpoint	c416504ade11b787	190	0
-ItemUsage	occurrenceDefinition	1c07486f49b99efe	190	146
+ItemUsage	occurrenceDefinition	f68d7c2ee41c5c0e	190	182
 ItemUsage	output	c416504ade11b787	190	0
 ItemUsage	ownedAnnotation	c416504ade11b787	190	0
 ItemUsage	ownedConjugator	9e1d6a1b166fcab7	190	0
@@ -5094,11 +5179,11 @@ ItemUsage	ownedImport	c416504ade11b787	190	0
 ItemUsage	ownedIntersecting	c416504ade11b787	190	0
 ItemUsage	ownedMember	9a4db4ce0c44e102	190	82
 ItemUsage	ownedMembership	e45e190600fb6d48	190	82
-ItemUsage	ownedRedefinition	5ea067a3d7f38a12	190	35
+ItemUsage	ownedRedefinition	b628ad89bcad7717	190	84
 ItemUsage	ownedReferenceSubsetting	9e1d6a1b166fcab7	190	0
-ItemUsage	ownedRelationship	a5bac30c81105472	190	190
-ItemUsage	ownedSpecialization	82ebc6414e95f54d	190	190
-ItemUsage	ownedSubsetting	59ae077728f26b43	190	190
+ItemUsage	ownedRelationship	d4589137b862987b	190	190
+ItemUsage	ownedSpecialization	ade4666b7bf9f23e	190	190
+ItemUsage	ownedSubsetting	f8192747519a5242	190	190
 ItemUsage	ownedTypeFeaturing	c416504ade11b787	190	0
 ItemUsage	ownedTyping	d0a7ad8834cfb597	190	126
 ItemUsage	ownedUnioning	c416504ade11b787	190	0
@@ -5111,10 +5196,10 @@ ItemUsage	owningRelationship	d0cbc82f8d33e1f2	190	190
 ItemUsage	owningType	8bb685480d69b535	190	184
 ItemUsage	owningUsage	98c04cc8df362590	190	98
 ItemUsage	portionKind	3d121cf96d9d8cb7	190	1
-ItemUsage	qualifiedName	0e7ce0219d07b077	190	180
+ItemUsage	qualifiedName	67175bda9949c023	190	184
 ItemUsage	shortName	9e1d6a1b166fcab7	190	0
 ItemUsage	textualRepresentation	c416504ade11b787	190	0
-ItemUsage	type	19253040d2445f61	190	146
+ItemUsage	type	f3ab64006ca71c71	190	182
 ItemUsage	unioningType	c416504ade11b787	190	0
 ItemUsage	usage	ed4d9cc3edc3737a	190	27
 ItemUsage	variant	c416504ade11b787	190	0
@@ -5152,12 +5237,12 @@ JoinNode	isConstant	265e91ff2e4db70f	5	0
 JoinNode	isDerived	265e91ff2e4db70f	5	0
 JoinNode	isEnd	265e91ff2e4db70f	5	0
 JoinNode	isImpliedIncluded	3e7b963c150b94f8	5	5
-JoinNode	isIndividual	9176e7c3d4189fc5	5	0
+JoinNode	isIndividual	265e91ff2e4db70f	5	0
 JoinNode	isLibraryElement	265e91ff2e4db70f	5	0
 JoinNode	isOrdered	265e91ff2e4db70f	5	0
-JoinNode	isPortion	9176e7c3d4189fc5	5	0
+JoinNode	isPortion	265e91ff2e4db70f	5	0
 JoinNode	isReference	265e91ff2e4db70f	5	0
-JoinNode	isSufficient	9176e7c3d4189fc5	5	0
+JoinNode	isSufficient	265e91ff2e4db70f	5	0
 JoinNode	isUnique	3e7b963c150b94f8	5	5
 JoinNode	isVariable	9176e7c3d4189fc5	5	0
 JoinNode	isVariation	265e91ff2e4db70f	5	0
@@ -5212,9 +5297,9 @@ JoinNode	ownedMember	c55adb631509aa04	5	0
 JoinNode	ownedMembership	c55adb631509aa04	5	0
 JoinNode	ownedRedefinition	c55adb631509aa04	5	0
 JoinNode	ownedReferenceSubsetting	9176e7c3d4189fc5	5	0
-JoinNode	ownedRelationship	c55adb631509aa04	5	0
-JoinNode	ownedSpecialization	c55adb631509aa04	5	0
-JoinNode	ownedSubsetting	c55adb631509aa04	5	0
+JoinNode	ownedRelationship	3498ea818bb98688	5	5
+JoinNode	ownedSpecialization	3498ea818bb98688	5	5
+JoinNode	ownedSubsetting	3498ea818bb98688	5	5
 JoinNode	ownedTypeFeaturing	c55adb631509aa04	5	0
 JoinNode	ownedTyping	c55adb631509aa04	5	0
 JoinNode	ownedUnioning	c55adb631509aa04	5	0
@@ -5285,20 +5370,20 @@ LiteralBoolean	inheritedFeature	ff4729258c8ecd00	35	0
 LiteralBoolean	inheritedMembership	ff4729258c8ecd00	35	0
 LiteralBoolean	input	ff4729258c8ecd00	35	0
 LiteralBoolean	intersectingType	ff4729258c8ecd00	35	0
-LiteralBoolean	isAbstract	10556b05e65bb947	35	0
-LiteralBoolean	isComposite	10556b05e65bb947	35	0
+LiteralBoolean	isAbstract	cf320728b3932735	35	0
+LiteralBoolean	isComposite	cf320728b3932735	35	0
 LiteralBoolean	isConjugated	cf320728b3932735	35	0
-LiteralBoolean	isConstant	10556b05e65bb947	35	0
-LiteralBoolean	isDerived	10556b05e65bb947	35	0
-LiteralBoolean	isEnd	10556b05e65bb947	35	0
+LiteralBoolean	isConstant	cf320728b3932735	35	0
+LiteralBoolean	isDerived	cf320728b3932735	35	0
+LiteralBoolean	isEnd	cf320728b3932735	35	0
 LiteralBoolean	isImpliedIncluded	bdf27cb55a38458c	35	35
 LiteralBoolean	isLibraryElement	cf320728b3932735	35	0
 LiteralBoolean	isModelLevelEvaluable	bdf27cb55a38458c	35	35
-LiteralBoolean	isOrdered	10556b05e65bb947	35	0
-LiteralBoolean	isPortion	10556b05e65bb947	35	0
-LiteralBoolean	isSufficient	10556b05e65bb947	35	0
-LiteralBoolean	isUnique	10556b05e65bb947	35	0
-LiteralBoolean	isVariable	10556b05e65bb947	35	0
+LiteralBoolean	isOrdered	cf320728b3932735	35	0
+LiteralBoolean	isPortion	cf320728b3932735	35	0
+LiteralBoolean	isSufficient	cf320728b3932735	35	0
+LiteralBoolean	isUnique	bdf27cb55a38458c	35	35
+LiteralBoolean	isVariable	cf320728b3932735	35	0
 LiteralBoolean	member	ff4729258c8ecd00	35	0
 LiteralBoolean	membership	ff4729258c8ecd00	35	0
 LiteralBoolean	multiplicity	10556b05e65bb947	35	0
@@ -5321,9 +5406,9 @@ LiteralBoolean	ownedMember	ff4729258c8ecd00	35	0
 LiteralBoolean	ownedMembership	ff4729258c8ecd00	35	0
 LiteralBoolean	ownedRedefinition	ff4729258c8ecd00	35	0
 LiteralBoolean	ownedReferenceSubsetting	10556b05e65bb947	35	0
-LiteralBoolean	ownedRelationship	ff4729258c8ecd00	35	0
-LiteralBoolean	ownedSpecialization	ff4729258c8ecd00	35	0
-LiteralBoolean	ownedSubsetting	ff4729258c8ecd00	35	0
+LiteralBoolean	ownedRelationship	d77c9b08f472038a	35	35
+LiteralBoolean	ownedSpecialization	d77c9b08f472038a	35	35
+LiteralBoolean	ownedSubsetting	d77c9b08f472038a	35	35
 LiteralBoolean	ownedTypeFeaturing	ff4729258c8ecd00	35	0
 LiteralBoolean	ownedTyping	ff4729258c8ecd00	35	0
 LiteralBoolean	ownedUnioning	ff4729258c8ecd00	35	0
@@ -5364,20 +5449,20 @@ LiteralInfinity	inheritedFeature	c78ecf28df0cb903	119	0
 LiteralInfinity	inheritedMembership	c78ecf28df0cb903	119	0
 LiteralInfinity	input	c78ecf28df0cb903	119	0
 LiteralInfinity	intersectingType	c78ecf28df0cb903	119	0
-LiteralInfinity	isAbstract	dc92a411e6726750	119	0
-LiteralInfinity	isComposite	dc92a411e6726750	119	0
+LiteralInfinity	isAbstract	12c1c6b99a8f2628	119	0
+LiteralInfinity	isComposite	12c1c6b99a8f2628	119	0
 LiteralInfinity	isConjugated	12c1c6b99a8f2628	119	0
-LiteralInfinity	isConstant	dc92a411e6726750	119	0
-LiteralInfinity	isDerived	dc92a411e6726750	119	0
-LiteralInfinity	isEnd	dc92a411e6726750	119	0
+LiteralInfinity	isConstant	12c1c6b99a8f2628	119	0
+LiteralInfinity	isDerived	12c1c6b99a8f2628	119	0
+LiteralInfinity	isEnd	12c1c6b99a8f2628	119	0
 LiteralInfinity	isImpliedIncluded	75bf1c2267ea921b	119	119
 LiteralInfinity	isLibraryElement	9d850c4e1feaf096	119	30
 LiteralInfinity	isModelLevelEvaluable	75bf1c2267ea921b	119	119
-LiteralInfinity	isOrdered	dc92a411e6726750	119	0
-LiteralInfinity	isPortion	dc92a411e6726750	119	0
-LiteralInfinity	isSufficient	dc92a411e6726750	119	0
-LiteralInfinity	isUnique	dc92a411e6726750	119	0
-LiteralInfinity	isVariable	dc92a411e6726750	119	0
+LiteralInfinity	isOrdered	12c1c6b99a8f2628	119	0
+LiteralInfinity	isPortion	12c1c6b99a8f2628	119	0
+LiteralInfinity	isSufficient	12c1c6b99a8f2628	119	0
+LiteralInfinity	isUnique	75bf1c2267ea921b	119	119
+LiteralInfinity	isVariable	12c1c6b99a8f2628	119	0
 LiteralInfinity	member	c78ecf28df0cb903	119	0
 LiteralInfinity	membership	c78ecf28df0cb903	119	0
 LiteralInfinity	multiplicity	dc92a411e6726750	119	0
@@ -5400,9 +5485,9 @@ LiteralInfinity	ownedMember	c78ecf28df0cb903	119	0
 LiteralInfinity	ownedMembership	c78ecf28df0cb903	119	0
 LiteralInfinity	ownedRedefinition	c78ecf28df0cb903	119	0
 LiteralInfinity	ownedReferenceSubsetting	dc92a411e6726750	119	0
-LiteralInfinity	ownedRelationship	c78ecf28df0cb903	119	0
-LiteralInfinity	ownedSpecialization	c78ecf28df0cb903	119	0
-LiteralInfinity	ownedSubsetting	c78ecf28df0cb903	119	0
+LiteralInfinity	ownedRelationship	d4a46b9ca007e5ce	119	119
+LiteralInfinity	ownedSpecialization	d4a46b9ca007e5ce	119	119
+LiteralInfinity	ownedSubsetting	d4a46b9ca007e5ce	119	119
 LiteralInfinity	ownedTypeFeaturing	c78ecf28df0cb903	119	0
 LiteralInfinity	ownedTyping	c78ecf28df0cb903	119	0
 LiteralInfinity	ownedUnioning	c78ecf28df0cb903	119	0
@@ -5442,20 +5527,20 @@ LiteralInteger	inheritedFeature	74b3d03514840f52	1011	0
 LiteralInteger	inheritedMembership	74b3d03514840f52	1011	0
 LiteralInteger	input	74b3d03514840f52	1011	0
 LiteralInteger	intersectingType	74b3d03514840f52	1011	0
-LiteralInteger	isAbstract	21ad4147b97eeba1	1011	0
-LiteralInteger	isComposite	21ad4147b97eeba1	1011	0
+LiteralInteger	isAbstract	4eb6314813552aff	1011	0
+LiteralInteger	isComposite	4eb6314813552aff	1011	0
 LiteralInteger	isConjugated	4eb6314813552aff	1011	0
-LiteralInteger	isConstant	21ad4147b97eeba1	1011	0
-LiteralInteger	isDerived	21ad4147b97eeba1	1011	0
-LiteralInteger	isEnd	21ad4147b97eeba1	1011	0
+LiteralInteger	isConstant	4eb6314813552aff	1011	0
+LiteralInteger	isDerived	4eb6314813552aff	1011	0
+LiteralInteger	isEnd	4eb6314813552aff	1011	0
 LiteralInteger	isImpliedIncluded	e2222a5bbbba2bce	1011	1011
 LiteralInteger	isLibraryElement	80b894db4502e574	1011	17
 LiteralInteger	isModelLevelEvaluable	e2222a5bbbba2bce	1011	1011
-LiteralInteger	isOrdered	21ad4147b97eeba1	1011	0
-LiteralInteger	isPortion	21ad4147b97eeba1	1011	0
-LiteralInteger	isSufficient	21ad4147b97eeba1	1011	0
-LiteralInteger	isUnique	21ad4147b97eeba1	1011	0
-LiteralInteger	isVariable	21ad4147b97eeba1	1011	0
+LiteralInteger	isOrdered	4eb6314813552aff	1011	0
+LiteralInteger	isPortion	4eb6314813552aff	1011	0
+LiteralInteger	isSufficient	4eb6314813552aff	1011	0
+LiteralInteger	isUnique	e2222a5bbbba2bce	1011	1011
+LiteralInteger	isVariable	4eb6314813552aff	1011	0
 LiteralInteger	member	74b3d03514840f52	1011	0
 LiteralInteger	membership	74b3d03514840f52	1011	0
 LiteralInteger	multiplicity	21ad4147b97eeba1	1011	0
@@ -5478,9 +5563,9 @@ LiteralInteger	ownedMember	74b3d03514840f52	1011	0
 LiteralInteger	ownedMembership	74b3d03514840f52	1011	0
 LiteralInteger	ownedRedefinition	74b3d03514840f52	1011	0
 LiteralInteger	ownedReferenceSubsetting	21ad4147b97eeba1	1011	0
-LiteralInteger	ownedRelationship	74b3d03514840f52	1011	0
-LiteralInteger	ownedSpecialization	74b3d03514840f52	1011	0
-LiteralInteger	ownedSubsetting	74b3d03514840f52	1011	0
+LiteralInteger	ownedRelationship	11a598dd390e73d1	1011	1011
+LiteralInteger	ownedSpecialization	11a598dd390e73d1	1011	1011
+LiteralInteger	ownedSubsetting	11a598dd390e73d1	1011	1011
 LiteralInteger	ownedTypeFeaturing	74b3d03514840f52	1011	0
 LiteralInteger	ownedTyping	74b3d03514840f52	1011	0
 LiteralInteger	ownedUnioning	74b3d03514840f52	1011	0
@@ -5521,20 +5606,20 @@ LiteralRational	inheritedFeature	f3f3421e925cd97b	109	0
 LiteralRational	inheritedMembership	f3f3421e925cd97b	109	0
 LiteralRational	input	f3f3421e925cd97b	109	0
 LiteralRational	intersectingType	f3f3421e925cd97b	109	0
-LiteralRational	isAbstract	e15a8d9a2f46ac3a	109	0
-LiteralRational	isComposite	e15a8d9a2f46ac3a	109	0
+LiteralRational	isAbstract	f2243fdf46eab0e2	109	0
+LiteralRational	isComposite	f2243fdf46eab0e2	109	0
 LiteralRational	isConjugated	f2243fdf46eab0e2	109	0
-LiteralRational	isConstant	e15a8d9a2f46ac3a	109	0
-LiteralRational	isDerived	e15a8d9a2f46ac3a	109	0
-LiteralRational	isEnd	e15a8d9a2f46ac3a	109	0
+LiteralRational	isConstant	f2243fdf46eab0e2	109	0
+LiteralRational	isDerived	f2243fdf46eab0e2	109	0
+LiteralRational	isEnd	f2243fdf46eab0e2	109	0
 LiteralRational	isImpliedIncluded	a4701d3a4ec5119b	109	109
 LiteralRational	isLibraryElement	f2243fdf46eab0e2	109	0
 LiteralRational	isModelLevelEvaluable	a4701d3a4ec5119b	109	109
-LiteralRational	isOrdered	e15a8d9a2f46ac3a	109	0
-LiteralRational	isPortion	e15a8d9a2f46ac3a	109	0
-LiteralRational	isSufficient	e15a8d9a2f46ac3a	109	0
-LiteralRational	isUnique	e15a8d9a2f46ac3a	109	0
-LiteralRational	isVariable	e15a8d9a2f46ac3a	109	0
+LiteralRational	isOrdered	f2243fdf46eab0e2	109	0
+LiteralRational	isPortion	f2243fdf46eab0e2	109	0
+LiteralRational	isSufficient	f2243fdf46eab0e2	109	0
+LiteralRational	isUnique	a4701d3a4ec5119b	109	109
+LiteralRational	isVariable	f2243fdf46eab0e2	109	0
 LiteralRational	member	f3f3421e925cd97b	109	0
 LiteralRational	membership	f3f3421e925cd97b	109	0
 LiteralRational	multiplicity	e15a8d9a2f46ac3a	109	0
@@ -5557,9 +5642,9 @@ LiteralRational	ownedMember	f3f3421e925cd97b	109	0
 LiteralRational	ownedMembership	f3f3421e925cd97b	109	0
 LiteralRational	ownedRedefinition	f3f3421e925cd97b	109	0
 LiteralRational	ownedReferenceSubsetting	e15a8d9a2f46ac3a	109	0
-LiteralRational	ownedRelationship	f3f3421e925cd97b	109	0
-LiteralRational	ownedSpecialization	f3f3421e925cd97b	109	0
-LiteralRational	ownedSubsetting	f3f3421e925cd97b	109	0
+LiteralRational	ownedRelationship	e46fa63fab9bf2d8	109	109
+LiteralRational	ownedSpecialization	e46fa63fab9bf2d8	109	109
+LiteralRational	ownedSubsetting	e46fa63fab9bf2d8	109	109
 LiteralRational	ownedTypeFeaturing	f3f3421e925cd97b	109	0
 LiteralRational	ownedTyping	f3f3421e925cd97b	109	0
 LiteralRational	ownedUnioning	f3f3421e925cd97b	109	0
@@ -5600,20 +5685,20 @@ LiteralString	inheritedFeature	d9b77a1f6c00ae64	57	0
 LiteralString	inheritedMembership	d9b77a1f6c00ae64	57	0
 LiteralString	input	d9b77a1f6c00ae64	57	0
 LiteralString	intersectingType	d9b77a1f6c00ae64	57	0
-LiteralString	isAbstract	d516443a7f6fefed	57	0
-LiteralString	isComposite	d516443a7f6fefed	57	0
+LiteralString	isAbstract	50832d025a25db73	57	0
+LiteralString	isComposite	50832d025a25db73	57	0
 LiteralString	isConjugated	50832d025a25db73	57	0
-LiteralString	isConstant	d516443a7f6fefed	57	0
-LiteralString	isDerived	d516443a7f6fefed	57	0
-LiteralString	isEnd	d516443a7f6fefed	57	0
+LiteralString	isConstant	50832d025a25db73	57	0
+LiteralString	isDerived	50832d025a25db73	57	0
+LiteralString	isEnd	50832d025a25db73	57	0
 LiteralString	isImpliedIncluded	f3488f33ede83e30	57	57
 LiteralString	isLibraryElement	534f19c8e30ecf60	57	1
 LiteralString	isModelLevelEvaluable	f3488f33ede83e30	57	57
-LiteralString	isOrdered	d516443a7f6fefed	57	0
-LiteralString	isPortion	d516443a7f6fefed	57	0
-LiteralString	isSufficient	d516443a7f6fefed	57	0
-LiteralString	isUnique	d516443a7f6fefed	57	0
-LiteralString	isVariable	d516443a7f6fefed	57	0
+LiteralString	isOrdered	50832d025a25db73	57	0
+LiteralString	isPortion	50832d025a25db73	57	0
+LiteralString	isSufficient	50832d025a25db73	57	0
+LiteralString	isUnique	f3488f33ede83e30	57	57
+LiteralString	isVariable	50832d025a25db73	57	0
 LiteralString	member	d9b77a1f6c00ae64	57	0
 LiteralString	membership	d9b77a1f6c00ae64	57	0
 LiteralString	multiplicity	d516443a7f6fefed	57	0
@@ -5636,9 +5721,9 @@ LiteralString	ownedMember	d9b77a1f6c00ae64	57	0
 LiteralString	ownedMembership	d9b77a1f6c00ae64	57	0
 LiteralString	ownedRedefinition	d9b77a1f6c00ae64	57	0
 LiteralString	ownedReferenceSubsetting	d516443a7f6fefed	57	0
-LiteralString	ownedRelationship	d9b77a1f6c00ae64	57	0
-LiteralString	ownedSpecialization	d9b77a1f6c00ae64	57	0
-LiteralString	ownedSubsetting	d9b77a1f6c00ae64	57	0
+LiteralString	ownedRelationship	c7d255f6eb129331	57	57
+LiteralString	ownedSpecialization	c7d255f6eb129331	57	57
+LiteralString	ownedSubsetting	c7d255f6eb129331	57	57
 LiteralString	ownedTypeFeaturing	d9b77a1f6c00ae64	57	0
 LiteralString	ownedTyping	d9b77a1f6c00ae64	57	0
 LiteralString	ownedUnioning	d9b77a1f6c00ae64	57	0
@@ -5656,36 +5741,36 @@ LiteralString	textualRepresentation	d9b77a1f6c00ae64	57	0
 LiteralString	type	d9b77a1f6c00ae64	57	0
 LiteralString	unioningType	d9b77a1f6c00ae64	57	0
 LiteralString	value	20b5017a7ebc6604	57	57
-Membership	aliasIds	cdc6131fd0a10d92	2338	0
-Membership	declaredName	2c91849a426e4310	2338	0
-Membership	declaredShortName	2c91849a426e4310	2338	0
-Membership	documentation	cdc6131fd0a10d92	2338	0
-Membership	elementId	92b6720c23c152c0	2338	2338
-Membership	isImplied	3546c530d8fe3960	2338	0
-Membership	isImpliedIncluded	5c193ffe27565b5a	2338	2338
-Membership	isLibraryElement	b6e5c4062e9f399b	2338	23
-Membership	memberElement	ea64876f395c0050	2338	2338
-Membership	memberElementId	de5cb443d6141cbe	2338	2338
-Membership	memberName	77293393d0e06cb2	2338	1804
-Membership	memberShortName	0c5630e34a6faf5b	2338	18
-Membership	membershipOwningNamespace	9fa6e56e5526b3ed	2338	2338
-Membership	name	2c91849a426e4310	2338	0
-Membership	ownedAnnotation	cdc6131fd0a10d92	2338	0
-Membership	ownedElement	a6bb43e371ae9534	2338	15
-Membership	ownedRelatedElement	cdc6131fd0a10d92	2338	0
-Membership	ownedRelationship	06a26a02e1f38966	2338	15
-Membership	owner	2c91849a426e4310	2338	0
-Membership	owningMembership	2c91849a426e4310	2338	0
-Membership	owningNamespace	2c91849a426e4310	2338	0
-Membership	owningRelatedElement	9fa6e56e5526b3ed	2338	2338
-Membership	owningRelationship	2c91849a426e4310	2338	0
-Membership	qualifiedName	2c91849a426e4310	2338	0
-Membership	relatedElement	ee38927ff15b808d	2338	2338
-Membership	shortName	2c91849a426e4310	2338	0
-Membership	source	3a66bf1d3423662b	2338	2338
-Membership	target	b7f483e35b910f20	2338	2338
-Membership	textualRepresentation	a6bb43e371ae9534	2338	15
-Membership	visibility	ea0802dcac622600	2338	32
+Membership	aliasIds	a74dc6171995eec4	2338	0
+Membership	declaredName	593c749888fae366	2338	0
+Membership	declaredShortName	593c749888fae366	2338	0
+Membership	documentation	a74dc6171995eec4	2338	0
+Membership	elementId	0b19c44ef50b7634	2338	2338
+Membership	isImplied	54fc0ee55f7ad51a	2338	0
+Membership	isImpliedIncluded	87e6c6d5c091019c	2338	2338
+Membership	isLibraryElement	d69b0dbab51bd555	2338	23
+Membership	memberElement	defdb18ae2f7b4e4	2338	2338
+Membership	memberElementId	7aa4911fffb5b8a6	2338	2338
+Membership	memberName	6963785018a73eac	2338	1803
+Membership	memberShortName	390120e190fc4fb1	2338	18
+Membership	membershipOwningNamespace	b3e9d16185988fac	2338	2338
+Membership	name	593c749888fae366	2338	0
+Membership	ownedAnnotation	a74dc6171995eec4	2338	0
+Membership	ownedElement	8042f6dabaa37666	2338	15
+Membership	ownedRelatedElement	a74dc6171995eec4	2338	0
+Membership	ownedRelationship	e02a1cfa2ae86a98	2338	15
+Membership	owner	593c749888fae366	2338	0
+Membership	owningMembership	593c749888fae366	2338	0
+Membership	owningNamespace	593c749888fae366	2338	0
+Membership	owningRelatedElement	b3e9d16185988fac	2338	2338
+Membership	owningRelationship	593c749888fae366	2338	0
+Membership	qualifiedName	593c749888fae366	2338	0
+Membership	relatedElement	0b0b93e518ea1ac8	2338	2338
+Membership	shortName	593c749888fae366	2338	0
+Membership	source	d32ba50c3b5db7c8	2338	2338
+Membership	target	6ad0d16977e594f8	2338	2338
+Membership	textualRepresentation	8042f6dabaa37666	2338	15
+Membership	visibility	e07f1d64a42d3332	2338	2338
 MembershipExpose	aliasIds	5c18716f7d72e78f	3	0
 MembershipExpose	declaredName	e7affae023d5d998	3	0
 MembershipExpose	declaredShortName	e7affae023d5d998	3	0
@@ -5723,7 +5808,7 @@ MembershipImport	documentation	7377536f8f9d5b6a	174	0
 MembershipImport	elementId	a1083640dc24aaa8	174	174
 MembershipImport	importOwningNamespace	7bcb6fd1f0f843fb	174	174
 MembershipImport	importedElement	c3d6e46c5683c546	174	174
-MembershipImport	importedMembership	138dd0aa60a682fe	174	174
+MembershipImport	importedMembership	5c04797e2c75443c	174	174
 MembershipImport	isImplied	5c08bf3ac3efec34	174	0
 MembershipImport	isImpliedIncluded	2b4e7a92e103fa8a	174	174
 MembershipImport	isImportAll	5c08bf3ac3efec34	174	0
@@ -5740,10 +5825,10 @@ MembershipImport	owningNamespace	3f33792eff066bf0	174	0
 MembershipImport	owningRelatedElement	7bcb6fd1f0f843fb	174	174
 MembershipImport	owningRelationship	3f33792eff066bf0	174	0
 MembershipImport	qualifiedName	3f33792eff066bf0	174	0
-MembershipImport	relatedElement	1908229d6e93f8e3	174	174
+MembershipImport	relatedElement	e7de1fc7dc19d501	174	174
 MembershipImport	shortName	3f33792eff066bf0	174	0
 MembershipImport	source	f184c0d224cd7451	174	174
-MembershipImport	target	182d85a289e9a522	174	174
+MembershipImport	target	bf5bfe17a1bd843c	174	174
 MembershipImport	textualRepresentation	451e6eec1189e1e7	174	2
 MembershipImport	visibility	fb69917ef5bd1086	174	174
 MergeNode	actionDefinition	634980ae0ed80a19	8	0
@@ -5779,12 +5864,12 @@ MergeNode	isConstant	3e70cacce7ba6455	8	0
 MergeNode	isDerived	3e70cacce7ba6455	8	0
 MergeNode	isEnd	3e70cacce7ba6455	8	0
 MergeNode	isImpliedIncluded	22eba3ce73d4dccd	8	8
-MergeNode	isIndividual	d641eefcc747481f	8	0
+MergeNode	isIndividual	3e70cacce7ba6455	8	0
 MergeNode	isLibraryElement	3e70cacce7ba6455	8	0
 MergeNode	isOrdered	3e70cacce7ba6455	8	0
-MergeNode	isPortion	d641eefcc747481f	8	0
+MergeNode	isPortion	3e70cacce7ba6455	8	0
 MergeNode	isReference	3e70cacce7ba6455	8	0
-MergeNode	isSufficient	d641eefcc747481f	8	0
+MergeNode	isSufficient	3e70cacce7ba6455	8	0
 MergeNode	isUnique	22eba3ce73d4dccd	8	8
 MergeNode	isVariable	d641eefcc747481f	8	0
 MergeNode	isVariation	3e70cacce7ba6455	8	0
@@ -5839,9 +5924,9 @@ MergeNode	ownedMember	93125d92639eec3a	8	1
 MergeNode	ownedMembership	22f60b1d231b46cf	8	1
 MergeNode	ownedRedefinition	634980ae0ed80a19	8	0
 MergeNode	ownedReferenceSubsetting	d641eefcc747481f	8	0
-MergeNode	ownedRelationship	22f60b1d231b46cf	8	1
-MergeNode	ownedSpecialization	634980ae0ed80a19	8	0
-MergeNode	ownedSubsetting	634980ae0ed80a19	8	0
+MergeNode	ownedRelationship	c6d7975e0e086704	8	8
+MergeNode	ownedSpecialization	886135e0c326a408	8	8
+MergeNode	ownedSubsetting	886135e0c326a408	8	8
 MergeNode	ownedTypeFeaturing	634980ae0ed80a19	8	0
 MergeNode	ownedTyping	634980ae0ed80a19	8	0
 MergeNode	ownedUnioning	634980ae0ed80a19	8	0
@@ -5886,20 +5971,20 @@ MetadataAccessExpression	inheritedFeature	025be037db3e3fbc	27	0
 MetadataAccessExpression	inheritedMembership	025be037db3e3fbc	27	0
 MetadataAccessExpression	input	025be037db3e3fbc	27	0
 MetadataAccessExpression	intersectingType	025be037db3e3fbc	27	0
-MetadataAccessExpression	isAbstract	c14f1f14323b3067	27	0
-MetadataAccessExpression	isComposite	c14f1f14323b3067	27	0
+MetadataAccessExpression	isAbstract	594413c2c0270291	27	0
+MetadataAccessExpression	isComposite	594413c2c0270291	27	0
 MetadataAccessExpression	isConjugated	594413c2c0270291	27	0
-MetadataAccessExpression	isConstant	c14f1f14323b3067	27	0
-MetadataAccessExpression	isDerived	c14f1f14323b3067	27	0
-MetadataAccessExpression	isEnd	c14f1f14323b3067	27	0
+MetadataAccessExpression	isConstant	594413c2c0270291	27	0
+MetadataAccessExpression	isDerived	594413c2c0270291	27	0
+MetadataAccessExpression	isEnd	594413c2c0270291	27	0
 MetadataAccessExpression	isImpliedIncluded	6ace4c6a191e80c8	27	27
 MetadataAccessExpression	isLibraryElement	60ec0eea9544e304	27	23
 MetadataAccessExpression	isModelLevelEvaluable	6ace4c6a191e80c8	27	27
-MetadataAccessExpression	isOrdered	c14f1f14323b3067	27	0
-MetadataAccessExpression	isPortion	c14f1f14323b3067	27	0
-MetadataAccessExpression	isSufficient	c14f1f14323b3067	27	0
-MetadataAccessExpression	isUnique	c14f1f14323b3067	27	0
-MetadataAccessExpression	isVariable	c14f1f14323b3067	27	0
+MetadataAccessExpression	isOrdered	594413c2c0270291	27	0
+MetadataAccessExpression	isPortion	594413c2c0270291	27	0
+MetadataAccessExpression	isSufficient	594413c2c0270291	27	0
+MetadataAccessExpression	isUnique	6ace4c6a191e80c8	27	27
+MetadataAccessExpression	isVariable	594413c2c0270291	27	0
 MetadataAccessExpression	member	08e09584f64ea19f	27	27
 MetadataAccessExpression	membership	996ead2137227c74	27	27
 MetadataAccessExpression	multiplicity	c14f1f14323b3067	27	0
@@ -5922,9 +6007,9 @@ MetadataAccessExpression	ownedMember	025be037db3e3fbc	27	0
 MetadataAccessExpression	ownedMembership	996ead2137227c74	27	27
 MetadataAccessExpression	ownedRedefinition	025be037db3e3fbc	27	0
 MetadataAccessExpression	ownedReferenceSubsetting	c14f1f14323b3067	27	0
-MetadataAccessExpression	ownedRelationship	996ead2137227c74	27	27
-MetadataAccessExpression	ownedSpecialization	025be037db3e3fbc	27	0
-MetadataAccessExpression	ownedSubsetting	025be037db3e3fbc	27	0
+MetadataAccessExpression	ownedRelationship	277b47b17a23a36f	27	27
+MetadataAccessExpression	ownedSpecialization	bd0f9d3ceb655573	27	27
+MetadataAccessExpression	ownedSubsetting	bd0f9d3ceb655573	27	27
 MetadataAccessExpression	ownedTypeFeaturing	025be037db3e3fbc	27	0
 MetadataAccessExpression	ownedTyping	025be037db3e3fbc	27	0
 MetadataAccessExpression	ownedUnioning	025be037db3e3fbc	27	0
@@ -5961,7 +6046,7 @@ MetadataDefinition	intersectingType	53276bf2f7d5db5b	46	0
 MetadataDefinition	isAbstract	931eecbec2776526	46	1
 MetadataDefinition	isConjugated	d3abf844d3c61b51	46	0
 MetadataDefinition	isImpliedIncluded	ba060b1c385f9237	46	46
-MetadataDefinition	isIndividual	9d895d5cfdeb1313	46	0
+MetadataDefinition	isIndividual	d3abf844d3c61b51	46	0
 MetadataDefinition	isLibraryElement	372dd93311af11c8	46	27
 MetadataDefinition	isSufficient	d3abf844d3c61b51	46	0
 MetadataDefinition	isVariation	d3abf844d3c61b51	46	0
@@ -5990,7 +6075,7 @@ MetadataDefinition	ownedFeature	9e131acb1cc34086	46	39
 MetadataDefinition	ownedFeatureMembership	8b2b8c667640e87b	46	39
 MetadataDefinition	ownedFlow	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedImport	53276bf2f7d5db5b	46	0
-MetadataDefinition	ownedInterface	1d5e547331f3d9ae	46	32
+MetadataDefinition	ownedInterface	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedIntersecting	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedItem	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedMember	5d04a0c332dc4ce8	46	39
@@ -6000,12 +6085,12 @@ MetadataDefinition	ownedOccurrence	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedPart	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedPort	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedReference	1d5e547331f3d9ae	46	32
-MetadataDefinition	ownedRelationship	6b2d672f98db2334	46	46
+MetadataDefinition	ownedRelationship	6c6603a4079dab3d	46	46
 MetadataDefinition	ownedRendering	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedRequirement	53276bf2f7d5db5b	46	0
-MetadataDefinition	ownedSpecialization	ab61b26088e5d537	46	46
+MetadataDefinition	ownedSpecialization	cee11d42e7f78d10	46	46
 MetadataDefinition	ownedState	53276bf2f7d5db5b	46	0
-MetadataDefinition	ownedSubclassification	ab61b26088e5d537	46	46
+MetadataDefinition	ownedSubclassification	cee11d42e7f78d10	46	46
 MetadataDefinition	ownedTransition	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedUnioning	53276bf2f7d5db5b	46	0
 MetadataDefinition	ownedUsage	9e131acb1cc34086	46	39
@@ -6050,20 +6135,20 @@ MetadataUsage	inheritedFeature	3520314ea7a1d36d	179	0
 MetadataUsage	inheritedMembership	3520314ea7a1d36d	179	0
 MetadataUsage	input	3520314ea7a1d36d	179	0
 MetadataUsage	intersectingType	3520314ea7a1d36d	179	0
-MetadataUsage	isAbstract	a055a35c415b4f0a	179	0
+MetadataUsage	isAbstract	761ff93ecfd8a0d6	179	0
 MetadataUsage	isComposite	761ff93ecfd8a0d6	179	0
 MetadataUsage	isConjugated	761ff93ecfd8a0d6	179	0
-MetadataUsage	isConstant	a055a35c415b4f0a	179	0
-MetadataUsage	isDerived	a055a35c415b4f0a	179	0
-MetadataUsage	isEnd	a055a35c415b4f0a	179	0
+MetadataUsage	isConstant	761ff93ecfd8a0d6	179	0
+MetadataUsage	isDerived	761ff93ecfd8a0d6	179	0
+MetadataUsage	isEnd	761ff93ecfd8a0d6	179	0
 MetadataUsage	isImpliedIncluded	5d3644f223ae6935	179	179
-MetadataUsage	isIndividual	e27d4c669cbaaf9e	179	0
+MetadataUsage	isIndividual	761ff93ecfd8a0d6	179	0
 MetadataUsage	isLibraryElement	1143389b33170b4a	179	20
-MetadataUsage	isOrdered	a055a35c415b4f0a	179	0
-MetadataUsage	isPortion	e27d4c669cbaaf9e	179	0
+MetadataUsage	isOrdered	761ff93ecfd8a0d6	179	0
+MetadataUsage	isPortion	761ff93ecfd8a0d6	179	0
 MetadataUsage	isReference	5d3644f223ae6935	179	179
-MetadataUsage	isSufficient	e27d4c669cbaaf9e	179	0
-MetadataUsage	isUnique	f4f5132200b1e5e5	179	63
+MetadataUsage	isSufficient	761ff93ecfd8a0d6	179	0
+MetadataUsage	isUnique	5d3644f223ae6935	179	179
 MetadataUsage	isVariable	e27d4c669cbaaf9e	179	0
 MetadataUsage	isVariation	761ff93ecfd8a0d6	179	0
 MetadataUsage	itemDefinition	3ebe7f44ee1fc6e9	179	179
@@ -6085,7 +6170,7 @@ MetadataUsage	nestedConnection	3520314ea7a1d36d	179	0
 MetadataUsage	nestedConstraint	3520314ea7a1d36d	179	0
 MetadataUsage	nestedEnumeration	3520314ea7a1d36d	179	0
 MetadataUsage	nestedFlow	3520314ea7a1d36d	179	0
-MetadataUsage	nestedInterface	0a7a7c935a9b2e8c	179	61
+MetadataUsage	nestedInterface	3520314ea7a1d36d	179	0
 MetadataUsage	nestedItem	3520314ea7a1d36d	179	0
 MetadataUsage	nestedMetadata	3520314ea7a1d36d	179	0
 MetadataUsage	nestedOccurrence	3520314ea7a1d36d	179	0
@@ -6167,19 +6252,19 @@ MultiplicityRange	inheritedFeature	62185e122e4519f8	576	0
 MultiplicityRange	inheritedMembership	62185e122e4519f8	576	0
 MultiplicityRange	input	62185e122e4519f8	576	0
 MultiplicityRange	intersectingType	62185e122e4519f8	576	0
-MultiplicityRange	isAbstract	64ddbbf33acaebb8	576	0
-MultiplicityRange	isComposite	64ddbbf33acaebb8	576	0
+MultiplicityRange	isAbstract	af8e25ed92db23a0	576	0
+MultiplicityRange	isComposite	af8e25ed92db23a0	576	0
 MultiplicityRange	isConjugated	af8e25ed92db23a0	576	0
-MultiplicityRange	isConstant	64ddbbf33acaebb8	576	0
-MultiplicityRange	isDerived	64ddbbf33acaebb8	576	0
-MultiplicityRange	isEnd	64ddbbf33acaebb8	576	0
+MultiplicityRange	isConstant	af8e25ed92db23a0	576	0
+MultiplicityRange	isDerived	af8e25ed92db23a0	576	0
+MultiplicityRange	isEnd	af8e25ed92db23a0	576	0
 MultiplicityRange	isImpliedIncluded	6bc3284d49e01e80	576	576
 MultiplicityRange	isLibraryElement	e7ee5a598da883ca	576	34
-MultiplicityRange	isOrdered	64ddbbf33acaebb8	576	0
-MultiplicityRange	isPortion	64ddbbf33acaebb8	576	0
-MultiplicityRange	isSufficient	64ddbbf33acaebb8	576	0
-MultiplicityRange	isUnique	64ddbbf33acaebb8	576	0
-MultiplicityRange	isVariable	64ddbbf33acaebb8	576	0
+MultiplicityRange	isOrdered	af8e25ed92db23a0	576	0
+MultiplicityRange	isPortion	af8e25ed92db23a0	576	0
+MultiplicityRange	isSufficient	af8e25ed92db23a0	576	0
+MultiplicityRange	isUnique	6bc3284d49e01e80	576	576
+MultiplicityRange	isVariable	af8e25ed92db23a0	576	0
 MultiplicityRange	lowerBound	bc642c30a3bb9c5f	576	116
 MultiplicityRange	member	83c38c3a1fd53ea2	576	576
 MultiplicityRange	membership	5238f10af7a6408f	576	576
@@ -6203,9 +6288,9 @@ MultiplicityRange	ownedMember	83c38c3a1fd53ea2	576	576
 MultiplicityRange	ownedMembership	5238f10af7a6408f	576	576
 MultiplicityRange	ownedRedefinition	62185e122e4519f8	576	0
 MultiplicityRange	ownedReferenceSubsetting	64ddbbf33acaebb8	576	0
-MultiplicityRange	ownedRelationship	5238f10af7a6408f	576	576
-MultiplicityRange	ownedSpecialization	62185e122e4519f8	576	0
-MultiplicityRange	ownedSubsetting	62185e122e4519f8	576	0
+MultiplicityRange	ownedRelationship	7da5b6eef670bd0f	576	576
+MultiplicityRange	ownedSpecialization	8c036eeb1058bb0a	576	576
+MultiplicityRange	ownedSubsetting	8c036eeb1058bb0a	576	576
 MultiplicityRange	ownedTypeFeaturing	62185e122e4519f8	576	0
 MultiplicityRange	ownedTyping	62185e122e4519f8	576	0
 MultiplicityRange	ownedUnioning	62185e122e4519f8	576	0
@@ -6328,20 +6413,20 @@ NullExpression	inheritedFeature	0c8041cb836844b7	10	0
 NullExpression	inheritedMembership	0c8041cb836844b7	10	0
 NullExpression	input	0c8041cb836844b7	10	0
 NullExpression	intersectingType	0c8041cb836844b7	10	0
-NullExpression	isAbstract	f3f79feecf93e1ff	10	0
-NullExpression	isComposite	f3f79feecf93e1ff	10	0
+NullExpression	isAbstract	f2c0ab4228abc629	10	0
+NullExpression	isComposite	f2c0ab4228abc629	10	0
 NullExpression	isConjugated	f2c0ab4228abc629	10	0
-NullExpression	isConstant	f3f79feecf93e1ff	10	0
-NullExpression	isDerived	f3f79feecf93e1ff	10	0
-NullExpression	isEnd	f3f79feecf93e1ff	10	0
+NullExpression	isConstant	f2c0ab4228abc629	10	0
+NullExpression	isDerived	f2c0ab4228abc629	10	0
+NullExpression	isEnd	f2c0ab4228abc629	10	0
 NullExpression	isImpliedIncluded	08283dc51ce9493b	10	10
 NullExpression	isLibraryElement	f2c0ab4228abc629	10	0
 NullExpression	isModelLevelEvaluable	08283dc51ce9493b	10	10
-NullExpression	isOrdered	f3f79feecf93e1ff	10	0
-NullExpression	isPortion	f3f79feecf93e1ff	10	0
-NullExpression	isSufficient	f3f79feecf93e1ff	10	0
-NullExpression	isUnique	f3f79feecf93e1ff	10	0
-NullExpression	isVariable	f3f79feecf93e1ff	10	0
+NullExpression	isOrdered	f2c0ab4228abc629	10	0
+NullExpression	isPortion	f2c0ab4228abc629	10	0
+NullExpression	isSufficient	f2c0ab4228abc629	10	0
+NullExpression	isUnique	08283dc51ce9493b	10	10
+NullExpression	isVariable	f2c0ab4228abc629	10	0
 NullExpression	member	0c8041cb836844b7	10	0
 NullExpression	membership	0c8041cb836844b7	10	0
 NullExpression	multiplicity	f3f79feecf93e1ff	10	0
@@ -6364,9 +6449,9 @@ NullExpression	ownedMember	0c8041cb836844b7	10	0
 NullExpression	ownedMembership	0c8041cb836844b7	10	0
 NullExpression	ownedRedefinition	0c8041cb836844b7	10	0
 NullExpression	ownedReferenceSubsetting	f3f79feecf93e1ff	10	0
-NullExpression	ownedRelationship	0c8041cb836844b7	10	0
-NullExpression	ownedSpecialization	0c8041cb836844b7	10	0
-NullExpression	ownedSubsetting	0c8041cb836844b7	10	0
+NullExpression	ownedRelationship	0051809840e14058	10	10
+NullExpression	ownedSpecialization	0051809840e14058	10	10
+NullExpression	ownedSubsetting	0051809840e14058	10	10
 NullExpression	ownedTypeFeaturing	0c8041cb836844b7	10	0
 NullExpression	ownedTyping	0c8041cb836844b7	10	0
 NullExpression	ownedUnioning	0c8041cb836844b7	10	0
@@ -6466,7 +6551,7 @@ OccurrenceDefinition	ownedEndFeature	2440ae8a9a25448e	40	0
 OccurrenceDefinition	ownedEnumeration	2440ae8a9a25448e	40	0
 OccurrenceDefinition	ownedFeature	9ce4b7ad9bb62e35	40	19
 OccurrenceDefinition	ownedFeatureMembership	eb5bc34d082d2425	40	19
-OccurrenceDefinition	ownedFlow	2440ae8a9a25448e	40	0
+OccurrenceDefinition	ownedFlow	6beb1792c22d65a2	40	7
 OccurrenceDefinition	ownedImport	2440ae8a9a25448e	40	0
 OccurrenceDefinition	ownedInterface	2440ae8a9a25448e	40	0
 OccurrenceDefinition	ownedIntersecting	2440ae8a9a25448e	40	0
@@ -6516,8 +6601,8 @@ OccurrenceUsage	documentation	c2c5174ef18cb0c2	113	8
 OccurrenceUsage	elementId	6afeb69a0552bedc	113	113
 OccurrenceUsage	endFeature	7e900f60cfb83537	113	0
 OccurrenceUsage	endOwningType	7f79ce2c604b7372	113	0
-OccurrenceUsage	feature	04e9b7eed33d7920	113	67
-OccurrenceUsage	featureMembership	88f7d73c60f18fc1	113	67
+OccurrenceUsage	feature	091d1cecf1d96bf9	113	67
+OccurrenceUsage	featureMembership	b6ee8126ef770d87	113	67
 OccurrenceUsage	featureTarget	3eb2140487c4a6b7	113	0
 OccurrenceUsage	featuringType	7e900f60cfb83537	113	0
 OccurrenceUsage	importedMembership	7e900f60cfb83537	113	0
@@ -6536,18 +6621,18 @@ OccurrenceUsage	isImpliedIncluded	b1631afe3fcedabf	113	113
 OccurrenceUsage	isIndividual	86b03d97e14c9859	113	19
 OccurrenceUsage	isLibraryElement	af72603aba96a40b	113	13
 OccurrenceUsage	isOrdered	411db72b02410847	113	1
-OccurrenceUsage	isPortion	7f79ce2c604b7372	113	0
+OccurrenceUsage	isPortion	3add13fc6f651c62	113	0
 OccurrenceUsage	isReference	d2f5d8ec5b723c13	113	29
-OccurrenceUsage	isSufficient	7f79ce2c604b7372	113	0
+OccurrenceUsage	isSufficient	3add13fc6f651c62	113	0
 OccurrenceUsage	isUnique	48fbc807c3c9fbba	113	104
 OccurrenceUsage	isVariable	7f79ce2c604b7372	113	0
 OccurrenceUsage	isVariation	3add13fc6f651c62	113	0
 OccurrenceUsage	mayTimeVary	7f79ce2c604b7372	113	0
-OccurrenceUsage	member	1434315939cba6cb	113	82
-OccurrenceUsage	membership	4cf2c0cc80164345	113	82
+OccurrenceUsage	member	8efc4c316b5d5d82	113	82
+OccurrenceUsage	membership	d5688d3df25efecb	113	82
 OccurrenceUsage	multiplicity	9dca5481f252db3c	113	12
 OccurrenceUsage	name	ecb3abf919bc27b9	113	112
-OccurrenceUsage	nestedAction	b9b45b99e52c87b8	113	7
+OccurrenceUsage	nestedAction	13756f8f104ff13d	113	7
 OccurrenceUsage	nestedAllocation	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedAnalysisCase	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedAttribute	6b145da8fb66e28e	113	6
@@ -6557,19 +6642,19 @@ OccurrenceUsage	nestedConcern	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedConnection	55b443421c212b9c	113	5
 OccurrenceUsage	nestedConstraint	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedEnumeration	7e900f60cfb83537	113	0
-OccurrenceUsage	nestedFlow	7e900f60cfb83537	113	0
-OccurrenceUsage	nestedInterface	a92589b4ee6a8cb3	113	30
+OccurrenceUsage	nestedFlow	909abc447c5729db	113	2
+OccurrenceUsage	nestedInterface	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedItem	aa122b46fe182a43	113	10
 OccurrenceUsage	nestedMetadata	7e900f60cfb83537	113	0
-OccurrenceUsage	nestedOccurrence	8ea67f44becca1c4	113	44
+OccurrenceUsage	nestedOccurrence	e8679339e9f00b49	113	44
 OccurrenceUsage	nestedPart	6b7717da4dd80005	113	4
 OccurrenceUsage	nestedPort	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedReference	a92589b4ee6a8cb3	113	30
 OccurrenceUsage	nestedRendering	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedRequirement	7e900f60cfb83537	113	0
-OccurrenceUsage	nestedState	4cb1af492b7f624b	113	3
+OccurrenceUsage	nestedState	a672c33e56a2cbd0	113	3
 OccurrenceUsage	nestedTransition	7e900f60cfb83537	113	0
-OccurrenceUsage	nestedUsage	04e9b7eed33d7920	113	67
+OccurrenceUsage	nestedUsage	091d1cecf1d96bf9	113	67
 OccurrenceUsage	nestedUseCase	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedVerificationCase	7e900f60cfb83537	113	0
 OccurrenceUsage	nestedView	7e900f60cfb83537	113	0
@@ -6581,21 +6666,21 @@ OccurrenceUsage	ownedConjugator	7f79ce2c604b7372	113	0
 OccurrenceUsage	ownedCrossSubsetting	7f79ce2c604b7372	113	0
 OccurrenceUsage	ownedDifferencing	7e900f60cfb83537	113	0
 OccurrenceUsage	ownedDisjoining	7e900f60cfb83537	113	0
-OccurrenceUsage	ownedElement	dbd35b96ec282cb0	113	82
+OccurrenceUsage	ownedElement	569b766f1db9e367	113	82
 OccurrenceUsage	ownedEndFeature	7e900f60cfb83537	113	0
-OccurrenceUsage	ownedFeature	04e9b7eed33d7920	113	67
+OccurrenceUsage	ownedFeature	091d1cecf1d96bf9	113	67
 OccurrenceUsage	ownedFeatureChaining	7e900f60cfb83537	113	0
 OccurrenceUsage	ownedFeatureInverting	7e900f60cfb83537	113	0
-OccurrenceUsage	ownedFeatureMembership	88f7d73c60f18fc1	113	67
+OccurrenceUsage	ownedFeatureMembership	b6ee8126ef770d87	113	67
 OccurrenceUsage	ownedImport	7e900f60cfb83537	113	0
 OccurrenceUsage	ownedIntersecting	7e900f60cfb83537	113	0
-OccurrenceUsage	ownedMember	1434315939cba6cb	113	82
-OccurrenceUsage	ownedMembership	4cf2c0cc80164345	113	82
+OccurrenceUsage	ownedMember	8efc4c316b5d5d82	113	82
+OccurrenceUsage	ownedMembership	d5688d3df25efecb	113	82
 OccurrenceUsage	ownedRedefinition	5884d28d612b33b4	113	25
 OccurrenceUsage	ownedReferenceSubsetting	7f79ce2c604b7372	113	0
-OccurrenceUsage	ownedRelationship	e4358f73d6aaec56	113	113
-OccurrenceUsage	ownedSpecialization	88069c3a9b9a7f64	113	113
-OccurrenceUsage	ownedSubsetting	6c6cf08c7bc94c04	113	113
+OccurrenceUsage	ownedRelationship	54e004129c517cb4	113	113
+OccurrenceUsage	ownedSpecialization	6da4059549e36050	113	113
+OccurrenceUsage	ownedSubsetting	31feb4ebef94ca6c	113	113
 OccurrenceUsage	ownedTypeFeaturing	7e900f60cfb83537	113	0
 OccurrenceUsage	ownedTyping	39fb6db8c3646dc7	113	61
 OccurrenceUsage	ownedUnioning	7e900f60cfb83537	113	0
@@ -6613,7 +6698,7 @@ OccurrenceUsage	shortName	7f79ce2c604b7372	113	0
 OccurrenceUsage	textualRepresentation	7e900f60cfb83537	113	0
 OccurrenceUsage	type	1a333ea3057effcc	113	78
 OccurrenceUsage	unioningType	7e900f60cfb83537	113	0
-OccurrenceUsage	usage	04e9b7eed33d7920	113	67
+OccurrenceUsage	usage	091d1cecf1d96bf9	113	67
 OccurrenceUsage	variant	7e900f60cfb83537	113	0
 OccurrenceUsage	variantMembership	7e900f60cfb83537	113	0
 OperatorExpression	aliasIds	0e965a577af286a9	931	0
@@ -6639,22 +6724,22 @@ OperatorExpression	importedMembership	0e965a577af286a9	931	0
 OperatorExpression	inheritedFeature	0e965a577af286a9	931	0
 OperatorExpression	inheritedMembership	0e965a577af286a9	931	0
 OperatorExpression	input	3945d5b868c02bf5	931	930
-OperatorExpression	instantiatedType	e541d3aa736e6d07	931	931
+OperatorExpression	instantiatedType	c881511473473db9	931	931
 OperatorExpression	intersectingType	0e965a577af286a9	931	0
-OperatorExpression	isAbstract	c55b67f7dff0d016	931	0
-OperatorExpression	isComposite	c55b67f7dff0d016	931	0
+OperatorExpression	isAbstract	f9193a67c434b5da	931	0
+OperatorExpression	isComposite	f9193a67c434b5da	931	0
 OperatorExpression	isConjugated	f9193a67c434b5da	931	0
-OperatorExpression	isConstant	c55b67f7dff0d016	931	0
-OperatorExpression	isDerived	c55b67f7dff0d016	931	0
-OperatorExpression	isEnd	c55b67f7dff0d016	931	0
+OperatorExpression	isConstant	f9193a67c434b5da	931	0
+OperatorExpression	isDerived	f9193a67c434b5da	931	0
+OperatorExpression	isEnd	f9193a67c434b5da	931	0
 OperatorExpression	isImpliedIncluded	3f1db5763953c0d1	931	931
 OperatorExpression	isLibraryElement	1b817acfde253415	931	23
-OperatorExpression	isModelLevelEvaluable	a63894d1973721c9	931	403
-OperatorExpression	isOrdered	c55b67f7dff0d016	931	0
-OperatorExpression	isPortion	c55b67f7dff0d016	931	0
-OperatorExpression	isSufficient	c55b67f7dff0d016	931	0
-OperatorExpression	isUnique	c55b67f7dff0d016	931	0
-OperatorExpression	isVariable	c55b67f7dff0d016	931	0
+OperatorExpression	isModelLevelEvaluable	4fee03b3f78ef0aa	931	152
+OperatorExpression	isOrdered	f9193a67c434b5da	931	0
+OperatorExpression	isPortion	f9193a67c434b5da	931	0
+OperatorExpression	isSufficient	f9193a67c434b5da	931	0
+OperatorExpression	isUnique	3f1db5763953c0d1	931	931
+OperatorExpression	isVariable	f9193a67c434b5da	931	0
 OperatorExpression	member	729bf7be46a6af3b	931	931
 OperatorExpression	membership	803fdde61e604daf	931	931
 OperatorExpression	multiplicity	c55b67f7dff0d016	931	0
@@ -6678,9 +6763,9 @@ OperatorExpression	ownedMember	729bf7be46a6af3b	931	931
 OperatorExpression	ownedMembership	803fdde61e604daf	931	931
 OperatorExpression	ownedRedefinition	0e965a577af286a9	931	0
 OperatorExpression	ownedReferenceSubsetting	c55b67f7dff0d016	931	0
-OperatorExpression	ownedRelationship	803fdde61e604daf	931	931
-OperatorExpression	ownedSpecialization	0e965a577af286a9	931	0
-OperatorExpression	ownedSubsetting	0e965a577af286a9	931	0
+OperatorExpression	ownedRelationship	b42a7f59f0c3e59a	931	931
+OperatorExpression	ownedSpecialization	b84c83e868f48d3e	931	931
+OperatorExpression	ownedSubsetting	b84c83e868f48d3e	931	931
 OperatorExpression	ownedTypeFeaturing	0e965a577af286a9	931	0
 OperatorExpression	ownedTyping	0e965a577af286a9	931	0
 OperatorExpression	ownedUnioning	0e965a577af286a9	931	0
@@ -6692,45 +6777,45 @@ OperatorExpression	owningRelationship	c9a7a73556fea81f	931	931
 OperatorExpression	owningType	184c094fbdae7f4e	931	110
 OperatorExpression	parameter	729bf7be46a6af3b	931	931
 OperatorExpression	qualifiedName	c55b67f7dff0d016	931	0
-OperatorExpression	result	711ca624ba9a9560	931	39
+OperatorExpression	result	7485f8a481087150	931	931
 OperatorExpression	shortName	c55b67f7dff0d016	931	0
 OperatorExpression	textualRepresentation	0e965a577af286a9	931	0
 OperatorExpression	type	0e965a577af286a9	931	0
 OperatorExpression	unioningType	0e965a577af286a9	931	0
-OwningMembership	aliasIds	2325a113fc80714e	4567	0
-OwningMembership	declaredName	57a73d82414f132d	4567	0
-OwningMembership	declaredShortName	57a73d82414f132d	4567	0
-OwningMembership	documentation	2325a113fc80714e	4567	0
-OwningMembership	elementId	cd60b6c740d85f94	4567	4567
-OwningMembership	isImplied	92acf88fe348bf57	4567	0
-OwningMembership	isImpliedIncluded	b115fc6959646cb2	4567	4567
-OwningMembership	isLibraryElement	8220fa21e8f944f9	4567	202
-OwningMembership	memberElement	9555d613492e87b2	4567	4567
-OwningMembership	memberElementId	cf951ef8b6c394eb	4567	4567
-OwningMembership	memberName	b0ba9349c5d361b2	4567	2509
-OwningMembership	memberShortName	d91a85a6c1800a21	4567	45
-OwningMembership	membershipOwningNamespace	d025b40c99c7672d	4567	4567
-OwningMembership	name	57a73d82414f132d	4567	0
-OwningMembership	ownedAnnotation	2325a113fc80714e	4567	0
-OwningMembership	ownedElement	2325a113fc80714e	4567	0
-OwningMembership	ownedMemberElement	9555d613492e87b2	4567	4567
-OwningMembership	ownedMemberElementId	cf951ef8b6c394eb	4567	4567
-OwningMembership	ownedMemberName	b0ba9349c5d361b2	4567	2509
-OwningMembership	ownedMemberShortName	d91a85a6c1800a21	4567	45
-OwningMembership	ownedRelatedElement	4508cd9e2e1b8d9a	4567	4567
-OwningMembership	ownedRelationship	2325a113fc80714e	4567	0
-OwningMembership	owner	57a73d82414f132d	4567	0
-OwningMembership	owningMembership	57a73d82414f132d	4567	0
-OwningMembership	owningNamespace	57a73d82414f132d	4567	0
-OwningMembership	owningRelatedElement	d025b40c99c7672d	4567	4567
-OwningMembership	owningRelationship	57a73d82414f132d	4567	0
-OwningMembership	qualifiedName	57a73d82414f132d	4567	0
-OwningMembership	relatedElement	3f3d562c6052500f	4567	4567
-OwningMembership	shortName	57a73d82414f132d	4567	0
-OwningMembership	source	771a6ec19e69b77b	4567	4567
-OwningMembership	target	4508cd9e2e1b8d9a	4567	4567
-OwningMembership	textualRepresentation	2325a113fc80714e	4567	0
-OwningMembership	visibility	50b00c2f3b935f7d	4567	3798
+OwningMembership	aliasIds	88c504996bdef732	6194	0
+OwningMembership	declaredName	97cce838c8a0d6c0	6194	0
+OwningMembership	declaredShortName	97cce838c8a0d6c0	6194	0
+OwningMembership	documentation	88c504996bdef732	6194	0
+OwningMembership	elementId	817f734cfb1d37e0	6194	6194
+OwningMembership	isImplied	d03f9cc0f70337e8	6194	1672
+OwningMembership	isImpliedIncluded	fde9b7fa75eb2f82	6194	6194
+OwningMembership	isLibraryElement	aaf2b63576904042	6194	202
+OwningMembership	memberElement	548f2bf03fa80906	6194	6194
+OwningMembership	memberElementId	fed4e9bc2ead4d1c	6194	6194
+OwningMembership	memberName	50e53315b06eed91	6194	2431
+OwningMembership	memberShortName	1940305d48d1cdb4	6194	45
+OwningMembership	membershipOwningNamespace	8e27eab0335edb92	6194	6194
+OwningMembership	name	97cce838c8a0d6c0	6194	0
+OwningMembership	ownedAnnotation	88c504996bdef732	6194	0
+OwningMembership	ownedElement	88c504996bdef732	6194	0
+OwningMembership	ownedMemberElement	548f2bf03fa80906	6194	6194
+OwningMembership	ownedMemberElementId	fed4e9bc2ead4d1c	6194	6194
+OwningMembership	ownedMemberName	50e53315b06eed91	6194	2431
+OwningMembership	ownedMemberShortName	1940305d48d1cdb4	6194	45
+OwningMembership	ownedRelatedElement	acdf3aba5c9af776	6194	6194
+OwningMembership	ownedRelationship	88c504996bdef732	6194	0
+OwningMembership	owner	97cce838c8a0d6c0	6194	0
+OwningMembership	owningMembership	97cce838c8a0d6c0	6194	0
+OwningMembership	owningNamespace	97cce838c8a0d6c0	6194	0
+OwningMembership	owningRelatedElement	8e27eab0335edb92	6194	6194
+OwningMembership	owningRelationship	97cce838c8a0d6c0	6194	0
+OwningMembership	qualifiedName	97cce838c8a0d6c0	6194	0
+OwningMembership	relatedElement	313c3b2b63a731bc	6194	6194
+OwningMembership	shortName	97cce838c8a0d6c0	6194	0
+OwningMembership	source	a6f42de0edee72ae	6194	6194
+OwningMembership	target	acdf3aba5c9af776	6194	6194
+OwningMembership	textualRepresentation	88c504996bdef732	6194	0
+OwningMembership	visibility	e7df29cdf0d607f0	6194	6194
 Package	aliasIds	2217fc747ddc9e04	473	0
 Package	declaredName	7a374c3e3ae3808b	473	463
 Package	declaredShortName	74a917432c024721	473	0
@@ -6756,43 +6841,43 @@ Package	owningRelationship	bd4bf086e349acb7	473	473
 Package	qualifiedName	bba42356e16d41e7	473	463
 Package	shortName	74a917432c024721	473	0
 Package	textualRepresentation	2217fc747ddc9e04	473	0
-ParameterMembership	aliasIds	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	declaredName	b14524a63016df07	3104	0
-ParameterMembership	declaredShortName	b14524a63016df07	3104	0
-ParameterMembership	documentation	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	elementId	0943963b05dc7c30	3104	3104
-ParameterMembership	isImplied	b8f82c5a68662bc5	3104	0
-ParameterMembership	isImpliedIncluded	a360c09df49c6255	3104	3104
-ParameterMembership	isLibraryElement	93aca2db78047438	3104	23
-ParameterMembership	memberElement	4362c0c8cba71811	3104	3104
-ParameterMembership	memberElementId	665a788822ff273f	3104	3104
-ParameterMembership	memberName	8100886aa344dc4e	3104	280
-ParameterMembership	memberShortName	b14524a63016df07	3104	0
-ParameterMembership	membershipOwningNamespace	1f8f41e5ca9c1978	3104	3104
-ParameterMembership	name	b14524a63016df07	3104	0
-ParameterMembership	ownedAnnotation	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	ownedElement	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	ownedMemberElement	4362c0c8cba71811	3104	3104
-ParameterMembership	ownedMemberElementId	665a788822ff273f	3104	3104
-ParameterMembership	ownedMemberFeature	4362c0c8cba71811	3104	3104
-ParameterMembership	ownedMemberName	fda411b9e1f2fd76	3104	338
-ParameterMembership	ownedMemberParameter	4362c0c8cba71811	3104	3104
-ParameterMembership	ownedMemberShortName	b14524a63016df07	3104	0
-ParameterMembership	ownedRelatedElement	3a26825f9315d679	3104	3104
-ParameterMembership	ownedRelationship	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	owner	b14524a63016df07	3104	0
-ParameterMembership	owningMembership	b14524a63016df07	3104	0
-ParameterMembership	owningNamespace	b14524a63016df07	3104	0
-ParameterMembership	owningRelatedElement	1f8f41e5ca9c1978	3104	3104
-ParameterMembership	owningRelationship	b14524a63016df07	3104	0
-ParameterMembership	owningType	1f8f41e5ca9c1978	3104	3104
-ParameterMembership	qualifiedName	b14524a63016df07	3104	0
-ParameterMembership	relatedElement	4009e0f6c181b012	3104	3104
-ParameterMembership	shortName	b14524a63016df07	3104	0
-ParameterMembership	source	7def3d251b478526	3104	3104
-ParameterMembership	target	3a26825f9315d679	3104	3104
-ParameterMembership	textualRepresentation	20fb09fdfcf0b4e1	3104	0
-ParameterMembership	visibility	89275c136e52c99f	3104	2444
+ParameterMembership	aliasIds	52e976004fd20780	3104	0
+ParameterMembership	declaredName	4865e6d32d87ff48	3104	0
+ParameterMembership	declaredShortName	4865e6d32d87ff48	3104	0
+ParameterMembership	documentation	52e976004fd20780	3104	0
+ParameterMembership	elementId	17bbbb86bd6c2aa8	3104	3104
+ParameterMembership	isImplied	682c229c514a0ba0	3104	0
+ParameterMembership	isImpliedIncluded	a4b4662f16de9ba0	3104	3104
+ParameterMembership	isLibraryElement	42e0991d60e85413	3104	23
+ParameterMembership	memberElement	db5b1d69048e4bc1	3104	3104
+ParameterMembership	memberElementId	d166168dadf97789	3104	3104
+ParameterMembership	memberName	18214a97a0b5fc8f	3104	280
+ParameterMembership	memberShortName	4865e6d32d87ff48	3104	0
+ParameterMembership	membershipOwningNamespace	03274364f463735f	3104	3104
+ParameterMembership	name	4865e6d32d87ff48	3104	0
+ParameterMembership	ownedAnnotation	52e976004fd20780	3104	0
+ParameterMembership	ownedElement	52e976004fd20780	3104	0
+ParameterMembership	ownedMemberElement	db5b1d69048e4bc1	3104	3104
+ParameterMembership	ownedMemberElementId	d166168dadf97789	3104	3104
+ParameterMembership	ownedMemberFeature	db5b1d69048e4bc1	3104	3104
+ParameterMembership	ownedMemberName	bfed33adcf921fd0	3104	590
+ParameterMembership	ownedMemberParameter	db5b1d69048e4bc1	3104	3104
+ParameterMembership	ownedMemberShortName	4865e6d32d87ff48	3104	0
+ParameterMembership	ownedRelatedElement	adea11894c7901ff	3104	3104
+ParameterMembership	ownedRelationship	52e976004fd20780	3104	0
+ParameterMembership	owner	4865e6d32d87ff48	3104	0
+ParameterMembership	owningMembership	4865e6d32d87ff48	3104	0
+ParameterMembership	owningNamespace	4865e6d32d87ff48	3104	0
+ParameterMembership	owningRelatedElement	03274364f463735f	3104	3104
+ParameterMembership	owningRelationship	4865e6d32d87ff48	3104	0
+ParameterMembership	owningType	03274364f463735f	3104	3104
+ParameterMembership	qualifiedName	4865e6d32d87ff48	3104	0
+ParameterMembership	relatedElement	ca644c1de44db248	3104	3104
+ParameterMembership	shortName	4865e6d32d87ff48	3104	0
+ParameterMembership	source	2a5c764484315abd	3104	3104
+ParameterMembership	target	adea11894c7901ff	3104	3104
+ParameterMembership	textualRepresentation	52e976004fd20780	3104	0
+ParameterMembership	visibility	7ddf2b661a363236	3104	3104
 PartDefinition	aliasIds	9c77a1738aa587dd	501	0
 PartDefinition	declaredName	84a01a7ae7ceb3e0	501	501
 PartDefinition	declaredShortName	7181cd23aae50299	501	1
@@ -6812,7 +6897,7 @@ PartDefinition	intersectingType	9c77a1738aa587dd	501	0
 PartDefinition	isAbstract	79c0f5f4a46e2b46	501	10
 PartDefinition	isConjugated	312b6839aa16ab54	501	0
 PartDefinition	isImpliedIncluded	0169eca0f40cd49d	501	501
-PartDefinition	isIndividual	54c60b3734d74904	501	12
+PartDefinition	isIndividual	2c69040e722e8378	501	12
 PartDefinition	isLibraryElement	39403c441589cd9a	501	6
 PartDefinition	isSufficient	312b6839aa16ab54	501	0
 PartDefinition	isVariation	8ff23b270ab06b68	501	4
@@ -6839,9 +6924,9 @@ PartDefinition	ownedEndFeature	9c77a1738aa587dd	501	0
 PartDefinition	ownedEnumeration	9c77a1738aa587dd	501	0
 PartDefinition	ownedFeature	2a212e3423fee9d6	501	219
 PartDefinition	ownedFeatureMembership	14ef076b6f9db76c	501	219
-PartDefinition	ownedFlow	9c77a1738aa587dd	501	0
+PartDefinition	ownedFlow	5cbde8fb959065de	501	3
 PartDefinition	ownedImport	625b8d8cde16e9d4	501	2
-PartDefinition	ownedInterface	16762b1b1a71d18e	501	26
+PartDefinition	ownedInterface	5f7a2c9401a1ea15	501	1
 PartDefinition	ownedIntersecting	9c77a1738aa587dd	501	0
 PartDefinition	ownedItem	e1c5ec2382a2c5ec	501	74
 PartDefinition	ownedMember	772c2f13f7f9d032	501	228
@@ -6851,12 +6936,12 @@ PartDefinition	ownedOccurrence	66ed6b3ebb5bc37a	501	138
 PartDefinition	ownedPart	c87b83fdc1d661e1	501	69
 PartDefinition	ownedPort	eebe36c173fa4b92	501	51
 PartDefinition	ownedReference	16762b1b1a71d18e	501	26
-PartDefinition	ownedRelationship	f9c87fdba988cb3c	501	501
+PartDefinition	ownedRelationship	5026021f25fd8a0f	501	501
 PartDefinition	ownedRendering	9c77a1738aa587dd	501	0
 PartDefinition	ownedRequirement	9c77a1738aa587dd	501	0
-PartDefinition	ownedSpecialization	aadc8047c68c31bc	501	501
+PartDefinition	ownedSpecialization	b1fdbaebab226589	501	501
 PartDefinition	ownedState	93e3695f48bf2377	501	15
-PartDefinition	ownedSubclassification	aadc8047c68c31bc	501	501
+PartDefinition	ownedSubclassification	b1fdbaebab226589	501	501
 PartDefinition	ownedTransition	9c77a1738aa587dd	501	0
 PartDefinition	ownedUnioning	9c77a1738aa587dd	501	0
 PartDefinition	ownedUsage	2a212e3423fee9d6	501	219
@@ -6875,122 +6960,122 @@ PartDefinition	unioningType	9c77a1738aa587dd	501	0
 PartDefinition	usage	2a212e3423fee9d6	501	219
 PartDefinition	variant	14d0e96e4f9bddf8	501	4
 PartDefinition	variantMembership	1d6259f5fa933bd1	501	4
-PartUsage	aliasIds	4db41e2874afe6bd	1083	0
-PartUsage	chainingFeature	4db41e2874afe6bd	1083	0
-PartUsage	crossFeature	9526d1ebaa6b1526	1083	0
-PartUsage	declaredName	28f035b7d0972ede	1083	925
-PartUsage	declaredShortName	cfebcc30956ca5f6	1083	1
-PartUsage	definition	3976896771655cc4	1083	731
-PartUsage	differencingType	4db41e2874afe6bd	1083	0
-PartUsage	directedFeature	3456b4d2276c18b0	1083	6
-PartUsage	directedUsage	3456b4d2276c18b0	1083	6
-PartUsage	direction	43f71700a48420bd	1083	64
-PartUsage	documentation	b014c311c6fcf5ae	1083	8
-PartUsage	elementId	386f6242ad0ef03c	1083	1083
-PartUsage	endFeature	4db41e2874afe6bd	1083	0
-PartUsage	endOwningType	d7eb527bef0c2fb0	1083	2
-PartUsage	feature	4dfb2573949a60ea	1083	554
-PartUsage	featureMembership	82f9458f5bf2f89c	1083	554
-PartUsage	featureTarget	cc7b8cb4f8cb27a9	1083	0
-PartUsage	featuringType	4db41e2874afe6bd	1083	0
-PartUsage	importedMembership	4db41e2874afe6bd	1083	0
-PartUsage	individualDefinition	b07bd83a545062f4	1083	6
-PartUsage	inheritedFeature	4db41e2874afe6bd	1083	0
-PartUsage	inheritedMembership	4db41e2874afe6bd	1083	0
-PartUsage	input	0f266b30b79d3e45	1083	6
-PartUsage	intersectingType	4db41e2874afe6bd	1083	0
-PartUsage	isAbstract	b49fecd1ca4bf1be	1083	24
-PartUsage	isComposite	c1c742630dc06e96	1083	704
-PartUsage	isConjugated	60b4d6c1d2c45ace	1083	0
-PartUsage	isConstant	9d2170c4e70f10a8	1083	2
-PartUsage	isDerived	60b4d6c1d2c45ace	1083	0
-PartUsage	isEnd	9d2170c4e70f10a8	1083	2
-PartUsage	isImpliedIncluded	a98e49541f2e084d	1083	1083
-PartUsage	isIndividual	02052547ec8659fc	1083	6
-PartUsage	isLibraryElement	e058b3abe40ca521	1083	7
-PartUsage	isOrdered	c8a78db4399dd256	1083	8
-PartUsage	isPortion	9526d1ebaa6b1526	1083	0
-PartUsage	isReference	487bddb2e431f485	1083	379
-PartUsage	isSufficient	9526d1ebaa6b1526	1083	0
-PartUsage	isUnique	a98e49541f2e084d	1083	1083
-PartUsage	isVariable	116c067429bc7e90	1083	2
-PartUsage	isVariation	946bf826f01036e4	1083	14
-PartUsage	itemDefinition	d633d180c1e79a47	1083	731
-PartUsage	mayTimeVary	116c067429bc7e90	1083	2
-PartUsage	member	369e5f6378e834d5	1083	805
-PartUsage	membership	f513c98e97e208c2	1083	805
-PartUsage	multiplicity	8622706f03b7eaa6	1083	222
-PartUsage	name	a9ff6e66ff752cb2	1083	1081
-PartUsage	nestedAction	e136c8e8c9af147d	1083	114
-PartUsage	nestedAllocation	0177a4f3b6f2f8c1	1083	2
-PartUsage	nestedAnalysisCase	cc217c0abb26a04a	1083	7
-PartUsage	nestedAttribute	b541e8e39f880554	1083	125
-PartUsage	nestedCalculation	e9151eb165afefef	1083	10
-PartUsage	nestedCase	78a31d1f6991cd7b	1083	9
-PartUsage	nestedConcern	4db41e2874afe6bd	1083	0
-PartUsage	nestedConnection	8186dda48908d005	1083	79
-PartUsage	nestedConstraint	65b75ed3c73bfa90	1083	28
-PartUsage	nestedEnumeration	4db41e2874afe6bd	1083	0
-PartUsage	nestedFlow	4db41e2874afe6bd	1083	0
-PartUsage	nestedInterface	3b29f30e912ef301	1083	31
-PartUsage	nestedItem	081f7c8a1f628663	1083	298
-PartUsage	nestedMetadata	4db41e2874afe6bd	1083	0
-PartUsage	nestedOccurrence	9a955fe98f6a303a	1083	476
-PartUsage	nestedPart	3ed66e26ec3eb955	1083	274
-PartUsage	nestedPort	0bea72864bfef0b2	1083	96
-PartUsage	nestedReference	3b29f30e912ef301	1083	31
-PartUsage	nestedRendering	4db41e2874afe6bd	1083	0
-PartUsage	nestedRequirement	2f5a996b3ef49823	1083	13
-PartUsage	nestedState	f916d9882bef759b	1083	13
-PartUsage	nestedTransition	4db41e2874afe6bd	1083	0
-PartUsage	nestedUsage	4dfb2573949a60ea	1083	554
-PartUsage	nestedUseCase	67bd5634e0e74610	1083	1
-PartUsage	nestedVerificationCase	e02c8730b6e3b49b	1083	1
-PartUsage	nestedView	4db41e2874afe6bd	1083	0
-PartUsage	nestedViewpoint	4db41e2874afe6bd	1083	0
-PartUsage	occurrenceDefinition	f71fe191856121d1	1083	731
-PartUsage	output	ab1f8ae3695e8348	1083	6
-PartUsage	ownedAnnotation	4db41e2874afe6bd	1083	0
-PartUsage	ownedConjugator	9526d1ebaa6b1526	1083	0
-PartUsage	ownedCrossSubsetting	9526d1ebaa6b1526	1083	0
-PartUsage	ownedDifferencing	4db41e2874afe6bd	1083	0
-PartUsage	ownedDisjoining	4db41e2874afe6bd	1083	0
-PartUsage	ownedElement	0088c024127b8e99	1083	805
-PartUsage	ownedEndFeature	4db41e2874afe6bd	1083	0
-PartUsage	ownedFeature	4dfb2573949a60ea	1083	554
-PartUsage	ownedFeatureChaining	4db41e2874afe6bd	1083	0
-PartUsage	ownedFeatureInverting	4db41e2874afe6bd	1083	0
-PartUsage	ownedFeatureMembership	82f9458f5bf2f89c	1083	554
-PartUsage	ownedImport	dcb52109b1747e03	1083	3
-PartUsage	ownedIntersecting	4db41e2874afe6bd	1083	0
-PartUsage	ownedMember	e6e3ddfe397de358	1083	805
-PartUsage	ownedMembership	f513c98e97e208c2	1083	805
-PartUsage	ownedRedefinition	b265df4f01100d25	1083	182
-PartUsage	ownedReferenceSubsetting	9526d1ebaa6b1526	1083	0
-PartUsage	ownedRelationship	7c70c2c707f1fab4	1083	1083
-PartUsage	ownedSpecialization	ce970e61d622dd8d	1083	1083
-PartUsage	ownedSubsetting	f93aac4ace1119ae	1083	1083
-PartUsage	ownedTypeFeaturing	4db41e2874afe6bd	1083	0
-PartUsage	ownedTyping	3e4fc2e2622c418e	1083	538
-PartUsage	ownedUnioning	4db41e2874afe6bd	1083	0
-PartUsage	owner	ffddb225eaebd5d6	1083	1083
-PartUsage	owningDefinition	6fcd6536c0be6ef3	1083	158
-PartUsage	owningFeatureMembership	e21aaac9c3cbb05e	1083	775
-PartUsage	owningMembership	d81a7888ed5c52fe	1083	1083
-PartUsage	owningNamespace	ffddb225eaebd5d6	1083	1083
-PartUsage	owningRelationship	d81a7888ed5c52fe	1083	1083
-PartUsage	owningType	700b1f5f75ecd928	1083	775
-PartUsage	owningUsage	95648c145f997f5b	1083	617
-PartUsage	partDefinition	4df14483ed8ec82c	1083	726
-PartUsage	portionKind	e2d67e0c72f41a62	1083	4
-PartUsage	qualifiedName	c658f0f745e7d799	1083	1078
-PartUsage	shortName	cfebcc30956ca5f6	1083	1
-PartUsage	textualRepresentation	4db41e2874afe6bd	1083	0
-PartUsage	type	3976896771655cc4	1083	731
-PartUsage	unioningType	4db41e2874afe6bd	1083	0
-PartUsage	usage	4dfb2573949a60ea	1083	554
-PartUsage	variant	c62a26347f850646	1083	14
-PartUsage	variantMembership	7261ab67d6d61a3d	1083	14
+PartUsage	aliasIds	8da3e27c1d8ca421	1083	0
+PartUsage	chainingFeature	8da3e27c1d8ca421	1083	0
+PartUsage	crossFeature	2be68388376579d2	1083	0
+PartUsage	declaredName	bfafe7545d91938a	1083	925
+PartUsage	declaredShortName	66ab7dcd22670aa2	1083	1
+PartUsage	definition	9ed1d54c7f818551	1083	737
+PartUsage	differencingType	8da3e27c1d8ca421	1083	0
+PartUsage	directedFeature	74467925d048d614	1083	6
+PartUsage	directedUsage	74467925d048d614	1083	6
+PartUsage	direction	6a1f6963e4ebe9d1	1083	64
+PartUsage	documentation	f00487656fd9b312	1083	8
+PartUsage	elementId	d219333370498c5c	1083	1083
+PartUsage	endFeature	8da3e27c1d8ca421	1083	0
+PartUsage	endOwningType	6eab04187c06945c	1083	2
+PartUsage	feature	bf45eb183f831902	1083	554
+PartUsage	featureMembership	cca50893129d6b47	1083	554
+PartUsage	featureTarget	80f99af50710366d	1083	0
+PartUsage	featuringType	8da3e27c1d8ca421	1083	0
+PartUsage	importedMembership	8da3e27c1d8ca421	1083	0
+PartUsage	individualDefinition	473b89d6e14ac7a0	1083	6
+PartUsage	inheritedFeature	8da3e27c1d8ca421	1083	0
+PartUsage	inheritedMembership	8da3e27c1d8ca421	1083	0
+PartUsage	input	4f162f846079fba9	1083	6
+PartUsage	intersectingType	8da3e27c1d8ca421	1083	0
+PartUsage	isAbstract	1f4416d931d17d4a	1083	24
+PartUsage	isComposite	2c6b6c6a7545fa22	1083	704
+PartUsage	isConjugated	cb5900c93a49e65a	1083	0
+PartUsage	isConstant	07c59acc4e949c34	1083	2
+PartUsage	isDerived	cb5900c93a49e65a	1083	0
+PartUsage	isEnd	07c59acc4e949c34	1083	2
+PartUsage	isImpliedIncluded	237ee58caf828701	1083	1083
+PartUsage	isIndividual	ba426ebea2b0e6f0	1083	6
+PartUsage	isLibraryElement	4afcddb34b9230ad	1083	7
+PartUsage	isOrdered	334bb7bba1235de2	1083	8
+PartUsage	isPortion	cb5900c93a49e65a	1083	0
+PartUsage	isReference	c26c79eb74867339	1083	379
+PartUsage	isSufficient	cb5900c93a49e65a	1083	0
+PartUsage	isUnique	237ee58caf828701	1083	1083
+PartUsage	isVariable	a82bb810b6b6e33c	1083	2
+PartUsage	isVariation	ff10222e5795c270	1083	14
+PartUsage	itemDefinition	3b8f1d65d003c2d4	1083	737
+PartUsage	mayTimeVary	a82bb810b6b6e33c	1083	2
+PartUsage	member	ecc83f04d70368d7	1083	805
+PartUsage	membership	2f295c430be58b85	1083	805
+PartUsage	multiplicity	1ce2220b90b24f52	1083	222
+PartUsage	name	48a94c4a621dd311	1083	1082
+PartUsage	nestedAction	91d7bff6d2a11819	1083	114
+PartUsage	nestedAllocation	416769475fcfb625	1083	2
+PartUsage	nestedAnalysisCase	0c11405e64035dae	1083	7
+PartUsage	nestedAttribute	f531ad374864c2b8	1083	125
+PartUsage	nestedCalculation	2904e3050e8cad53	1083	10
+PartUsage	nestedCase	b892e173126e8adf	1083	9
+PartUsage	nestedConcern	8da3e27c1d8ca421	1083	0
+PartUsage	nestedConnection	c176a1f831e58d69	1083	79
+PartUsage	nestedConstraint	a5a723277018b7f4	1083	28
+PartUsage	nestedEnumeration	8da3e27c1d8ca421	1083	0
+PartUsage	nestedFlow	a46755afa3f3c3a3	1083	22
+PartUsage	nestedInterface	49489c7218fb1b89	1083	15
+PartUsage	nestedItem	480f40ddc83f43c7	1083	298
+PartUsage	nestedMetadata	8da3e27c1d8ca421	1083	0
+PartUsage	nestedOccurrence	11f55f6516a221d2	1083	476
+PartUsage	nestedPart	7ec6327a951b76b9	1083	274
+PartUsage	nestedPort	4bda36d9f4dbae16	1083	96
+PartUsage	nestedReference	7b19b7623a0bb065	1083	31
+PartUsage	nestedRendering	8da3e27c1d8ca421	1083	0
+PartUsage	nestedRequirement	6f4a5dbee7d15587	1083	13
+PartUsage	nestedState	39069ddbd4cc32ff	1083	13
+PartUsage	nestedTransition	8da3e27c1d8ca421	1083	0
+PartUsage	nestedUsage	bf45eb183f831902	1083	554
+PartUsage	nestedUseCase	a7ad1a8889c40374	1083	1
+PartUsage	nestedVerificationCase	201c4b845fc071ff	1083	1
+PartUsage	nestedView	8da3e27c1d8ca421	1083	0
+PartUsage	nestedViewpoint	8da3e27c1d8ca421	1083	0
+PartUsage	occurrenceDefinition	5c7b2d76937d4a5e	1083	737
+PartUsage	output	eb0f4f37123b40ac	1083	6
+PartUsage	ownedAnnotation	8da3e27c1d8ca421	1083	0
+PartUsage	ownedConjugator	2be68388376579d2	1083	0
+PartUsage	ownedCrossSubsetting	2be68388376579d2	1083	0
+PartUsage	ownedDifferencing	8da3e27c1d8ca421	1083	0
+PartUsage	ownedDisjoining	8da3e27c1d8ca421	1083	0
+PartUsage	ownedElement	b6b29fc57096c29b	1083	805
+PartUsage	ownedEndFeature	8da3e27c1d8ca421	1083	0
+PartUsage	ownedFeature	bf45eb183f831902	1083	554
+PartUsage	ownedFeatureChaining	8da3e27c1d8ca421	1083	0
+PartUsage	ownedFeatureInverting	8da3e27c1d8ca421	1083	0
+PartUsage	ownedFeatureMembership	cca50893129d6b47	1083	554
+PartUsage	ownedImport	1ca4e55d5a513b67	1083	3
+PartUsage	ownedIntersecting	8da3e27c1d8ca421	1083	0
+PartUsage	ownedMember	9d0dbd9f9799175a	1083	805
+PartUsage	ownedMembership	2f295c430be58b85	1083	805
+PartUsage	ownedRedefinition	b29872d62a525f32	1083	195
+PartUsage	ownedReferenceSubsetting	2be68388376579d2	1083	0
+PartUsage	ownedRelationship	134956c69bce5016	1083	1083
+PartUsage	ownedSpecialization	9412c9f4f217f68e	1083	1083
+PartUsage	ownedSubsetting	1982f0d25f73d13f	1083	1083
+PartUsage	ownedTypeFeaturing	8da3e27c1d8ca421	1083	0
+PartUsage	ownedTyping	7e3f87360b08fef2	1083	538
+PartUsage	ownedUnioning	8da3e27c1d8ca421	1083	0
+PartUsage	owner	1a889b62380a9007	1083	1083
+PartUsage	owningDefinition	068d16d34db8d39f	1083	158
+PartUsage	owningFeatureMembership	5f5c1ae92627a781	1083	775
+PartUsage	owningMembership	555be8a84fb84a21	1083	1083
+PartUsage	owningNamespace	1a889b62380a9007	1083	1083
+PartUsage	owningRelationship	555be8a84fb84a21	1083	1083
+PartUsage	owningType	8ab6089bc30b9359	1083	775
+PartUsage	owningUsage	b00f7550acb8398c	1083	617
+PartUsage	partDefinition	b34c9068fbaaf0b9	1083	732
+PartUsage	portionKind	79962fa8ffee7f0e	1083	4
+PartUsage	qualifiedName	c3eeb05d110f2b7c	1083	1079
+PartUsage	shortName	66ab7dcd22670aa2	1083	1
+PartUsage	textualRepresentation	8da3e27c1d8ca421	1083	0
+PartUsage	type	9ed1d54c7f818551	1083	737
+PartUsage	unioningType	8da3e27c1d8ca421	1083	0
+PartUsage	usage	bf45eb183f831902	1083	554
+PartUsage	variant	0619ea882861c3aa	1083	14
+PartUsage	variantMembership	b2516fbb7fb2d7a1	1083	14
 PayloadFeature	aliasIds	dd28ff24ddad4d13	48	0
 PayloadFeature	chainingFeature	dd28ff24ddad4d13	48	0
 PayloadFeature	crossFeature	48330bffc17b72d1	48	0
@@ -7012,19 +7097,19 @@ PayloadFeature	inheritedFeature	dd28ff24ddad4d13	48	0
 PayloadFeature	inheritedMembership	dd28ff24ddad4d13	48	0
 PayloadFeature	input	dd28ff24ddad4d13	48	0
 PayloadFeature	intersectingType	dd28ff24ddad4d13	48	0
-PayloadFeature	isAbstract	48330bffc17b72d1	48	0
-PayloadFeature	isComposite	48330bffc17b72d1	48	0
+PayloadFeature	isAbstract	b0366a8bbd30cf27	48	0
+PayloadFeature	isComposite	b0366a8bbd30cf27	48	0
 PayloadFeature	isConjugated	b0366a8bbd30cf27	48	0
-PayloadFeature	isConstant	48330bffc17b72d1	48	0
-PayloadFeature	isDerived	48330bffc17b72d1	48	0
-PayloadFeature	isEnd	48330bffc17b72d1	48	0
+PayloadFeature	isConstant	b0366a8bbd30cf27	48	0
+PayloadFeature	isDerived	b0366a8bbd30cf27	48	0
+PayloadFeature	isEnd	b0366a8bbd30cf27	48	0
 PayloadFeature	isImpliedIncluded	36855aff8e9e0e07	48	48
 PayloadFeature	isLibraryElement	b0366a8bbd30cf27	48	0
-PayloadFeature	isOrdered	48330bffc17b72d1	48	0
-PayloadFeature	isPortion	48330bffc17b72d1	48	0
-PayloadFeature	isSufficient	48330bffc17b72d1	48	0
-PayloadFeature	isUnique	48330bffc17b72d1	48	0
-PayloadFeature	isVariable	48330bffc17b72d1	48	0
+PayloadFeature	isOrdered	b0366a8bbd30cf27	48	0
+PayloadFeature	isPortion	b0366a8bbd30cf27	48	0
+PayloadFeature	isSufficient	b0366a8bbd30cf27	48	0
+PayloadFeature	isUnique	36855aff8e9e0e07	48	48
+PayloadFeature	isVariable	b0366a8bbd30cf27	48	0
 PayloadFeature	member	90273a846b1c45a0	48	10
 PayloadFeature	membership	a1f3d64479f76941	48	10
 PayloadFeature	multiplicity	1af1961bed861163	48	9
@@ -7047,9 +7132,9 @@ PayloadFeature	ownedMember	90273a846b1c45a0	48	10
 PayloadFeature	ownedMembership	a1f3d64479f76941	48	10
 PayloadFeature	ownedRedefinition	dd28ff24ddad4d13	48	0
 PayloadFeature	ownedReferenceSubsetting	48330bffc17b72d1	48	0
-PayloadFeature	ownedRelationship	3f33d7297555c1be	48	48
-PayloadFeature	ownedSpecialization	407b4579272ea4da	48	48
-PayloadFeature	ownedSubsetting	dd28ff24ddad4d13	48	0
+PayloadFeature	ownedRelationship	37d8c38a7910ac33	48	48
+PayloadFeature	ownedSpecialization	c1323e6479495c4d	48	48
+PayloadFeature	ownedSubsetting	db241866c7a30122	48	48
 PayloadFeature	ownedTypeFeaturing	dd28ff24ddad4d13	48	0
 PayloadFeature	ownedTyping	407b4579272ea4da	48	48
 PayloadFeature	ownedUnioning	dd28ff24ddad4d13	48	0
@@ -7064,125 +7149,125 @@ PayloadFeature	shortName	48330bffc17b72d1	48	0
 PayloadFeature	textualRepresentation	dd28ff24ddad4d13	48	0
 PayloadFeature	type	2e3d7e6c7453ecb9	48	48
 PayloadFeature	unioningType	dd28ff24ddad4d13	48	0
-PerformActionUsage	actionDefinition	f46eaaea37765a1b	153	59
-PerformActionUsage	aliasIds	240b0155f6d100c0	153	0
-PerformActionUsage	behavior	f46eaaea37765a1b	153	59
-PerformActionUsage	chainingFeature	240b0155f6d100c0	153	0
-PerformActionUsage	crossFeature	0fba2e9807953621	153	0
-PerformActionUsage	declaredName	24cdcb6d6b5276cf	153	51
-PerformActionUsage	declaredShortName	0fba2e9807953621	153	0
-PerformActionUsage	definition	f46eaaea37765a1b	153	59
-PerformActionUsage	differencingType	240b0155f6d100c0	153	0
-PerformActionUsage	directedFeature	8abbc347b49fb008	153	25
-PerformActionUsage	directedUsage	8abbc347b49fb008	153	25
-PerformActionUsage	direction	0fba2e9807953621	153	0
-PerformActionUsage	documentation	0ef8b9ae9feb66d9	153	4
-PerformActionUsage	elementId	955d9f24f38b87b8	153	153
-PerformActionUsage	endFeature	240b0155f6d100c0	153	0
-PerformActionUsage	endOwningType	0fba2e9807953621	153	0
-PerformActionUsage	eventOccurrence	02c706c75ec61168	153	96
-PerformActionUsage	feature	2e8f856a3b00f91c	153	40
-PerformActionUsage	featureMembership	6d81a8c87e33c73c	153	40
-PerformActionUsage	featureTarget	b6308601882d85e5	153	0
-PerformActionUsage	featuringType	240b0155f6d100c0	153	0
-PerformActionUsage	importedMembership	240b0155f6d100c0	153	0
-PerformActionUsage	individualDefinition	0fba2e9807953621	153	0
-PerformActionUsage	inheritedFeature	240b0155f6d100c0	153	0
-PerformActionUsage	inheritedMembership	240b0155f6d100c0	153	0
-PerformActionUsage	input	15161493621878c9	153	20
-PerformActionUsage	intersectingType	240b0155f6d100c0	153	0
-PerformActionUsage	isAbstract	f67e936d5f55da1c	153	1
-PerformActionUsage	isComposite	5ad8aa497247c997	153	0
-PerformActionUsage	isConjugated	5ad8aa497247c997	153	0
-PerformActionUsage	isConstant	5ad8aa497247c997	153	0
-PerformActionUsage	isDerived	5ad8aa497247c997	153	0
-PerformActionUsage	isEnd	5ad8aa497247c997	153	0
-PerformActionUsage	isImpliedIncluded	fef814ed260a0b34	153	153
-PerformActionUsage	isIndividual	0fba2e9807953621	153	0
-PerformActionUsage	isLibraryElement	5ad8aa497247c997	153	0
-PerformActionUsage	isOrdered	c299bac7c336abac	153	1
-PerformActionUsage	isPortion	0fba2e9807953621	153	0
-PerformActionUsage	isReference	fef814ed260a0b34	153	153
-PerformActionUsage	isSufficient	0fba2e9807953621	153	0
-PerformActionUsage	isUnique	fef814ed260a0b34	153	153
-PerformActionUsage	isVariable	0fba2e9807953621	153	0
-PerformActionUsage	isVariation	f67e936d5f55da1c	153	1
-PerformActionUsage	mayTimeVary	0fba2e9807953621	153	0
-PerformActionUsage	member	35dce1e575235702	153	51
-PerformActionUsage	membership	6f2b7e1842b0ef26	153	51
-PerformActionUsage	multiplicity	3c4ffbbdb26751f5	153	2
-PerformActionUsage	name	b300f61d198b8e8b	153	151
-PerformActionUsage	nestedAction	2f799a567f106c3c	153	15
-PerformActionUsage	nestedAllocation	240b0155f6d100c0	153	0
-PerformActionUsage	nestedAnalysisCase	240b0155f6d100c0	153	0
-PerformActionUsage	nestedAttribute	240b0155f6d100c0	153	0
-PerformActionUsage	nestedCalculation	240b0155f6d100c0	153	0
-PerformActionUsage	nestedCase	240b0155f6d100c0	153	0
-PerformActionUsage	nestedConcern	240b0155f6d100c0	153	0
-PerformActionUsage	nestedConnection	30706bcc950fa87b	153	10
-PerformActionUsage	nestedConstraint	240b0155f6d100c0	153	0
-PerformActionUsage	nestedEnumeration	240b0155f6d100c0	153	0
-PerformActionUsage	nestedFlow	240b0155f6d100c0	153	0
-PerformActionUsage	nestedInterface	2e1fad956117f0a7	153	22
-PerformActionUsage	nestedItem	c71043dd4d96907b	153	3
-PerformActionUsage	nestedMetadata	240b0155f6d100c0	153	0
-PerformActionUsage	nestedOccurrence	4256a8e33b72e987	153	20
-PerformActionUsage	nestedPart	c71043dd4d96907b	153	3
-PerformActionUsage	nestedPort	240b0155f6d100c0	153	0
-PerformActionUsage	nestedReference	2e1fad956117f0a7	153	22
-PerformActionUsage	nestedRendering	240b0155f6d100c0	153	0
-PerformActionUsage	nestedRequirement	240b0155f6d100c0	153	0
-PerformActionUsage	nestedState	240b0155f6d100c0	153	0
-PerformActionUsage	nestedTransition	71cbb2fd71f3a756	153	2
-PerformActionUsage	nestedUsage	2e8f856a3b00f91c	153	40
-PerformActionUsage	nestedUseCase	240b0155f6d100c0	153	0
-PerformActionUsage	nestedVerificationCase	240b0155f6d100c0	153	0
-PerformActionUsage	nestedView	240b0155f6d100c0	153	0
-PerformActionUsage	nestedViewpoint	240b0155f6d100c0	153	0
-PerformActionUsage	occurrenceDefinition	f46eaaea37765a1b	153	59
-PerformActionUsage	output	64eee948ea9af997	153	14
-PerformActionUsage	ownedAnnotation	240b0155f6d100c0	153	0
-PerformActionUsage	ownedConjugator	0fba2e9807953621	153	0
-PerformActionUsage	ownedCrossSubsetting	0fba2e9807953621	153	0
-PerformActionUsage	ownedDifferencing	240b0155f6d100c0	153	0
-PerformActionUsage	ownedDisjoining	240b0155f6d100c0	153	0
-PerformActionUsage	ownedElement	9a1e1847b48f5180	153	96
-PerformActionUsage	ownedEndFeature	240b0155f6d100c0	153	0
-PerformActionUsage	ownedFeature	2e8f856a3b00f91c	153	40
-PerformActionUsage	ownedFeatureChaining	240b0155f6d100c0	153	0
-PerformActionUsage	ownedFeatureInverting	240b0155f6d100c0	153	0
-PerformActionUsage	ownedFeatureMembership	6d81a8c87e33c73c	153	40
-PerformActionUsage	ownedImport	240b0155f6d100c0	153	0
-PerformActionUsage	ownedIntersecting	240b0155f6d100c0	153	0
-PerformActionUsage	ownedMember	50de368cf7043a9b	153	51
-PerformActionUsage	ownedMembership	6f2b7e1842b0ef26	153	51
-PerformActionUsage	ownedRedefinition	0730af9b27de399c	153	18
-PerformActionUsage	ownedReferenceSubsetting	5c86dcc795352686	153	96
-PerformActionUsage	ownedRelationship	0037adfba5e173f8	153	153
-PerformActionUsage	ownedSpecialization	cb6276174854b580	153	153
-PerformActionUsage	ownedSubsetting	3af2e13db816c4cb	153	153
-PerformActionUsage	ownedTypeFeaturing	240b0155f6d100c0	153	0
-PerformActionUsage	ownedTyping	a5c6f21c43228b7f	153	9
-PerformActionUsage	ownedUnioning	240b0155f6d100c0	153	0
-PerformActionUsage	owner	0ff854039c790201	153	153
-PerformActionUsage	owningDefinition	f534032cdff15b19	153	18
-PerformActionUsage	owningFeatureMembership	69beb3e9851046c8	153	151
-PerformActionUsage	owningMembership	be80859ef3ec51d9	153	153
-PerformActionUsage	owningNamespace	0ff854039c790201	153	153
-PerformActionUsage	owningRelationship	be80859ef3ec51d9	153	153
-PerformActionUsage	owningType	0d2d57b9b335323d	153	151
-PerformActionUsage	owningUsage	27b38324dad90d45	153	133
-PerformActionUsage	parameter	8abbc347b49fb008	153	25
-PerformActionUsage	performedAction	02c706c75ec61168	153	96
-PerformActionUsage	portionKind	0fba2e9807953621	153	0
-PerformActionUsage	qualifiedName	19c53dc022b0d77f	153	147
-PerformActionUsage	shortName	0fba2e9807953621	153	0
-PerformActionUsage	textualRepresentation	240b0155f6d100c0	153	0
-PerformActionUsage	type	f46eaaea37765a1b	153	59
-PerformActionUsage	unioningType	240b0155f6d100c0	153	0
-PerformActionUsage	usage	2e8f856a3b00f91c	153	40
-PerformActionUsage	variant	52463f91ef678fce	153	1
-PerformActionUsage	variantMembership	7ad7e71beb72d113	153	1
+PerformActionUsage	actionDefinition	65667c762095bc43	153	59
+PerformActionUsage	aliasIds	d7c8b438baced676	153	0
+PerformActionUsage	behavior	65667c762095bc43	153	59
+PerformActionUsage	chainingFeature	d7c8b438baced676	153	0
+PerformActionUsage	crossFeature	8d23e978bddb7a5f	153	0
+PerformActionUsage	declaredName	a237864e2198bb0d	153	51
+PerformActionUsage	declaredShortName	8d23e978bddb7a5f	153	0
+PerformActionUsage	definition	65667c762095bc43	153	59
+PerformActionUsage	differencingType	d7c8b438baced676	153	0
+PerformActionUsage	directedFeature	c7ad91b9c82b22a3	153	25
+PerformActionUsage	directedUsage	c7ad91b9c82b22a3	153	25
+PerformActionUsage	direction	8d23e978bddb7a5f	153	0
+PerformActionUsage	documentation	c2b66c9163e93c8f	153	4
+PerformActionUsage	elementId	083ab859c423b4c0	153	153
+PerformActionUsage	endFeature	d7c8b438baced676	153	0
+PerformActionUsage	endOwningType	8d23e978bddb7a5f	153	0
+PerformActionUsage	eventOccurrence	f9dfcb18db5f8f32	153	96
+PerformActionUsage	feature	2ae8baf4cb056011	153	40
+PerformActionUsage	featureMembership	dafa94190206a856	153	40
+PerformActionUsage	featureTarget	6fad2464d2a453f1	153	0
+PerformActionUsage	featuringType	d7c8b438baced676	153	0
+PerformActionUsage	importedMembership	d7c8b438baced676	153	0
+PerformActionUsage	individualDefinition	8d23e978bddb7a5f	153	0
+PerformActionUsage	inheritedFeature	d7c8b438baced676	153	0
+PerformActionUsage	inheritedMembership	d7c8b438baced676	153	0
+PerformActionUsage	input	98154c97342dfebe	153	20
+PerformActionUsage	intersectingType	d7c8b438baced676	153	0
+PerformActionUsage	isAbstract	329000eacc9417d2	153	1
+PerformActionUsage	isComposite	96ea17c6df86074d	153	0
+PerformActionUsage	isConjugated	96ea17c6df86074d	153	0
+PerformActionUsage	isConstant	96ea17c6df86074d	153	0
+PerformActionUsage	isDerived	96ea17c6df86074d	153	0
+PerformActionUsage	isEnd	96ea17c6df86074d	153	0
+PerformActionUsage	isImpliedIncluded	8a04921820812e8a	153	153
+PerformActionUsage	isIndividual	96ea17c6df86074d	153	0
+PerformActionUsage	isLibraryElement	96ea17c6df86074d	153	0
+PerformActionUsage	isOrdered	feab28453074e962	153	1
+PerformActionUsage	isPortion	96ea17c6df86074d	153	0
+PerformActionUsage	isReference	8a04921820812e8a	153	153
+PerformActionUsage	isSufficient	96ea17c6df86074d	153	0
+PerformActionUsage	isUnique	8a04921820812e8a	153	153
+PerformActionUsage	isVariable	8d23e978bddb7a5f	153	0
+PerformActionUsage	isVariation	329000eacc9417d2	153	1
+PerformActionUsage	mayTimeVary	8d23e978bddb7a5f	153	0
+PerformActionUsage	member	74ab3b5885166872	153	51
+PerformActionUsage	membership	e25c209e0c9ae073	153	51
+PerformActionUsage	multiplicity	b9b9b69e68ad9633	153	2
+PerformActionUsage	name	3dc43c38a65be3a1	153	151
+PerformActionUsage	nestedAction	e3374d39430e41f2	153	15
+PerformActionUsage	nestedAllocation	d7c8b438baced676	153	0
+PerformActionUsage	nestedAnalysisCase	d7c8b438baced676	153	0
+PerformActionUsage	nestedAttribute	d7c8b438baced676	153	0
+PerformActionUsage	nestedCalculation	d7c8b438baced676	153	0
+PerformActionUsage	nestedCase	d7c8b438baced676	153	0
+PerformActionUsage	nestedConcern	d7c8b438baced676	153	0
+PerformActionUsage	nestedConnection	e42e1eaf590d7e31	153	10
+PerformActionUsage	nestedConstraint	d7c8b438baced676	153	0
+PerformActionUsage	nestedEnumeration	d7c8b438baced676	153	0
+PerformActionUsage	nestedFlow	19abce7bf673306f	153	2
+PerformActionUsage	nestedInterface	d7c8b438baced676	153	0
+PerformActionUsage	nestedItem	fd05b7d5bca575e7	153	3
+PerformActionUsage	nestedMetadata	d7c8b438baced676	153	0
+PerformActionUsage	nestedOccurrence	784c1cdbaa81cef3	153	20
+PerformActionUsage	nestedPart	fd05b7d5bca575e7	153	3
+PerformActionUsage	nestedPort	d7c8b438baced676	153	0
+PerformActionUsage	nestedReference	11318821ce4f8e48	153	22
+PerformActionUsage	nestedRendering	d7c8b438baced676	153	0
+PerformActionUsage	nestedRequirement	d7c8b438baced676	153	0
+PerformActionUsage	nestedState	d7c8b438baced676	153	0
+PerformActionUsage	nestedTransition	258965e035f17d0c	153	2
+PerformActionUsage	nestedUsage	2ae8baf4cb056011	153	40
+PerformActionUsage	nestedUseCase	d7c8b438baced676	153	0
+PerformActionUsage	nestedVerificationCase	d7c8b438baced676	153	0
+PerformActionUsage	nestedView	d7c8b438baced676	153	0
+PerformActionUsage	nestedViewpoint	d7c8b438baced676	153	0
+PerformActionUsage	occurrenceDefinition	65667c762095bc43	153	59
+PerformActionUsage	output	3be74cabed4f714f	153	14
+PerformActionUsage	ownedAnnotation	d7c8b438baced676	153	0
+PerformActionUsage	ownedConjugator	8d23e978bddb7a5f	153	0
+PerformActionUsage	ownedCrossSubsetting	8d23e978bddb7a5f	153	0
+PerformActionUsage	ownedDifferencing	d7c8b438baced676	153	0
+PerformActionUsage	ownedDisjoining	d7c8b438baced676	153	0
+PerformActionUsage	ownedElement	55b38f76e1761383	153	96
+PerformActionUsage	ownedEndFeature	d7c8b438baced676	153	0
+PerformActionUsage	ownedFeature	2ae8baf4cb056011	153	40
+PerformActionUsage	ownedFeatureChaining	d7c8b438baced676	153	0
+PerformActionUsage	ownedFeatureInverting	d7c8b438baced676	153	0
+PerformActionUsage	ownedFeatureMembership	dafa94190206a856	153	40
+PerformActionUsage	ownedImport	d7c8b438baced676	153	0
+PerformActionUsage	ownedIntersecting	d7c8b438baced676	153	0
+PerformActionUsage	ownedMember	8fac900006f74c0b	153	51
+PerformActionUsage	ownedMembership	e25c209e0c9ae073	153	51
+PerformActionUsage	ownedRedefinition	654a5b36b4f606d8	153	18
+PerformActionUsage	ownedReferenceSubsetting	57068ce7f79c3aea	153	96
+PerformActionUsage	ownedRelationship	3a832b654dc2e199	153	153
+PerformActionUsage	ownedSpecialization	3a7a6296dc6c7cd8	153	153
+PerformActionUsage	ownedSubsetting	aa0acdbd4c2e8c23	153	153
+PerformActionUsage	ownedTypeFeaturing	d7c8b438baced676	153	0
+PerformActionUsage	ownedTyping	5984a4ff07206135	153	9
+PerformActionUsage	ownedUnioning	d7c8b438baced676	153	0
+PerformActionUsage	owner	dc34815a7ac1a0df	153	153
+PerformActionUsage	owningDefinition	d358e0581c666dc7	153	18
+PerformActionUsage	owningFeatureMembership	fb49767df8159bad	153	151
+PerformActionUsage	owningMembership	500b483366f1a6be	153	153
+PerformActionUsage	owningNamespace	dc34815a7ac1a0df	153	153
+PerformActionUsage	owningRelationship	500b483366f1a6be	153	153
+PerformActionUsage	owningType	d9698510917dd11b	153	151
+PerformActionUsage	owningUsage	93348e3132f2ddb3	153	133
+PerformActionUsage	parameter	c7ad91b9c82b22a3	153	25
+PerformActionUsage	performedAction	f9dfcb18db5f8f32	153	96
+PerformActionUsage	portionKind	8d23e978bddb7a5f	153	0
+PerformActionUsage	qualifiedName	26b8a52cc3012545	153	147
+PerformActionUsage	shortName	8d23e978bddb7a5f	153	0
+PerformActionUsage	textualRepresentation	d7c8b438baced676	153	0
+PerformActionUsage	type	65667c762095bc43	153	59
+PerformActionUsage	unioningType	d7c8b438baced676	153	0
+PerformActionUsage	usage	2ae8baf4cb056011	153	40
+PerformActionUsage	variant	0603f274b3656584	153	1
+PerformActionUsage	variantMembership	2e9599feaf70a6c9	153	1
 PortConjugation	aliasIds	a090dea588dcd8bd	91	0
 PortConjugation	conjugatedPortDefinition	5fa280f4d6befdc9	91	91
 PortConjugation	conjugatedType	5fa280f4d6befdc9	91	91
@@ -7232,7 +7317,7 @@ PortDefinition	intersectingType	6f20e08b58daa1f6	91	0
 PortDefinition	isAbstract	8c454c6d8aa73be3	91	0
 PortDefinition	isConjugated	8c454c6d8aa73be3	91	0
 PortDefinition	isImpliedIncluded	b7afe0333ce83c62	91	91
-PortDefinition	isIndividual	9a9bc8fe57c25ded	91	0
+PortDefinition	isIndividual	8c454c6d8aa73be3	91	0
 PortDefinition	isLibraryElement	1adff28f94ed90c6	91	7
 PortDefinition	isSufficient	8c454c6d8aa73be3	91	0
 PortDefinition	isVariation	8c454c6d8aa73be3	91	0
@@ -7261,7 +7346,7 @@ PortDefinition	ownedFeature	7c54cfd0441d2884	91	35
 PortDefinition	ownedFeatureMembership	d390bd1991680821	91	35
 PortDefinition	ownedFlow	6f20e08b58daa1f6	91	0
 PortDefinition	ownedImport	6f20e08b58daa1f6	91	0
-PortDefinition	ownedInterface	a98e49aa874b3b79	91	13
+PortDefinition	ownedInterface	6f20e08b58daa1f6	91	0
 PortDefinition	ownedIntersecting	6f20e08b58daa1f6	91	0
 PortDefinition	ownedItem	06b287ee2eb70e22	91	12
 PortDefinition	ownedMember	9e04a43d46fdb8da	91	91
@@ -7271,12 +7356,12 @@ PortDefinition	ownedOccurrence	9074e4d2d2a31c7b	91	18
 PortDefinition	ownedPart	6f20e08b58daa1f6	91	0
 PortDefinition	ownedPort	f8e33d6ffcc6b04f	91	6
 PortDefinition	ownedReference	a98e49aa874b3b79	91	13
-PortDefinition	ownedRelationship	c8858d35f2bd9cb1	91	91
+PortDefinition	ownedRelationship	ca07b0cec3e31e71	91	91
 PortDefinition	ownedRendering	6f20e08b58daa1f6	91	0
 PortDefinition	ownedRequirement	6f20e08b58daa1f6	91	0
-PortDefinition	ownedSpecialization	13fbb04a6bab5bcd	91	91
+PortDefinition	ownedSpecialization	ae3bb8e8134728a3	91	91
 PortDefinition	ownedState	6f20e08b58daa1f6	91	0
-PortDefinition	ownedSubclassification	13fbb04a6bab5bcd	91	91
+PortDefinition	ownedSubclassification	ae3bb8e8134728a3	91	91
 PortDefinition	ownedTransition	6f20e08b58daa1f6	91	0
 PortDefinition	ownedUnioning	6f20e08b58daa1f6	91	0
 PortDefinition	ownedUsage	7c54cfd0441d2884	91	35
@@ -7300,7 +7385,7 @@ PortUsage	chainingFeature	006f585500af6d8e	365	0
 PortUsage	crossFeature	6c773ae1772df27b	365	0
 PortUsage	declaredName	21e057f7aa9ac310	365	268
 PortUsage	declaredShortName	6c773ae1772df27b	365	0
-PortUsage	definition	e520de610ca5a77d	365	305
+PortUsage	definition	c721c2976dcc31b4	365	311
 PortUsage	differencingType	006f585500af6d8e	365	0
 PortUsage	directedFeature	de1fc5db42249bdd	365	36
 PortUsage	directedUsage	de1fc5db42249bdd	365	36
@@ -7319,27 +7404,27 @@ PortUsage	inheritedFeature	006f585500af6d8e	365	0
 PortUsage	inheritedMembership	006f585500af6d8e	365	0
 PortUsage	input	a8447d64df6c54c8	365	25
 PortUsage	intersectingType	006f585500af6d8e	365	0
-PortUsage	isAbstract	226be4e7317218e2	365	1
+PortUsage	isAbstract	04c730ae9b2c2a3e	365	1
 PortUsage	isComposite	3b1c20ef2e1066a0	365	35
 PortUsage	isConjugated	d10223e08220b669	365	0
 PortUsage	isConstant	35cd9f99e94ff617	365	118
-PortUsage	isDerived	eea6d8191866a50d	365	0
+PortUsage	isDerived	d10223e08220b669	365	0
 PortUsage	isEnd	35cd9f99e94ff617	365	118
 PortUsage	isImpliedIncluded	a18614943a8fc24a	365	365
-PortUsage	isIndividual	6c773ae1772df27b	365	0
+PortUsage	isIndividual	d10223e08220b669	365	0
 PortUsage	isLibraryElement	08d8e141b557da92	365	5
-PortUsage	isOrdered	eea6d8191866a50d	365	0
-PortUsage	isPortion	6c773ae1772df27b	365	0
+PortUsage	isOrdered	d10223e08220b669	365	0
+PortUsage	isPortion	d10223e08220b669	365	0
 PortUsage	isReference	376c17858ea01213	365	330
-PortUsage	isSufficient	6c773ae1772df27b	365	0
-PortUsage	isUnique	a03ac45a99c6bf5a	365	289
+PortUsage	isSufficient	d10223e08220b669	365	0
+PortUsage	isUnique	a18614943a8fc24a	365	365
 PortUsage	isVariable	df75e84e5ae24913	365	118
 PortUsage	isVariation	04c730ae9b2c2a3e	365	1
 PortUsage	mayTimeVary	df75e84e5ae24913	365	118
 PortUsage	member	a186dd91888a88f5	365	111
 PortUsage	membership	f5606ac29f27c31b	365	111
 PortUsage	multiplicity	ffe2cf723ac25b90	365	34
-PortUsage	name	646a4e3caf4ee6f2	365	364
+PortUsage	name	239f9bc0d44dbbe0	365	364
 PortUsage	nestedAction	006f585500af6d8e	365	0
 PortUsage	nestedAllocation	006f585500af6d8e	365	0
 PortUsage	nestedAnalysisCase	006f585500af6d8e	365	0
@@ -7351,7 +7436,7 @@ PortUsage	nestedConnection	5684e961c68301fc	365	1
 PortUsage	nestedConstraint	006f585500af6d8e	365	0
 PortUsage	nestedEnumeration	006f585500af6d8e	365	0
 PortUsage	nestedFlow	006f585500af6d8e	365	0
-PortUsage	nestedInterface	64496cdae7fd8a9c	365	30
+PortUsage	nestedInterface	006f585500af6d8e	365	0
 PortUsage	nestedItem	cccf5d5f96a2096c	365	5
 PortUsage	nestedMetadata	006f585500af6d8e	365	0
 PortUsage	nestedOccurrence	144b6c89b9624366	365	37
@@ -7367,7 +7452,7 @@ PortUsage	nestedUseCase	006f585500af6d8e	365	0
 PortUsage	nestedVerificationCase	006f585500af6d8e	365	0
 PortUsage	nestedView	006f585500af6d8e	365	0
 PortUsage	nestedViewpoint	006f585500af6d8e	365	0
-PortUsage	occurrenceDefinition	e520de610ca5a77d	365	305
+PortUsage	occurrenceDefinition	c721c2976dcc31b4	365	311
 PortUsage	output	38dc7e163e235999	365	19
 PortUsage	ownedAnnotation	006f585500af6d8e	365	0
 PortUsage	ownedConjugator	6c773ae1772df27b	365	0
@@ -7384,11 +7469,11 @@ PortUsage	ownedImport	006f585500af6d8e	365	0
 PortUsage	ownedIntersecting	006f585500af6d8e	365	0
 PortUsage	ownedMember	a186dd91888a88f5	365	111
 PortUsage	ownedMembership	f5606ac29f27c31b	365	111
-PortUsage	ownedRedefinition	c77287fe50a15471	365	67
+PortUsage	ownedRedefinition	179f6fa020cc85e9	365	177
 PortUsage	ownedReferenceSubsetting	879d0b34d085f8b9	365	80
-PortUsage	ownedRelationship	40e4d7dd7260f688	365	365
-PortUsage	ownedSpecialization	44ac2aae675fb875	365	365
-PortUsage	ownedSubsetting	c0163a71ffeb116b	365	365
+PortUsage	ownedRelationship	227cacd91a052a65	365	365
+PortUsage	ownedSpecialization	aecf23916e319e16	365	365
+PortUsage	ownedSubsetting	86c484f19b98eccc	365	365
 PortUsage	ownedTypeFeaturing	006f585500af6d8e	365	0
 PortUsage	ownedTyping	585a89a6a2726384	365	185
 PortUsage	ownedUnioning	006f585500af6d8e	365	0
@@ -7400,190 +7485,190 @@ PortUsage	owningNamespace	c61d32e3533e42ef	365	365
 PortUsage	owningRelationship	06250d4df2c84205	365	365
 PortUsage	owningType	e340a8bc40899bc5	365	361
 PortUsage	owningUsage	3596e0fdd86c48fa	365	241
-PortUsage	portDefinition	e520de610ca5a77d	365	305
+PortUsage	portDefinition	c721c2976dcc31b4	365	311
 PortUsage	portionKind	6c773ae1772df27b	365	0
-PortUsage	qualifiedName	5dd552ad24dbe4e3	365	342
+PortUsage	qualifiedName	8a3e76f50daccc4c	365	341
 PortUsage	shortName	6c773ae1772df27b	365	0
 PortUsage	textualRepresentation	006f585500af6d8e	365	0
-PortUsage	type	e520de610ca5a77d	365	305
+PortUsage	type	c721c2976dcc31b4	365	311
 PortUsage	unioningType	006f585500af6d8e	365	0
 PortUsage	usage	61727fee7204e7cb	365	70
 PortUsage	variant	ef618121b171b03c	365	1
 PortUsage	variantMembership	0e2e60d8ff28354d	365	1
-Redefinition	aliasIds	b14afcd20400b321	1304	0
-Redefinition	declaredName	494d8946e1d7e57f	1304	0
-Redefinition	declaredShortName	494d8946e1d7e57f	1304	0
-Redefinition	documentation	b14afcd20400b321	1304	0
-Redefinition	elementId	fc71d187a6116fdc	1304	1304
-Redefinition	general	321d69595f5f4bbf	1304	1304
-Redefinition	isImplied	df68572e01aea7dd	1304	0
-Redefinition	isImpliedIncluded	32966bb3325292c5	1304	1304
-Redefinition	isLibraryElement	daa9f48a757b85e0	1304	39
-Redefinition	name	494d8946e1d7e57f	1304	0
-Redefinition	ownedAnnotation	b14afcd20400b321	1304	0
-Redefinition	ownedElement	5b7b39d8ff36ba86	1304	24
-Redefinition	ownedRelatedElement	b4bfca2c38834c99	1304	6
-Redefinition	ownedRelationship	9f47c4843fe03885	1304	24
-Redefinition	owner	494d8946e1d7e57f	1304	0
-Redefinition	owningFeature	ed0f2030db69f7a8	1304	1304
-Redefinition	owningMembership	494d8946e1d7e57f	1304	0
-Redefinition	owningNamespace	494d8946e1d7e57f	1304	0
-Redefinition	owningRelatedElement	ed0f2030db69f7a8	1304	1304
-Redefinition	owningRelationship	494d8946e1d7e57f	1304	0
-Redefinition	owningType	ed0f2030db69f7a8	1304	1304
-Redefinition	qualifiedName	494d8946e1d7e57f	1304	0
-Redefinition	redefinedFeature	321d69595f5f4bbf	1304	1304
-Redefinition	redefiningFeature	ed0f2030db69f7a8	1304	1304
-Redefinition	relatedElement	2f50dc03373f9308	1304	1304
-Redefinition	shortName	494d8946e1d7e57f	1304	0
-Redefinition	source	8d505ac0bd7d87e2	1304	1304
-Redefinition	specific	ed0f2030db69f7a8	1304	1304
-Redefinition	subsettedFeature	321d69595f5f4bbf	1304	1304
-Redefinition	subsettingFeature	ed0f2030db69f7a8	1304	1304
-Redefinition	target	11a6a56632d9cf4f	1304	1304
-Redefinition	textualRepresentation	5b7b39d8ff36ba86	1304	24
-ReferenceSubsetting	aliasIds	7c8932dd086c471b	1164	0
-ReferenceSubsetting	declaredName	2bce54be67db2b25	1164	0
-ReferenceSubsetting	declaredShortName	2bce54be67db2b25	1164	0
-ReferenceSubsetting	documentation	7c8932dd086c471b	1164	0
-ReferenceSubsetting	elementId	786f03f006215d18	1164	1164
-ReferenceSubsetting	general	fcb6c4c1ae75be5a	1164	1164
-ReferenceSubsetting	isImplied	bc0260da9cc7cacb	1164	0
-ReferenceSubsetting	isImpliedIncluded	8c63431cbd9f7e4f	1164	1164
-ReferenceSubsetting	isLibraryElement	bc0260da9cc7cacb	1164	0
-ReferenceSubsetting	name	2bce54be67db2b25	1164	0
-ReferenceSubsetting	ownedAnnotation	7c8932dd086c471b	1164	0
-ReferenceSubsetting	ownedElement	bedaf0ada9a6f594	1164	10
-ReferenceSubsetting	ownedRelatedElement	5ec99b6b78dc6286	1164	495
-ReferenceSubsetting	ownedRelationship	30a1b4c2e88769a0	1164	10
-ReferenceSubsetting	owner	2bce54be67db2b25	1164	0
-ReferenceSubsetting	owningFeature	846bafbe73517293	1164	1164
-ReferenceSubsetting	owningMembership	2bce54be67db2b25	1164	0
-ReferenceSubsetting	owningNamespace	2bce54be67db2b25	1164	0
-ReferenceSubsetting	owningRelatedElement	846bafbe73517293	1164	1164
-ReferenceSubsetting	owningRelationship	2bce54be67db2b25	1164	0
-ReferenceSubsetting	owningType	846bafbe73517293	1164	1164
-ReferenceSubsetting	qualifiedName	2bce54be67db2b25	1164	0
-ReferenceSubsetting	referencedFeature	fcb6c4c1ae75be5a	1164	1164
-ReferenceSubsetting	referencingFeature	846bafbe73517293	1164	1164
-ReferenceSubsetting	relatedElement	7f54deb5e8f7cbec	1164	1164
-ReferenceSubsetting	shortName	2bce54be67db2b25	1164	0
-ReferenceSubsetting	source	500aa6b407b68cef	1164	1164
-ReferenceSubsetting	specific	846bafbe73517293	1164	1164
-ReferenceSubsetting	subsettedFeature	fcb6c4c1ae75be5a	1164	1164
-ReferenceSubsetting	subsettingFeature	846bafbe73517293	1164	1164
-ReferenceSubsetting	target	2ab4230e602bb8a4	1164	1164
-ReferenceSubsetting	textualRepresentation	bedaf0ada9a6f594	1164	10
-ReferenceUsage	aliasIds	b2e28eeca2859c0c	3074	0
-ReferenceUsage	chainingFeature	b2e28eeca2859c0c	3074	0
-ReferenceUsage	crossFeature	d9d0348954fc86be	3074	0
-ReferenceUsage	declaredName	39661a7321d6adfc	3074	1028
-ReferenceUsage	declaredShortName	d9d0348954fc86be	3074	0
-ReferenceUsage	definition	5841841adc9e3259	3074	1522
-ReferenceUsage	differencingType	b2e28eeca2859c0c	3074	0
-ReferenceUsage	directedFeature	b2e28eeca2859c0c	3074	0
-ReferenceUsage	directedUsage	b2e28eeca2859c0c	3074	0
-ReferenceUsage	direction	9a1ed50a0bc08744	3074	1243
-ReferenceUsage	documentation	8349ab004b77ba23	3074	3
-ReferenceUsage	elementId	7613b3d32f9af500	3074	3074
-ReferenceUsage	endFeature	b2e28eeca2859c0c	3074	0
-ReferenceUsage	endOwningType	a91e6dc313c7a041	3074	1052
-ReferenceUsage	feature	281a3b70801aa733	3074	34
-ReferenceUsage	featureMembership	f524cce76d690742	3074	34
-ReferenceUsage	featureTarget	aa51a76548bcfbaa	3074	0
-ReferenceUsage	featuringType	b2e28eeca2859c0c	3074	0
-ReferenceUsage	importedMembership	b2e28eeca2859c0c	3074	0
-ReferenceUsage	inheritedFeature	b2e28eeca2859c0c	3074	0
-ReferenceUsage	inheritedMembership	b2e28eeca2859c0c	3074	0
-ReferenceUsage	input	b2e28eeca2859c0c	3074	0
-ReferenceUsage	intersectingType	b2e28eeca2859c0c	3074	0
-ReferenceUsage	isAbstract	97aaa822180a00c4	3074	2
-ReferenceUsage	isComposite	827776558f4475b8	3074	0
-ReferenceUsage	isConjugated	cc6fb1314ea68cba	3074	0
-ReferenceUsage	isConstant	42dceba9e8758160	3074	1052
-ReferenceUsage	isDerived	f443f1b6684d76ea	3074	0
-ReferenceUsage	isEnd	42dceba9e8758160	3074	1052
-ReferenceUsage	isImpliedIncluded	2e908618a80cbc5c	3074	3074
-ReferenceUsage	isLibraryElement	fbe2398abeb6663a	3074	48
-ReferenceUsage	isOrdered	f443f1b6684d76ea	3074	0
-ReferenceUsage	isPortion	d9d0348954fc86be	3074	0
-ReferenceUsage	isReference	57f13ea6ba5f151c	3074	2844
-ReferenceUsage	isSufficient	d9d0348954fc86be	3074	0
-ReferenceUsage	isUnique	018a8ebef5793ed6	3074	1388
-ReferenceUsage	isVariable	6ff755d8a1d4c334	3074	1052
-ReferenceUsage	isVariation	cc6fb1314ea68cba	3074	0
-ReferenceUsage	mayTimeVary	6ff755d8a1d4c334	3074	1052
-ReferenceUsage	member	14f2322e0465504a	3074	929
-ReferenceUsage	membership	05b95428f3622efa	3074	929
-ReferenceUsage	multiplicity	0024a2d7e1e342a4	3074	108
-ReferenceUsage	name	8307e8a334911694	3074	2779
-ReferenceUsage	nestedAction	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedAllocation	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedAnalysisCase	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedAttribute	70c5842af8cef12d	3074	1
-ReferenceUsage	nestedCalculation	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedCase	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedConcern	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedConnection	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedConstraint	a711eb1b55cd1a50	3074	4
-ReferenceUsage	nestedEnumeration	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedFlow	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedInterface	de6d1e2e258c9c6f	3074	26
-ReferenceUsage	nestedItem	99f462ee9e504142	3074	3
-ReferenceUsage	nestedMetadata	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedOccurrence	3eacb6f0a6ca51af	3074	7
-ReferenceUsage	nestedPart	99f462ee9e504142	3074	3
-ReferenceUsage	nestedPort	c4c76f9f0ac8ddcf	3074	2
-ReferenceUsage	nestedReference	de6d1e2e258c9c6f	3074	26
-ReferenceUsage	nestedRendering	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedRequirement	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedState	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedTransition	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedUsage	281a3b70801aa733	3074	34
-ReferenceUsage	nestedUseCase	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedVerificationCase	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedView	b2e28eeca2859c0c	3074	0
-ReferenceUsage	nestedViewpoint	b2e28eeca2859c0c	3074	0
-ReferenceUsage	output	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedAnnotation	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedConjugator	d9d0348954fc86be	3074	0
-ReferenceUsage	ownedCrossSubsetting	d9d0348954fc86be	3074	0
-ReferenceUsage	ownedDifferencing	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedDisjoining	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedElement	1a0342976f8ca8cb	3074	1125
-ReferenceUsage	ownedEndFeature	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedFeature	281a3b70801aa733	3074	34
-ReferenceUsage	ownedFeatureChaining	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedFeatureInverting	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedFeatureMembership	f524cce76d690742	3074	34
-ReferenceUsage	ownedImport	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedIntersecting	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedMember	14f2322e0465504a	3074	929
-ReferenceUsage	ownedMembership	05b95428f3622efa	3074	929
-ReferenceUsage	ownedRedefinition	ec0c1d2fc95fd3a0	3074	628
-ReferenceUsage	ownedReferenceSubsetting	9543488fa87c651d	3074	583
-ReferenceUsage	ownedRelationship	6d6228b6c38642ee	3074	2404
-ReferenceUsage	ownedSpecialization	08c972a1ec93c31e	3074	1953
-ReferenceUsage	ownedSubsetting	6fddebee52a896e3	3074	1277
-ReferenceUsage	ownedTypeFeaturing	b2e28eeca2859c0c	3074	0
-ReferenceUsage	ownedTyping	a96c56cf0acb7835	3074	733
-ReferenceUsage	ownedUnioning	b2e28eeca2859c0c	3074	0
-ReferenceUsage	owner	940ac453a828863f	3074	3074
-ReferenceUsage	owningDefinition	6660f001f33ed25f	3074	540
-ReferenceUsage	owningFeatureMembership	e6d84a2ad469c783	3074	3017
-ReferenceUsage	owningMembership	9d500fc08cf05fa9	3074	3074
-ReferenceUsage	owningNamespace	940ac453a828863f	3074	3074
-ReferenceUsage	owningRelationship	9d500fc08cf05fa9	3074	3074
-ReferenceUsage	owningType	8e8657068e0f6188	3074	3017
-ReferenceUsage	owningUsage	9e8043f5f0536ff4	3074	2221
-ReferenceUsage	qualifiedName	2c2ee2bf6eff0ad6	3074	1490
-ReferenceUsage	shortName	b51f1735ff0bb0df	3074	1
-ReferenceUsage	textualRepresentation	b2e28eeca2859c0c	3074	0
-ReferenceUsage	type	5841841adc9e3259	3074	1522
-ReferenceUsage	unioningType	b2e28eeca2859c0c	3074	0
-ReferenceUsage	usage	281a3b70801aa733	3074	34
-ReferenceUsage	variant	b2e28eeca2859c0c	3074	0
-ReferenceUsage	variantMembership	b2e28eeca2859c0c	3074	0
+Redefinition	aliasIds	4be4f14333771992	5594	0
+Redefinition	declaredName	4eeb020e09ac6cf4	5594	0
+Redefinition	declaredShortName	4eeb020e09ac6cf4	5594	0
+Redefinition	documentation	4be4f14333771992	5594	0
+Redefinition	elementId	04ef37d6fad55e60	5594	5594
+Redefinition	general	feeed4a8460fe1d4	5594	5594
+Redefinition	isImplied	c7f7d90c7c6f4bea	5594	4290
+Redefinition	isImpliedIncluded	55eaf31a30dd25ba	5594	5594
+Redefinition	isLibraryElement	67d9c6f950f33402	5594	74
+Redefinition	name	4eeb020e09ac6cf4	5594	0
+Redefinition	ownedAnnotation	4be4f14333771992	5594	0
+Redefinition	ownedElement	ac0e03cd1240760d	5594	9
+Redefinition	ownedRelatedElement	4f59be9d67f9b30a	5594	6
+Redefinition	ownedRelationship	3345aee95aed3614	5594	9
+Redefinition	owner	4eeb020e09ac6cf4	5594	0
+Redefinition	owningFeature	03390f759cbecf3d	5594	5594
+Redefinition	owningMembership	4eeb020e09ac6cf4	5594	0
+Redefinition	owningNamespace	4eeb020e09ac6cf4	5594	0
+Redefinition	owningRelatedElement	03390f759cbecf3d	5594	5594
+Redefinition	owningRelationship	4eeb020e09ac6cf4	5594	0
+Redefinition	owningType	03390f759cbecf3d	5594	5594
+Redefinition	qualifiedName	4eeb020e09ac6cf4	5594	0
+Redefinition	redefinedFeature	feeed4a8460fe1d4	5594	5594
+Redefinition	redefiningFeature	03390f759cbecf3d	5594	5594
+Redefinition	relatedElement	325c165cc13b3e25	5594	5594
+Redefinition	shortName	4eeb020e09ac6cf4	5594	0
+Redefinition	source	4ee9278ae260ec07	5594	5594
+Redefinition	specific	03390f759cbecf3d	5594	5594
+Redefinition	subsettedFeature	feeed4a8460fe1d4	5594	5594
+Redefinition	subsettingFeature	03390f759cbecf3d	5594	5594
+Redefinition	target	d5e1436a169160a8	5594	5594
+Redefinition	textualRepresentation	ac0e03cd1240760d	5594	9
+ReferenceSubsetting	aliasIds	14eeb1b444a0dd12	4876	0
+ReferenceSubsetting	declaredName	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	declaredShortName	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	documentation	14eeb1b444a0dd12	4876	0
+ReferenceSubsetting	elementId	6298c6f436bb9e24	4876	4876
+ReferenceSubsetting	general	e0a04884a2ecb2f4	4876	4876
+ReferenceSubsetting	isImplied	774540d90bb0bb6e	4876	3712
+ReferenceSubsetting	isImpliedIncluded	1a3ecaa6147ad96a	4876	4876
+ReferenceSubsetting	isLibraryElement	4c2311e8cf9fe2a6	4876	0
+ReferenceSubsetting	name	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	ownedAnnotation	14eeb1b444a0dd12	4876	0
+ReferenceSubsetting	ownedElement	14eeb1b444a0dd12	4876	0
+ReferenceSubsetting	ownedRelatedElement	5432ec86d81f2912	4876	495
+ReferenceSubsetting	ownedRelationship	14eeb1b444a0dd12	4876	0
+ReferenceSubsetting	owner	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	owningFeature	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	owningMembership	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	owningNamespace	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	owningRelatedElement	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	owningRelationship	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	owningType	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	qualifiedName	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	referencedFeature	e0a04884a2ecb2f4	4876	4876
+ReferenceSubsetting	referencingFeature	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	relatedElement	e3d717ac766556a7	4876	4876
+ReferenceSubsetting	shortName	88d11c9300dab9ae	4876	0
+ReferenceSubsetting	source	2b1548939be6bd5d	4876	4876
+ReferenceSubsetting	specific	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	subsettedFeature	e0a04884a2ecb2f4	4876	4876
+ReferenceSubsetting	subsettingFeature	676d7c3fb1cc6bcf	4876	4876
+ReferenceSubsetting	target	ce2de80af90d189c	4876	4876
+ReferenceSubsetting	textualRepresentation	14eeb1b444a0dd12	4876	0
+ReferenceUsage	aliasIds	c7737264274ba99f	3074	0
+ReferenceUsage	chainingFeature	c7737264274ba99f	3074	0
+ReferenceUsage	crossFeature	0818faf68da39347	3074	0
+ReferenceUsage	declaredName	5cff2d1b4077431b	3074	1028
+ReferenceUsage	declaredShortName	0818faf68da39347	3074	0
+ReferenceUsage	definition	98b567e954779b6a	3074	1702
+ReferenceUsage	differencingType	c7737264274ba99f	3074	0
+ReferenceUsage	directedFeature	c7737264274ba99f	3074	0
+ReferenceUsage	directedUsage	c7737264274ba99f	3074	0
+ReferenceUsage	direction	4098d89d4201d0a5	3074	1243
+ReferenceUsage	documentation	97da8e77d03dc7b6	3074	3
+ReferenceUsage	elementId	d998374488947a34	3074	3074
+ReferenceUsage	endFeature	c7737264274ba99f	3074	0
+ReferenceUsage	endOwningType	d76734304c6eacca	3074	1052
+ReferenceUsage	feature	3cab1ee804e0b4c6	3074	34
+ReferenceUsage	featureMembership	09b5b05ef22f14d5	3074	34
+ReferenceUsage	featureTarget	f0e37d534d63eae0	3074	0
+ReferenceUsage	featuringType	c7737264274ba99f	3074	0
+ReferenceUsage	importedMembership	c7737264274ba99f	3074	0
+ReferenceUsage	inheritedFeature	c7737264274ba99f	3074	0
+ReferenceUsage	inheritedMembership	c7737264274ba99f	3074	0
+ReferenceUsage	input	c7737264274ba99f	3074	0
+ReferenceUsage	intersectingType	c7737264274ba99f	3074	0
+ReferenceUsage	isAbstract	5dd909acbabea65b	3074	2
+ReferenceUsage	isComposite	ba7253410b021c81	3074	0
+ReferenceUsage	isConjugated	ba7253410b021c81	3074	0
+ReferenceUsage	isConstant	9ea0553a5f74df1d	3074	1052
+ReferenceUsage	isDerived	ba7253410b021c81	3074	0
+ReferenceUsage	isEnd	9ea0553a5f74df1d	3074	1052
+ReferenceUsage	isImpliedIncluded	66a445d659e2d0ab	3074	3074
+ReferenceUsage	isLibraryElement	e9e4db9a7b11f601	3074	48
+ReferenceUsage	isOrdered	ba7253410b021c81	3074	0
+ReferenceUsage	isPortion	ba7253410b021c81	3074	0
+ReferenceUsage	isReference	9004fe646c35296b	3074	2844
+ReferenceUsage	isSufficient	ba7253410b021c81	3074	0
+ReferenceUsage	isUnique	66a445d659e2d0ab	3074	3074
+ReferenceUsage	isVariable	9e401c45da7bcfbd	3074	1052
+ReferenceUsage	isVariation	ba7253410b021c81	3074	0
+ReferenceUsage	mayTimeVary	9e401c45da7bcfbd	3074	1052
+ReferenceUsage	member	cea17a4b02f03b72	3074	929
+ReferenceUsage	membership	9607c35d988c4baf	3074	929
+ReferenceUsage	multiplicity	2e6d69451a8a4f2d	3074	108
+ReferenceUsage	name	831a5943beb00730	3074	3036
+ReferenceUsage	nestedAction	c7737264274ba99f	3074	0
+ReferenceUsage	nestedAllocation	c7737264274ba99f	3074	0
+ReferenceUsage	nestedAnalysisCase	c7737264274ba99f	3074	0
+ReferenceUsage	nestedAttribute	855667a27d94fec0	3074	1
+ReferenceUsage	nestedCalculation	c7737264274ba99f	3074	0
+ReferenceUsage	nestedCase	c7737264274ba99f	3074	0
+ReferenceUsage	nestedConcern	c7737264274ba99f	3074	0
+ReferenceUsage	nestedConnection	c7737264274ba99f	3074	0
+ReferenceUsage	nestedConstraint	bba2ce92da9327e3	3074	4
+ReferenceUsage	nestedEnumeration	c7737264274ba99f	3074	0
+ReferenceUsage	nestedFlow	c7737264274ba99f	3074	0
+ReferenceUsage	nestedInterface	c7737264274ba99f	3074	0
+ReferenceUsage	nestedItem	ae85466623164ed5	3074	3
+ReferenceUsage	nestedMetadata	c7737264274ba99f	3074	0
+ReferenceUsage	nestedOccurrence	533d9a682b905f42	3074	7
+ReferenceUsage	nestedPart	ae85466623164ed5	3074	3
+ReferenceUsage	nestedPort	d95853168f8eeb62	3074	2
+ReferenceUsage	nestedReference	f2fe01a5aa52aa02	3074	26
+ReferenceUsage	nestedRendering	c7737264274ba99f	3074	0
+ReferenceUsage	nestedRequirement	c7737264274ba99f	3074	0
+ReferenceUsage	nestedState	c7737264274ba99f	3074	0
+ReferenceUsage	nestedTransition	c7737264274ba99f	3074	0
+ReferenceUsage	nestedUsage	3cab1ee804e0b4c6	3074	34
+ReferenceUsage	nestedUseCase	c7737264274ba99f	3074	0
+ReferenceUsage	nestedVerificationCase	c7737264274ba99f	3074	0
+ReferenceUsage	nestedView	c7737264274ba99f	3074	0
+ReferenceUsage	nestedViewpoint	c7737264274ba99f	3074	0
+ReferenceUsage	output	c7737264274ba99f	3074	0
+ReferenceUsage	ownedAnnotation	c7737264274ba99f	3074	0
+ReferenceUsage	ownedConjugator	0818faf68da39347	3074	0
+ReferenceUsage	ownedCrossSubsetting	0818faf68da39347	3074	0
+ReferenceUsage	ownedDifferencing	c7737264274ba99f	3074	0
+ReferenceUsage	ownedDisjoining	c7737264274ba99f	3074	0
+ReferenceUsage	ownedElement	d3b28ab46e1793f3	3074	1125
+ReferenceUsage	ownedEndFeature	c7737264274ba99f	3074	0
+ReferenceUsage	ownedFeature	3cab1ee804e0b4c6	3074	34
+ReferenceUsage	ownedFeatureChaining	c7737264274ba99f	3074	0
+ReferenceUsage	ownedFeatureInverting	c7737264274ba99f	3074	0
+ReferenceUsage	ownedFeatureMembership	09b5b05ef22f14d5	3074	34
+ReferenceUsage	ownedImport	c7737264274ba99f	3074	0
+ReferenceUsage	ownedIntersecting	c7737264274ba99f	3074	0
+ReferenceUsage	ownedMember	cea17a4b02f03b72	3074	929
+ReferenceUsage	ownedMembership	9607c35d988c4baf	3074	929
+ReferenceUsage	ownedRedefinition	4282e0da0cf221d3	3074	2242
+ReferenceUsage	ownedReferenceSubsetting	58ce90b70be63ae0	3074	951
+ReferenceUsage	ownedRelationship	89d794d599f7dd25	3074	3074
+ReferenceUsage	ownedSpecialization	d173ca8e3629be49	3074	3074
+ReferenceUsage	ownedSubsetting	6367446cb9d6080a	3074	3074
+ReferenceUsage	ownedTypeFeaturing	c7737264274ba99f	3074	0
+ReferenceUsage	ownedTyping	bdfd3a468f9185c8	3074	733
+ReferenceUsage	ownedUnioning	c7737264274ba99f	3074	0
+ReferenceUsage	owner	e21e3a64ff26f918	3074	3074
+ReferenceUsage	owningDefinition	94a9b66f2be5dee8	3074	540
+ReferenceUsage	owningFeatureMembership	f3ffdc2bd76def02	3074	3017
+ReferenceUsage	owningMembership	aa77a1c18ff48728	3074	3074
+ReferenceUsage	owningNamespace	e21e3a64ff26f918	3074	3074
+ReferenceUsage	owningRelationship	aa77a1c18ff48728	3074	3074
+ReferenceUsage	owningType	dc99cd17e50dd461	3074	3017
+ReferenceUsage	owningUsage	ea0bef666878cf61	3074	2221
+ReferenceUsage	qualifiedName	d38f86f7c0ae3ac5	3074	1543
+ReferenceUsage	shortName	e367dda337b2bd68	3074	1
+ReferenceUsage	textualRepresentation	c7737264274ba99f	3074	0
+ReferenceUsage	type	98b567e954779b6a	3074	1702
+ReferenceUsage	unioningType	c7737264274ba99f	3074	0
+ReferenceUsage	usage	3cab1ee804e0b4c6	3074	34
+ReferenceUsage	variant	c7737264274ba99f	3074	0
+ReferenceUsage	variantMembership	c7737264274ba99f	3074	0
 RenderingDefinition	aliasIds	46bd8d533727e761	1	0
 RenderingDefinition	declaredName	4b639867d1de95f1	1	1
 RenderingDefinition	declaredShortName	3e957a329570a258	1	0
@@ -7603,7 +7688,7 @@ RenderingDefinition	intersectingType	46bd8d533727e761	1	0
 RenderingDefinition	isAbstract	68a3c8d8df79989c	1	0
 RenderingDefinition	isConjugated	68a3c8d8df79989c	1	0
 RenderingDefinition	isImpliedIncluded	1930c5df46692381	1	1
-RenderingDefinition	isIndividual	3e957a329570a258	1	0
+RenderingDefinition	isIndividual	68a3c8d8df79989c	1	0
 RenderingDefinition	isLibraryElement	68a3c8d8df79989c	1	0
 RenderingDefinition	isSufficient	68a3c8d8df79989c	1	0
 RenderingDefinition	isVariation	68a3c8d8df79989c	1	0
@@ -7698,12 +7783,12 @@ RenderingUsage	isConstant	f4ac3cd6336f4328	14	0
 RenderingUsage	isDerived	f4ac3cd6336f4328	14	0
 RenderingUsage	isEnd	f4ac3cd6336f4328	14	0
 RenderingUsage	isImpliedIncluded	ac4a9908769295ce	14	14
-RenderingUsage	isIndividual	e914bbcdd1aa38f4	14	0
+RenderingUsage	isIndividual	f4ac3cd6336f4328	14	0
 RenderingUsage	isLibraryElement	f4ac3cd6336f4328	14	0
 RenderingUsage	isOrdered	f4ac3cd6336f4328	14	0
-RenderingUsage	isPortion	e914bbcdd1aa38f4	14	0
+RenderingUsage	isPortion	f4ac3cd6336f4328	14	0
 RenderingUsage	isReference	e7eddf043ad945b2	14	2
-RenderingUsage	isSufficient	e914bbcdd1aa38f4	14	0
+RenderingUsage	isSufficient	f4ac3cd6336f4328	14	0
 RenderingUsage	isUnique	ac4a9908769295ce	14	14
 RenderingUsage	isVariable	e914bbcdd1aa38f4	14	0
 RenderingUsage	isVariation	f4ac3cd6336f4328	14	0
@@ -7784,45 +7869,45 @@ RenderingUsage	unioningType	f88374922a60e41e	14	0
 RenderingUsage	usage	c20f640416afaa83	14	2
 RenderingUsage	variant	f88374922a60e41e	14	0
 RenderingUsage	variantMembership	f88374922a60e41e	14	0
-RequirementConstraintMembership	aliasIds	f825b3fdd215e998	54	0
-RequirementConstraintMembership	declaredName	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	declaredShortName	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	documentation	f825b3fdd215e998	54	0
-RequirementConstraintMembership	elementId	58653c1337b2d084	54	54
-RequirementConstraintMembership	isImplied	7424ee3b88e2988a	54	0
-RequirementConstraintMembership	isImpliedIncluded	bca796c06c314cc8	54	54
-RequirementConstraintMembership	isLibraryElement	7424ee3b88e2988a	54	0
-RequirementConstraintMembership	kind	504cd94854859f90	54	54
-RequirementConstraintMembership	memberElement	b94ff8f1604ba776	54	54
-RequirementConstraintMembership	memberElementId	64b237266b48128c	54	54
-RequirementConstraintMembership	memberName	a190476b6ab1399a	54	23
-RequirementConstraintMembership	memberShortName	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	membershipOwningNamespace	4f4dc952cd97d9cb	54	54
-RequirementConstraintMembership	name	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	ownedAnnotation	f825b3fdd215e998	54	0
-RequirementConstraintMembership	ownedConstraint	b94ff8f1604ba776	54	54
-RequirementConstraintMembership	ownedElement	f825b3fdd215e998	54	0
-RequirementConstraintMembership	ownedMemberElement	b94ff8f1604ba776	54	54
-RequirementConstraintMembership	ownedMemberElementId	64b237266b48128c	54	54
-RequirementConstraintMembership	ownedMemberFeature	b94ff8f1604ba776	54	54
-RequirementConstraintMembership	ownedMemberName	a190476b6ab1399a	54	23
-RequirementConstraintMembership	ownedMemberShortName	ce6dc98c829c5d31	54	10
-RequirementConstraintMembership	ownedRelatedElement	7e7d8d9bc10859d2	54	54
-RequirementConstraintMembership	ownedRelationship	f825b3fdd215e998	54	0
-RequirementConstraintMembership	owner	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	owningMembership	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	owningNamespace	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	owningRelatedElement	4f4dc952cd97d9cb	54	54
-RequirementConstraintMembership	owningRelationship	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	owningType	4f4dc952cd97d9cb	54	54
-RequirementConstraintMembership	qualifiedName	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	referencedConstraint	d0173992d0013505	54	54
-RequirementConstraintMembership	relatedElement	319f7ebce5cff191	54	54
-RequirementConstraintMembership	shortName	e0fcfa569375a7fa	54	0
-RequirementConstraintMembership	source	4680a56348ee9e29	54	54
-RequirementConstraintMembership	target	7e7d8d9bc10859d2	54	54
-RequirementConstraintMembership	textualRepresentation	f825b3fdd215e998	54	0
-RequirementConstraintMembership	visibility	41d29c504cd87d52	54	54
+RequirementConstraintMembership	aliasIds	2c31df65640b92dd	54	0
+RequirementConstraintMembership	declaredName	b2f0814a0161b005	54	0
+RequirementConstraintMembership	declaredShortName	b2f0814a0161b005	54	0
+RequirementConstraintMembership	documentation	2c31df65640b92dd	54	0
+RequirementConstraintMembership	elementId	4a5d216267ab1fc8	54	54
+RequirementConstraintMembership	isImplied	565c6357d219cecb	54	0
+RequirementConstraintMembership	isImpliedIncluded	18a91e3bd0555a71	54	54
+RequirementConstraintMembership	isLibraryElement	565c6357d219cecb	54	0
+RequirementConstraintMembership	kind	3a9cf4ad5df56321	54	54
+RequirementConstraintMembership	memberElement	1596e15eee7b1a33	54	54
+RequirementConstraintMembership	memberElementId	40869350c74c9763	54	54
+RequirementConstraintMembership	memberName	2d06279245423226	54	24
+RequirementConstraintMembership	memberShortName	b2f0814a0161b005	54	0
+RequirementConstraintMembership	membershipOwningNamespace	34026ab4aa3baa2e	54	54
+RequirementConstraintMembership	name	b2f0814a0161b005	54	0
+RequirementConstraintMembership	ownedAnnotation	2c31df65640b92dd	54	0
+RequirementConstraintMembership	ownedConstraint	1596e15eee7b1a33	54	54
+RequirementConstraintMembership	ownedElement	2c31df65640b92dd	54	0
+RequirementConstraintMembership	ownedMemberElement	1596e15eee7b1a33	54	54
+RequirementConstraintMembership	ownedMemberElementId	40869350c74c9763	54	54
+RequirementConstraintMembership	ownedMemberFeature	1596e15eee7b1a33	54	54
+RequirementConstraintMembership	ownedMemberName	2d06279245423226	54	24
+RequirementConstraintMembership	ownedMemberShortName	4918d214346ad9a1	54	11
+RequirementConstraintMembership	ownedRelatedElement	04424b07fe246a27	54	54
+RequirementConstraintMembership	ownedRelationship	2c31df65640b92dd	54	0
+RequirementConstraintMembership	owner	b2f0814a0161b005	54	0
+RequirementConstraintMembership	owningMembership	b2f0814a0161b005	54	0
+RequirementConstraintMembership	owningNamespace	b2f0814a0161b005	54	0
+RequirementConstraintMembership	owningRelatedElement	34026ab4aa3baa2e	54	54
+RequirementConstraintMembership	owningRelationship	b2f0814a0161b005	54	0
+RequirementConstraintMembership	owningType	34026ab4aa3baa2e	54	54
+RequirementConstraintMembership	qualifiedName	b2f0814a0161b005	54	0
+RequirementConstraintMembership	referencedConstraint	e786831c4324ccd2	54	54
+RequirementConstraintMembership	relatedElement	08cd93ab46f355be	54	54
+RequirementConstraintMembership	shortName	b2f0814a0161b005	54	0
+RequirementConstraintMembership	source	8e2a29b042fde5b4	54	54
+RequirementConstraintMembership	target	04424b07fe246a27	54	54
+RequirementConstraintMembership	textualRepresentation	2c31df65640b92dd	54	0
+RequirementConstraintMembership	visibility	f97ae50e2877fe85	54	54
 RequirementDefinition	actorParameter	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	aliasIds	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	assumedConstraint	ccbe7a0789e225a3	32	2
@@ -7846,7 +7931,7 @@ RequirementDefinition	intersectingType	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	isAbstract	6b5133b9536bd39d	32	0
 RequirementDefinition	isConjugated	6b5133b9536bd39d	32	0
 RequirementDefinition	isImpliedIncluded	f1fcc79129b16c0d	32	32
-RequirementDefinition	isIndividual	7636019f13ee12b7	32	0
+RequirementDefinition	isIndividual	6b5133b9536bd39d	32	0
 RequirementDefinition	isLibraryElement	65774f87d62deaef	32	2
 RequirementDefinition	isModelLevelEvaluable	6b5133b9536bd39d	32	0
 RequirementDefinition	isSufficient	6b5133b9536bd39d	32	0
@@ -7876,7 +7961,7 @@ RequirementDefinition	ownedFeature	3b2b7e71293bd551	32	22
 RequirementDefinition	ownedFeatureMembership	137e0d849f8342e3	32	22
 RequirementDefinition	ownedFlow	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	ownedImport	1f15ad6d54e9a9b9	32	0
-RequirementDefinition	ownedInterface	556ab3b246715286	32	8
+RequirementDefinition	ownedInterface	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	ownedIntersecting	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	ownedItem	1f15ad6d54e9a9b9	32	0
 RequirementDefinition	ownedMember	40dee7ca35f5c5e0	32	25
@@ -7921,13 +8006,13 @@ RequirementDefinition	variantMembership	1f15ad6d54e9a9b9	32	0
 RequirementUsage	actorParameter	971b54713097b58b	135	0
 RequirementUsage	aliasIds	971b54713097b58b	135	0
 RequirementUsage	assumedConstraint	fd06ef83cb233a76	135	17
-RequirementUsage	behavior	34475cac14dcba05	135	75
+RequirementUsage	behavior	6a92d2b153057d72	135	80
 RequirementUsage	chainingFeature	971b54713097b58b	135	0
-RequirementUsage	constraintDefinition	3a0340253051a04d	135	75
+RequirementUsage	constraintDefinition	be10fb33f86d5bc3	135	80
 RequirementUsage	crossFeature	a89867c0736e855c	135	0
 RequirementUsage	declaredName	0b1173beff4e4430	135	106
 RequirementUsage	declaredShortName	f7fe6460d74c0699	135	26
-RequirementUsage	definition	34475cac14dcba05	135	75
+RequirementUsage	definition	6a92d2b153057d72	135	80
 RequirementUsage	differencingType	971b54713097b58b	135	0
 RequirementUsage	directedFeature	26e47c6d2309c401	135	31
 RequirementUsage	directedUsage	26e47c6d2309c401	135	31
@@ -7936,12 +8021,12 @@ RequirementUsage	documentation	0e7e9736baa4ee1b	135	37
 RequirementUsage	elementId	530bf1b45b2c9518	135	135
 RequirementUsage	endFeature	971b54713097b58b	135	0
 RequirementUsage	endOwningType	a89867c0736e855c	135	0
-RequirementUsage	feature	442674b62fb6a9b3	135	74
-RequirementUsage	featureMembership	05463e958264067d	135	74
+RequirementUsage	feature	1f0fc19c911b060d	135	74
+RequirementUsage	featureMembership	407f54d79f010f40	135	74
 RequirementUsage	featureTarget	fe200c66cdb841a1	135	0
 RequirementUsage	featuringType	971b54713097b58b	135	0
 RequirementUsage	framedConcern	971b54713097b58b	135	0
-RequirementUsage	function	3a0340253051a04d	135	75
+RequirementUsage	function	be10fb33f86d5bc3	135	80
 RequirementUsage	importedMembership	971b54713097b58b	135	0
 RequirementUsage	individualDefinition	a89867c0736e855c	135	0
 RequirementUsage	inheritedFeature	971b54713097b58b	135	0
@@ -7955,21 +8040,21 @@ RequirementUsage	isConstant	2539ffa655aca030	135	0
 RequirementUsage	isDerived	2539ffa655aca030	135	0
 RequirementUsage	isEnd	2539ffa655aca030	135	0
 RequirementUsage	isImpliedIncluded	fe8076bb45a257b3	135	135
-RequirementUsage	isIndividual	a89867c0736e855c	135	0
+RequirementUsage	isIndividual	2539ffa655aca030	135	0
 RequirementUsage	isLibraryElement	52063c1239072675	135	1
 RequirementUsage	isModelLevelEvaluable	2539ffa655aca030	135	0
 RequirementUsage	isOrdered	2539ffa655aca030	135	0
-RequirementUsage	isPortion	a89867c0736e855c	135	0
+RequirementUsage	isPortion	2539ffa655aca030	135	0
 RequirementUsage	isReference	91d897285745147d	135	49
-RequirementUsage	isSufficient	a89867c0736e855c	135	0
+RequirementUsage	isSufficient	2539ffa655aca030	135	0
 RequirementUsage	isUnique	e37b986fddb24f51	135	133
 RequirementUsage	isVariable	a89867c0736e855c	135	0
 RequirementUsage	isVariation	a6448fc2da5a04ca	135	2
 RequirementUsage	mayTimeVary	a89867c0736e855c	135	0
-RequirementUsage	member	e4564f553bd5525d	135	101
-RequirementUsage	membership	f67e6ebdf7f127d1	135	101
+RequirementUsage	member	ce7818a336f5d3c7	135	101
+RequirementUsage	membership	eb1eba98464edaca	135	101
 RequirementUsage	multiplicity	8a6ec3ddc603314f	135	2
-RequirementUsage	name	ee6e66eb496a6f75	135	132
+RequirementUsage	name	503def2f75f9e574	135	128
 RequirementUsage	nestedAction	971b54713097b58b	135	0
 RequirementUsage	nestedAllocation	b5a1a9984a10d152	135	1
 RequirementUsage	nestedAnalysisCase	971b54713097b58b	135	0
@@ -7978,13 +8063,13 @@ RequirementUsage	nestedCalculation	971b54713097b58b	135	0
 RequirementUsage	nestedCase	971b54713097b58b	135	0
 RequirementUsage	nestedConcern	971b54713097b58b	135	0
 RequirementUsage	nestedConnection	b5a1a9984a10d152	135	1
-RequirementUsage	nestedConstraint	4fc8df265930a587	135	44
+RequirementUsage	nestedConstraint	2ab22c0cba9501e1	135	44
 RequirementUsage	nestedEnumeration	971b54713097b58b	135	0
 RequirementUsage	nestedFlow	971b54713097b58b	135	0
-RequirementUsage	nestedInterface	1b8ca3b2052b1539	135	43
+RequirementUsage	nestedInterface	971b54713097b58b	135	0
 RequirementUsage	nestedItem	b5a1a9984a10d152	135	1
 RequirementUsage	nestedMetadata	971b54713097b58b	135	0
-RequirementUsage	nestedOccurrence	094d331c266179fd	135	46
+RequirementUsage	nestedOccurrence	e436800287c5d657	135	46
 RequirementUsage	nestedPart	b5a1a9984a10d152	135	1
 RequirementUsage	nestedPort	c27acb5c36dcf9e2	135	2
 RequirementUsage	nestedReference	1b8ca3b2052b1539	135	43
@@ -7992,33 +8077,33 @@ RequirementUsage	nestedRendering	971b54713097b58b	135	0
 RequirementUsage	nestedRequirement	43b87cc04a023bb0	135	16
 RequirementUsage	nestedState	971b54713097b58b	135	0
 RequirementUsage	nestedTransition	971b54713097b58b	135	0
-RequirementUsage	nestedUsage	442674b62fb6a9b3	135	74
+RequirementUsage	nestedUsage	1f0fc19c911b060d	135	74
 RequirementUsage	nestedUseCase	971b54713097b58b	135	0
 RequirementUsage	nestedVerificationCase	971b54713097b58b	135	0
 RequirementUsage	nestedView	971b54713097b58b	135	0
 RequirementUsage	nestedViewpoint	971b54713097b58b	135	0
-RequirementUsage	occurrenceDefinition	34475cac14dcba05	135	75
+RequirementUsage	occurrenceDefinition	6a92d2b153057d72	135	80
 RequirementUsage	output	971b54713097b58b	135	0
 RequirementUsage	ownedAnnotation	971b54713097b58b	135	0
 RequirementUsage	ownedConjugator	a89867c0736e855c	135	0
 RequirementUsage	ownedCrossSubsetting	a89867c0736e855c	135	0
 RequirementUsage	ownedDifferencing	971b54713097b58b	135	0
 RequirementUsage	ownedDisjoining	971b54713097b58b	135	0
-RequirementUsage	ownedElement	04557b1f93cc6796	135	101
+RequirementUsage	ownedElement	ee77446d8eece900	135	101
 RequirementUsage	ownedEndFeature	971b54713097b58b	135	0
-RequirementUsage	ownedFeature	442674b62fb6a9b3	135	74
+RequirementUsage	ownedFeature	1f0fc19c911b060d	135	74
 RequirementUsage	ownedFeatureChaining	971b54713097b58b	135	0
 RequirementUsage	ownedFeatureInverting	971b54713097b58b	135	0
-RequirementUsage	ownedFeatureMembership	05463e958264067d	135	74
+RequirementUsage	ownedFeatureMembership	407f54d79f010f40	135	74
 RequirementUsage	ownedImport	5d6bf1fde5463629	135	1
 RequirementUsage	ownedIntersecting	971b54713097b58b	135	0
-RequirementUsage	ownedMember	e4564f553bd5525d	135	101
-RequirementUsage	ownedMembership	f67e6ebdf7f127d1	135	101
-RequirementUsage	ownedRedefinition	df0bf58481fdb280	135	15
+RequirementUsage	ownedMember	ce7818a336f5d3c7	135	101
+RequirementUsage	ownedMembership	eb1eba98464edaca	135	101
+RequirementUsage	ownedRedefinition	051570efaa8fc320	135	19
 RequirementUsage	ownedReferenceSubsetting	0b7a52a3f738d444	135	5
-RequirementUsage	ownedRelationship	5aca40f7b9d7f74b	135	135
-RequirementUsage	ownedSpecialization	98b7ed0691284a0b	135	135
-RequirementUsage	ownedSubsetting	df919be03dd11819	135	135
+RequirementUsage	ownedRelationship	7c2382dcc4f23540	135	135
+RequirementUsage	ownedSpecialization	db12e6aaef1e9ff7	135	135
+RequirementUsage	ownedSubsetting	5b3c448170a0b8dd	135	135
 RequirementUsage	ownedTypeFeaturing	971b54713097b58b	135	0
 RequirementUsage	ownedTyping	95323301f40f3a63	135	57
 RequirementUsage	ownedUnioning	971b54713097b58b	135	0
@@ -8032,20 +8117,20 @@ RequirementUsage	owningType	963c81fb42d9476d	135	92
 RequirementUsage	owningUsage	659cd89a659020d0	135	68
 RequirementUsage	parameter	26e47c6d2309c401	135	31
 RequirementUsage	portionKind	a89867c0736e855c	135	0
-RequirementUsage	predicate	3a0340253051a04d	135	75
-RequirementUsage	qualifiedName	6feb4a515cf67d15	135	132
+RequirementUsage	predicate	be10fb33f86d5bc3	135	80
+RequirementUsage	qualifiedName	b84f40d58442febf	135	125
 RequirementUsage	reqId	a89867c0736e855c	135	0
-RequirementUsage	requiredConstraint	f20f0992738acc03	135	21
-RequirementUsage	requirementDefinition	3a0340253051a04d	135	75
+RequirementUsage	requiredConstraint	ccf85678d4ef285d	135	21
+RequirementUsage	requirementDefinition	be10fb33f86d5bc3	135	80
 RequirementUsage	result	fe200c66cdb841a1	135	0
-RequirementUsage	shortName	e81cc3cff2d5ce04	135	28
+RequirementUsage	shortName	f7fe6460d74c0699	135	26
 RequirementUsage	stakeholderParameter	971b54713097b58b	135	0
 RequirementUsage	subjectParameter	5a6ca1b6fa66131e	135	31
 RequirementUsage	text	4c954254e84153a3	135	37
 RequirementUsage	textualRepresentation	971b54713097b58b	135	0
-RequirementUsage	type	34475cac14dcba05	135	75
+RequirementUsage	type	6a92d2b153057d72	135	80
 RequirementUsage	unioningType	971b54713097b58b	135	0
-RequirementUsage	usage	442674b62fb6a9b3	135	74
+RequirementUsage	usage	1f0fc19c911b060d	135	74
 RequirementUsage	variant	7c974ce8d22bf721	135	2
 RequirementUsage	variantMembership	7b93cdd1b7190459	135	2
 RequirementVerificationMembership	aliasIds	4cd0c5a1b6246cba	6	0
@@ -8059,7 +8144,7 @@ RequirementVerificationMembership	isLibraryElement	31a98a6d196c7b74	6	0
 RequirementVerificationMembership	kind	3f0ae08f29380c58	6	6
 RequirementVerificationMembership	memberElement	5dd243c26213f188	6	6
 RequirementVerificationMembership	memberElementId	015cf84b022c2672	6	6
-RequirementVerificationMembership	memberName	d0e9b57755796da1	6	4
+RequirementVerificationMembership	memberName	9b18dea7e2432690	6	1
 RequirementVerificationMembership	memberShortName	3430f34ab9ca94ac	6	0
 RequirementVerificationMembership	membershipOwningNamespace	e99cb9a8bdd49862	6	6
 RequirementVerificationMembership	name	3430f34ab9ca94ac	6	0
@@ -8069,8 +8154,8 @@ RequirementVerificationMembership	ownedElement	4cd0c5a1b6246cba	6	0
 RequirementVerificationMembership	ownedMemberElement	5dd243c26213f188	6	6
 RequirementVerificationMembership	ownedMemberElementId	015cf84b022c2672	6	6
 RequirementVerificationMembership	ownedMemberFeature	5dd243c26213f188	6	6
-RequirementVerificationMembership	ownedMemberName	d0e9b57755796da1	6	4
-RequirementVerificationMembership	ownedMemberShortName	075c6041bcfde4be	6	1
+RequirementVerificationMembership	ownedMemberName	9b18dea7e2432690	6	1
+RequirementVerificationMembership	ownedMemberShortName	3430f34ab9ca94ac	6	0
 RequirementVerificationMembership	ownedRelatedElement	6315ccddd16181d4	6	6
 RequirementVerificationMembership	ownedRelationship	4cd0c5a1b6246cba	6	0
 RequirementVerificationMembership	ownedRequirement	5dd243c26213f188	6	6
@@ -8081,13 +8166,13 @@ RequirementVerificationMembership	owningRelatedElement	e99cb9a8bdd49862	6	6
 RequirementVerificationMembership	owningRelationship	3430f34ab9ca94ac	6	0
 RequirementVerificationMembership	owningType	e99cb9a8bdd49862	6	6
 RequirementVerificationMembership	qualifiedName	3430f34ab9ca94ac	6	0
-RequirementVerificationMembership	referencedConstraint	29f2b6314ee7b8e3	6	6
+RequirementVerificationMembership	referencedConstraint	5d43eface52177c1	6	6
 RequirementVerificationMembership	relatedElement	b9380db3089114e0	6	6
 RequirementVerificationMembership	shortName	3430f34ab9ca94ac	6	0
 RequirementVerificationMembership	source	176cbc839ef24346	6	6
 RequirementVerificationMembership	target	6315ccddd16181d4	6	6
 RequirementVerificationMembership	textualRepresentation	4cd0c5a1b6246cba	6	0
-RequirementVerificationMembership	verifiedRequirement	29f2b6314ee7b8e3	6	6
+RequirementVerificationMembership	verifiedRequirement	5d43eface52177c1	6	6
 RequirementVerificationMembership	visibility	b9c9db6a124c0900	6	6
 ResultExpressionMembership	aliasIds	e5dd4fe59392a009	105	0
 ResultExpressionMembership	declaredName	8caa2072cf57d97c	105	0
@@ -8126,43 +8211,43 @@ ResultExpressionMembership	source	94de3607180f5c15	105	105
 ResultExpressionMembership	target	cc174a68e74d5586	105	105
 ResultExpressionMembership	textualRepresentation	e5dd4fe59392a009	105	0
 ResultExpressionMembership	visibility	09fbeb566528ecb2	105	105
-ReturnParameterMembership	aliasIds	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	declaredName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	declaredShortName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	documentation	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	elementId	e9354790f3540934	157	157
-ReturnParameterMembership	isImplied	5021ec1757d0395e	157	0
-ReturnParameterMembership	isImpliedIncluded	650156ffcf74031f	157	157
-ReturnParameterMembership	isLibraryElement	01f162fefd3e9c29	157	23
-ReturnParameterMembership	memberElement	2664adae40e05dc8	157	157
-ReturnParameterMembership	memberElementId	9efe72127aa3a685	157	157
-ReturnParameterMembership	memberName	ea88d8b90f583804	157	157
-ReturnParameterMembership	memberShortName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	membershipOwningNamespace	d91b55cecbfc1a21	157	157
-ReturnParameterMembership	name	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	ownedAnnotation	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	ownedElement	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	ownedMemberElement	2664adae40e05dc8	157	157
-ReturnParameterMembership	ownedMemberElementId	9efe72127aa3a685	157	157
-ReturnParameterMembership	ownedMemberFeature	2664adae40e05dc8	157	157
-ReturnParameterMembership	ownedMemberName	ea88d8b90f583804	157	157
-ReturnParameterMembership	ownedMemberParameter	2664adae40e05dc8	157	157
-ReturnParameterMembership	ownedMemberShortName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	ownedRelatedElement	9d90063d68ca5f46	157	157
-ReturnParameterMembership	ownedRelationship	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	owner	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	owningMembership	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	owningNamespace	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	owningRelatedElement	d91b55cecbfc1a21	157	157
-ReturnParameterMembership	owningRelationship	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	owningType	d91b55cecbfc1a21	157	157
-ReturnParameterMembership	qualifiedName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	relatedElement	6f2f3df55e6e6e32	157	157
-ReturnParameterMembership	shortName	9cbfa2d4f5e9517a	157	0
-ReturnParameterMembership	source	76faaa603e327061	157	157
-ReturnParameterMembership	target	9d90063d68ca5f46	157	157
-ReturnParameterMembership	textualRepresentation	a8f9aecaeff899a7	157	0
-ReturnParameterMembership	visibility	636ccb1079f3a1bc	157	81
+ReturnParameterMembership	aliasIds	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	declaredName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	declaredShortName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	documentation	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	elementId	d2429676a15894b4	1829	1829
+ReturnParameterMembership	isImplied	1deb706c8e3d7768	1829	1672
+ReturnParameterMembership	isImpliedIncluded	32cadb5505e14129	1829	1829
+ReturnParameterMembership	isLibraryElement	815ed28d0788057b	1829	23
+ReturnParameterMembership	memberElement	91373818088b3242	1829	1829
+ReturnParameterMembership	memberElementId	52a8a8243c23c4ff	1829	1829
+ReturnParameterMembership	memberName	fc18ac8e965c9142	1829	1829
+ReturnParameterMembership	memberShortName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	membershipOwningNamespace	fa2a1a86071e3889	1829	1829
+ReturnParameterMembership	name	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	ownedAnnotation	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	ownedElement	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	ownedMemberElement	91373818088b3242	1829	1829
+ReturnParameterMembership	ownedMemberElementId	52a8a8243c23c4ff	1829	1829
+ReturnParameterMembership	ownedMemberFeature	91373818088b3242	1829	1829
+ReturnParameterMembership	ownedMemberName	725641865c24d8cf	1829	1829
+ReturnParameterMembership	ownedMemberParameter	91373818088b3242	1829	1829
+ReturnParameterMembership	ownedMemberShortName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	ownedRelatedElement	b9111d4e512fc610	1829	1829
+ReturnParameterMembership	ownedRelationship	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	owner	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	owningMembership	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	owningNamespace	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	owningRelatedElement	fa2a1a86071e3889	1829	1829
+ReturnParameterMembership	owningRelationship	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	owningType	fa2a1a86071e3889	1829	1829
+ReturnParameterMembership	qualifiedName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	relatedElement	553d95e64f94035a	1829	1829
+ReturnParameterMembership	shortName	113c63dd0c96cd48	1829	0
+ReturnParameterMembership	source	c7795ebe194e1909	1829	1829
+ReturnParameterMembership	target	b9111d4e512fc610	1829	1829
+ReturnParameterMembership	textualRepresentation	38fb662cfb5445f1	1829	0
+ReturnParameterMembership	visibility	11e0aa4c66640c1e	1829	1829
 SatisfyRequirementUsage	actorParameter	68885785a8e480da	22	0
 SatisfyRequirementUsage	aliasIds	68885785a8e480da	22	0
 SatisfyRequirementUsage	assertedConstraint	b50c142a1f184a64	22	18
@@ -8201,14 +8286,14 @@ SatisfyRequirementUsage	isConstant	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isDerived	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isEnd	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isImpliedIncluded	56b1065cf1cb9f2a	22	22
-SatisfyRequirementUsage	isIndividual	15305e32408be798	22	0
+SatisfyRequirementUsage	isIndividual	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isLibraryElement	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isModelLevelEvaluable	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isNegated	b966054c5f0c6916	22	2
 SatisfyRequirementUsage	isOrdered	b5c3ffc32dd2eeec	22	0
-SatisfyRequirementUsage	isPortion	15305e32408be798	22	0
+SatisfyRequirementUsage	isPortion	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isReference	cdf785f87b5b2cbb	22	3
-SatisfyRequirementUsage	isSufficient	15305e32408be798	22	0
+SatisfyRequirementUsage	isSufficient	b5c3ffc32dd2eeec	22	0
 SatisfyRequirementUsage	isUnique	56b1065cf1cb9f2a	22	22
 SatisfyRequirementUsage	isVariable	15305e32408be798	22	0
 SatisfyRequirementUsage	isVariation	b5c3ffc32dd2eeec	22	0
@@ -8216,7 +8301,7 @@ SatisfyRequirementUsage	mayTimeVary	15305e32408be798	22	0
 SatisfyRequirementUsage	member	f06175302d33e2b8	22	19
 SatisfyRequirementUsage	membership	9c21c5a2f2556fc0	22	19
 SatisfyRequirementUsage	multiplicity	15305e32408be798	22	0
-SatisfyRequirementUsage	name	b90dece13c3e1501	22	22
+SatisfyRequirementUsage	name	56702bd2010e6455	22	4
 SatisfyRequirementUsage	nestedAction	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedAllocation	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedAnalysisCase	68885785a8e480da	22	0
@@ -8228,7 +8313,7 @@ SatisfyRequirementUsage	nestedConnection	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedConstraint	9e020885911bc758	22	2
 SatisfyRequirementUsage	nestedEnumeration	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedFlow	68885785a8e480da	22	0
-SatisfyRequirementUsage	nestedInterface	0bd80be9160b9486	22	19
+SatisfyRequirementUsage	nestedInterface	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedItem	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedMetadata	68885785a8e480da	22	0
 SatisfyRequirementUsage	nestedOccurrence	9e020885911bc758	22	2
@@ -8263,9 +8348,9 @@ SatisfyRequirementUsage	ownedMember	f06175302d33e2b8	22	19
 SatisfyRequirementUsage	ownedMembership	9c21c5a2f2556fc0	22	19
 SatisfyRequirementUsage	ownedRedefinition	68885785a8e480da	22	0
 SatisfyRequirementUsage	ownedReferenceSubsetting	69fba36d6cd0045f	22	18
-SatisfyRequirementUsage	ownedRelationship	9cd6fb3ede5a21d9	22	22
-SatisfyRequirementUsage	ownedSpecialization	716075834ece7a23	22	22
-SatisfyRequirementUsage	ownedSubsetting	9494554511d4b7c2	22	22
+SatisfyRequirementUsage	ownedRelationship	a0d768066393e4d8	22	22
+SatisfyRequirementUsage	ownedSpecialization	93aa15168e32e1ce	22	22
+SatisfyRequirementUsage	ownedSubsetting	083c739e9afe6ad3	22	22
 SatisfyRequirementUsage	ownedTypeFeaturing	68885785a8e480da	22	0
 SatisfyRequirementUsage	ownedTyping	fa1b2ce4e192e967	22	4
 SatisfyRequirementUsage	ownedUnioning	68885785a8e480da	22	0
@@ -8280,7 +8365,7 @@ SatisfyRequirementUsage	owningUsage	fc471a22b82bb5ac	22	18
 SatisfyRequirementUsage	parameter	0bd80be9160b9486	22	19
 SatisfyRequirementUsage	portionKind	15305e32408be798	22	0
 SatisfyRequirementUsage	predicate	18ec518fed14c1b7	22	9
-SatisfyRequirementUsage	qualifiedName	49e78b2893038473	22	22
+SatisfyRequirementUsage	qualifiedName	9e9fdb8a5e40ddc1	22	4
 SatisfyRequirementUsage	reqId	15305e32408be798	22	0
 SatisfyRequirementUsage	requiredConstraint	68885785a8e480da	22	0
 SatisfyRequirementUsage	requirementDefinition	18ec518fed14c1b7	22	9
@@ -8322,20 +8407,20 @@ SelectExpression	inheritedMembership	7da4538739bb7b2d	2	0
 SelectExpression	input	d8166efcda9dd721	2	2
 SelectExpression	instantiatedType	3c327fac034bfc91	2	2
 SelectExpression	intersectingType	7da4538739bb7b2d	2	0
-SelectExpression	isAbstract	f613db5daf2145dd	2	0
-SelectExpression	isComposite	f613db5daf2145dd	2	0
+SelectExpression	isAbstract	50d4e5c4b410aaff	2	0
+SelectExpression	isComposite	50d4e5c4b410aaff	2	0
 SelectExpression	isConjugated	50d4e5c4b410aaff	2	0
-SelectExpression	isConstant	f613db5daf2145dd	2	0
-SelectExpression	isDerived	f613db5daf2145dd	2	0
-SelectExpression	isEnd	f613db5daf2145dd	2	0
+SelectExpression	isConstant	50d4e5c4b410aaff	2	0
+SelectExpression	isDerived	50d4e5c4b410aaff	2	0
+SelectExpression	isEnd	50d4e5c4b410aaff	2	0
 SelectExpression	isImpliedIncluded	f3bc82fd5128f3b9	2	2
 SelectExpression	isLibraryElement	50d4e5c4b410aaff	2	0
 SelectExpression	isModelLevelEvaluable	50d4e5c4b410aaff	2	0
-SelectExpression	isOrdered	f613db5daf2145dd	2	0
-SelectExpression	isPortion	f613db5daf2145dd	2	0
-SelectExpression	isSufficient	f613db5daf2145dd	2	0
-SelectExpression	isUnique	f613db5daf2145dd	2	0
-SelectExpression	isVariable	f613db5daf2145dd	2	0
+SelectExpression	isOrdered	50d4e5c4b410aaff	2	0
+SelectExpression	isPortion	50d4e5c4b410aaff	2	0
+SelectExpression	isSufficient	50d4e5c4b410aaff	2	0
+SelectExpression	isUnique	f3bc82fd5128f3b9	2	2
+SelectExpression	isVariable	50d4e5c4b410aaff	2	0
 SelectExpression	member	d8166efcda9dd721	2	2
 SelectExpression	membership	077200833aa00eae	2	2
 SelectExpression	multiplicity	f613db5daf2145dd	2	0
@@ -8359,9 +8444,9 @@ SelectExpression	ownedMember	d8166efcda9dd721	2	2
 SelectExpression	ownedMembership	077200833aa00eae	2	2
 SelectExpression	ownedRedefinition	7da4538739bb7b2d	2	0
 SelectExpression	ownedReferenceSubsetting	f613db5daf2145dd	2	0
-SelectExpression	ownedRelationship	077200833aa00eae	2	2
-SelectExpression	ownedSpecialization	7da4538739bb7b2d	2	0
-SelectExpression	ownedSubsetting	7da4538739bb7b2d	2	0
+SelectExpression	ownedRelationship	c573df32fc42272c	2	2
+SelectExpression	ownedSpecialization	878e9de7e5e2a0db	2	2
+SelectExpression	ownedSubsetting	878e9de7e5e2a0db	2	2
 SelectExpression	ownedTypeFeaturing	7da4538739bb7b2d	2	0
 SelectExpression	ownedTyping	7da4538739bb7b2d	2	0
 SelectExpression	ownedUnioning	7da4538739bb7b2d	2	0
@@ -8411,12 +8496,12 @@ SendActionUsage	isConstant	e364447561063eda	37	0
 SendActionUsage	isDerived	e364447561063eda	37	0
 SendActionUsage	isEnd	e364447561063eda	37	0
 SendActionUsage	isImpliedIncluded	0f05fa8dcdeef3f3	37	37
-SendActionUsage	isIndividual	794ee8b26bff4de2	37	0
+SendActionUsage	isIndividual	e364447561063eda	37	0
 SendActionUsage	isLibraryElement	e364447561063eda	37	0
 SendActionUsage	isOrdered	e364447561063eda	37	0
-SendActionUsage	isPortion	794ee8b26bff4de2	37	0
+SendActionUsage	isPortion	e364447561063eda	37	0
 SendActionUsage	isReference	e364447561063eda	37	0
-SendActionUsage	isSufficient	794ee8b26bff4de2	37	0
+SendActionUsage	isSufficient	e364447561063eda	37	0
 SendActionUsage	isUnique	0f05fa8dcdeef3f3	37	37
 SendActionUsage	isVariable	794ee8b26bff4de2	37	0
 SendActionUsage	isVariation	e364447561063eda	37	0
@@ -8436,7 +8521,7 @@ SendActionUsage	nestedConnection	0f31877d531b5a83	37	0
 SendActionUsage	nestedConstraint	0f31877d531b5a83	37	0
 SendActionUsage	nestedEnumeration	0f31877d531b5a83	37	0
 SendActionUsage	nestedFlow	0f31877d531b5a83	37	0
-SendActionUsage	nestedInterface	f6db1b8ae9ca8353	37	37
+SendActionUsage	nestedInterface	0f31877d531b5a83	37	0
 SendActionUsage	nestedItem	0f31877d531b5a83	37	0
 SendActionUsage	nestedMetadata	0f31877d531b5a83	37	0
 SendActionUsage	nestedOccurrence	0f31877d531b5a83	37	0
@@ -8559,7 +8644,7 @@ StateDefinition	intersectingType	b54b27bfaaefbbed	17	0
 StateDefinition	isAbstract	12e739ded7d68520	17	0
 StateDefinition	isConjugated	12e739ded7d68520	17	0
 StateDefinition	isImpliedIncluded	882454254121474d	17	17
-StateDefinition	isIndividual	36b99177e665b758	17	0
+StateDefinition	isIndividual	12e739ded7d68520	17	0
 StateDefinition	isLibraryElement	12e739ded7d68520	17	0
 StateDefinition	isParallel	12e739ded7d68520	17	0
 StateDefinition	isSufficient	12e739ded7d68520	17	0
@@ -8589,7 +8674,7 @@ StateDefinition	ownedFeature	cb8b769c22a0fa64	17	5
 StateDefinition	ownedFeatureMembership	30ff3ad55c55aa40	17	5
 StateDefinition	ownedFlow	b54b27bfaaefbbed	17	0
 StateDefinition	ownedImport	b54b27bfaaefbbed	17	0
-StateDefinition	ownedInterface	5a296b3106b3e579	17	1
+StateDefinition	ownedInterface	b54b27bfaaefbbed	17	0
 StateDefinition	ownedIntersecting	b54b27bfaaefbbed	17	0
 StateDefinition	ownedItem	2ffea806ddff9cdf	17	1
 StateDefinition	ownedMember	cb8b769c22a0fa64	17	5
@@ -8700,13 +8785,13 @@ StateUsage	isConstant	f72fb195fb17de6a	131	0
 StateUsage	isDerived	f72fb195fb17de6a	131	0
 StateUsage	isEnd	f72fb195fb17de6a	131	0
 StateUsage	isImpliedIncluded	bff5fbc326def531	131	131
-StateUsage	isIndividual	d0fc20f6ef15294e	131	0
+StateUsage	isIndividual	f72fb195fb17de6a	131	0
 StateUsage	isLibraryElement	f72fb195fb17de6a	131	0
 StateUsage	isOrdered	f72fb195fb17de6a	131	0
 StateUsage	isParallel	f452c03d920a8b52	131	8
-StateUsage	isPortion	d0fc20f6ef15294e	131	0
+StateUsage	isPortion	f72fb195fb17de6a	131	0
 StateUsage	isReference	db582c0db6f2a937	131	17
-StateUsage	isSufficient	d0fc20f6ef15294e	131	0
+StateUsage	isSufficient	f72fb195fb17de6a	131	0
 StateUsage	isUnique	784b6847fcab1e74	131	130
 StateUsage	isVariable	d0fc20f6ef15294e	131	0
 StateUsage	isVariation	f72fb195fb17de6a	131	0
@@ -8726,7 +8811,7 @@ StateUsage	nestedConnection	bcbcb0140157754d	131	14
 StateUsage	nestedConstraint	883afceb430a7102	131	3
 StateUsage	nestedEnumeration	a920af2ca7526091	131	0
 StateUsage	nestedFlow	a920af2ca7526091	131	0
-StateUsage	nestedInterface	ecc89223ce9ee131	131	5
+StateUsage	nestedInterface	a920af2ca7526091	131	0
 StateUsage	nestedItem	a920af2ca7526091	131	0
 StateUsage	nestedMetadata	a920af2ca7526091	131	0
 StateUsage	nestedOccurrence	c91c0e30a0c6778f	131	49
@@ -8761,9 +8846,9 @@ StateUsage	ownedMember	fd12fa3e9019bd98	131	51
 StateUsage	ownedMembership	689df57dfa7cbb60	131	51
 StateUsage	ownedRedefinition	a920af2ca7526091	131	0
 StateUsage	ownedReferenceSubsetting	d0fc20f6ef15294e	131	0
-StateUsage	ownedRelationship	9945282fc2292d7a	131	131
-StateUsage	ownedSpecialization	a402c21118bb2235	131	131
-StateUsage	ownedSubsetting	570ce413940316b9	131	131
+StateUsage	ownedRelationship	fef282b76875285a	131	131
+StateUsage	ownedSpecialization	40eb496da3274315	131	131
+StateUsage	ownedSubsetting	f3f56b701e6f3799	131	131
 StateUsage	ownedTypeFeaturing	a920af2ca7526091	131	0
 StateUsage	ownedTyping	f2b61fb1d025230f	131	11
 StateUsage	ownedUnioning	a920af2ca7526091	131	0
@@ -8786,36 +8871,36 @@ StateUsage	unioningType	a920af2ca7526091	131	0
 StateUsage	usage	95e2dfb83096022d	131	49
 StateUsage	variant	a920af2ca7526091	131	0
 StateUsage	variantMembership	a920af2ca7526091	131	0
-Subclassification	aliasIds	462ecda113f17213	1151	0
-Subclassification	declaredName	52a7a144febaf5a4	1151	0
-Subclassification	declaredShortName	52a7a144febaf5a4	1151	0
-Subclassification	documentation	462ecda113f17213	1151	0
-Subclassification	elementId	0ac6c92666fefcc0	1151	1151
-Subclassification	general	a3c86d894e5d6915	1151	1151
-Subclassification	isImplied	1fea74f056634ad2	1151	898
-Subclassification	isImpliedIncluded	3b51657e29b1edc3	1151	1151
-Subclassification	isLibraryElement	710e381d67c05b9a	1151	58
-Subclassification	name	52a7a144febaf5a4	1151	0
-Subclassification	ownedAnnotation	462ecda113f17213	1151	0
-Subclassification	ownedElement	462ecda113f17213	1151	0
-Subclassification	ownedRelatedElement	462ecda113f17213	1151	0
-Subclassification	ownedRelationship	462ecda113f17213	1151	0
-Subclassification	owner	52a7a144febaf5a4	1151	0
-Subclassification	owningClassifier	82cb232410ebc59b	1151	1151
-Subclassification	owningMembership	52a7a144febaf5a4	1151	0
-Subclassification	owningNamespace	52a7a144febaf5a4	1151	0
-Subclassification	owningRelatedElement	82cb232410ebc59b	1151	1151
-Subclassification	owningRelationship	52a7a144febaf5a4	1151	0
-Subclassification	owningType	82cb232410ebc59b	1151	1151
-Subclassification	qualifiedName	52a7a144febaf5a4	1151	0
-Subclassification	relatedElement	dcddd7a1ec8c4749	1151	1151
-Subclassification	shortName	52a7a144febaf5a4	1151	0
-Subclassification	source	a207debe43f54c67	1151	1151
-Subclassification	specific	82cb232410ebc59b	1151	1151
-Subclassification	subclassifier	82cb232410ebc59b	1151	1151
-Subclassification	superclassifier	a3c86d894e5d6915	1151	1151
-Subclassification	target	a465d718b3b7de31	1151	1151
-Subclassification	textualRepresentation	462ecda113f17213	1151	0
+Subclassification	aliasIds	2323d195c850f6da	1183	0
+Subclassification	declaredName	20d79e5e9cdffd85	1183	0
+Subclassification	declaredShortName	20d79e5e9cdffd85	1183	0
+Subclassification	documentation	2323d195c850f6da	1183	0
+Subclassification	elementId	1d06019d0066d644	1183	1183
+Subclassification	general	1d358ed4f996eb95	1183	1183
+Subclassification	isImplied	b48bb28393c6a3d5	1183	930
+Subclassification	isImpliedIncluded	cff2a311671546c6	1183	1183
+Subclassification	isLibraryElement	595e37ab47355d12	1183	75
+Subclassification	name	20d79e5e9cdffd85	1183	0
+Subclassification	ownedAnnotation	2323d195c850f6da	1183	0
+Subclassification	ownedElement	2323d195c850f6da	1183	0
+Subclassification	ownedRelatedElement	2323d195c850f6da	1183	0
+Subclassification	ownedRelationship	2323d195c850f6da	1183	0
+Subclassification	owner	20d79e5e9cdffd85	1183	0
+Subclassification	owningClassifier	fab7e80027cc1d1e	1183	1183
+Subclassification	owningMembership	20d79e5e9cdffd85	1183	0
+Subclassification	owningNamespace	20d79e5e9cdffd85	1183	0
+Subclassification	owningRelatedElement	fab7e80027cc1d1e	1183	1183
+Subclassification	owningRelationship	20d79e5e9cdffd85	1183	0
+Subclassification	owningType	fab7e80027cc1d1e	1183	1183
+Subclassification	qualifiedName	20d79e5e9cdffd85	1183	0
+Subclassification	relatedElement	20e78c57aafdad3d	1183	1183
+Subclassification	shortName	20d79e5e9cdffd85	1183	0
+Subclassification	source	e44de99f5dc09cd6	1183	1183
+Subclassification	specific	fab7e80027cc1d1e	1183	1183
+Subclassification	subclassifier	fab7e80027cc1d1e	1183	1183
+Subclassification	superclassifier	1d358ed4f996eb95	1183	1183
+Subclassification	target	d8f2f8d5869779af	1183	1183
+Subclassification	textualRepresentation	2323d195c850f6da	1183	0
 SubjectMembership	aliasIds	13ef2b698bc8406b	122	0
 SubjectMembership	declaredName	ab175383ef2eb23b	122	0
 SubjectMembership	declaredShortName	ab175383ef2eb23b	122	0
@@ -8835,7 +8920,7 @@ SubjectMembership	ownedElement	13ef2b698bc8406b	122	0
 SubjectMembership	ownedMemberElement	6a62627be86e27ef	122	122
 SubjectMembership	ownedMemberElementId	4a18cda493cd881b	122	122
 SubjectMembership	ownedMemberFeature	6a62627be86e27ef	122	122
-SubjectMembership	ownedMemberName	d3b62ff4afae6427	122	122
+SubjectMembership	ownedMemberName	2947186b9120ac9f	122	122
 SubjectMembership	ownedMemberParameter	6a62627be86e27ef	122	122
 SubjectMembership	ownedMemberShortName	ab175383ef2eb23b	122	0
 SubjectMembership	ownedRelatedElement	2df48626c8fdde57	122	122
@@ -8853,37 +8938,37 @@ SubjectMembership	shortName	ab175383ef2eb23b	122	0
 SubjectMembership	source	865660f3bc6f5abe	122	122
 SubjectMembership	target	2df48626c8fdde57	122	122
 SubjectMembership	textualRepresentation	13ef2b698bc8406b	122	0
-SubjectMembership	visibility	75a79b2d6684c37d	122	103
-Subsetting	aliasIds	cdd7bc01dd3a2b36	3167	0
-Subsetting	declaredName	d802aee440a539ad	3167	0
-Subsetting	declaredShortName	d802aee440a539ad	3167	0
-Subsetting	documentation	cdd7bc01dd3a2b36	3167	0
-Subsetting	elementId	02f40e17d77d17ac	3167	3167
-Subsetting	general	43a56166e5d279a6	3167	3167
-Subsetting	isImplied	0678e514d4e8007c	3167	2761
-Subsetting	isImpliedIncluded	a31107e00ccc6f7a	3167	3167
-Subsetting	isLibraryElement	f6650ca5b043772b	3167	52
-Subsetting	name	d802aee440a539ad	3167	0
-Subsetting	ownedAnnotation	cdd7bc01dd3a2b36	3167	0
-Subsetting	ownedElement	0bce73257f3dea59	3167	6
-Subsetting	ownedRelatedElement	dbe54c3fc5d47f8d	3167	8
-Subsetting	ownedRelationship	650a174e260c1271	3167	6
-Subsetting	owner	d802aee440a539ad	3167	0
-Subsetting	owningFeature	2bed2cba045fca8c	3167	3167
-Subsetting	owningMembership	d802aee440a539ad	3167	0
-Subsetting	owningNamespace	d802aee440a539ad	3167	0
-Subsetting	owningRelatedElement	2bed2cba045fca8c	3167	3167
-Subsetting	owningRelationship	d802aee440a539ad	3167	0
-Subsetting	owningType	2bed2cba045fca8c	3167	3167
-Subsetting	qualifiedName	d802aee440a539ad	3167	0
-Subsetting	relatedElement	e0b2473f8f8f47d2	3167	3167
-Subsetting	shortName	d802aee440a539ad	3167	0
-Subsetting	source	c9c01831a7a5fc34	3167	3167
-Subsetting	specific	2bed2cba045fca8c	3167	3167
-Subsetting	subsettedFeature	43a56166e5d279a6	3167	3167
-Subsetting	subsettingFeature	2bed2cba045fca8c	3167	3167
-Subsetting	target	c156476cd4745d0a	3167	3167
-Subsetting	textualRepresentation	0bce73257f3dea59	3167	6
+SubjectMembership	visibility	1a92db910434fccb	122	122
+Subsetting	aliasIds	26d70a5b708fa2f1	15615	0
+Subsetting	declaredName	62fd3b717d8dd4ae	15615	0
+Subsetting	declaredShortName	62fd3b717d8dd4ae	15615	0
+Subsetting	documentation	26d70a5b708fa2f1	15615	0
+Subsetting	elementId	64615a9ca01a5c98	15615	15615
+Subsetting	general	c08ae52cf93900e2	15615	15615
+Subsetting	isImplied	fbec7fb7d614fb4b	15615	15209
+Subsetting	isImpliedIncluded	9884a2830df96a49	15615	15615
+Subsetting	isLibraryElement	1c7646c49f0fdb9d	15615	283
+Subsetting	name	62fd3b717d8dd4ae	15615	0
+Subsetting	ownedAnnotation	26d70a5b708fa2f1	15615	0
+Subsetting	ownedElement	64cdc17f12936214	15615	6
+Subsetting	ownedRelatedElement	34e49a995929f748	15615	8
+Subsetting	ownedRelationship	be0965a7b9618a2c	15615	6
+Subsetting	owner	62fd3b717d8dd4ae	15615	0
+Subsetting	owningFeature	fd16c80ae733f88f	15615	15615
+Subsetting	owningMembership	62fd3b717d8dd4ae	15615	0
+Subsetting	owningNamespace	62fd3b717d8dd4ae	15615	0
+Subsetting	owningRelatedElement	fd16c80ae733f88f	15615	15615
+Subsetting	owningRelationship	62fd3b717d8dd4ae	15615	0
+Subsetting	owningType	fd16c80ae733f88f	15615	15615
+Subsetting	qualifiedName	62fd3b717d8dd4ae	15615	0
+Subsetting	relatedElement	4e502b4b60476ce8	15615	15615
+Subsetting	shortName	62fd3b717d8dd4ae	15615	0
+Subsetting	source	a6c66da444c5fb63	15615	15615
+Subsetting	specific	fd16c80ae733f88f	15615	15615
+Subsetting	subsettedFeature	c08ae52cf93900e2	15615	15615
+Subsetting	subsettingFeature	fd16c80ae733f88f	15615	15615
+Subsetting	target	1262e10afba1b748	15615	15615
+Subsetting	textualRepresentation	64cdc17f12936214	15615	6
 SuccessionAsUsage	aliasIds	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	association	c4376bd39c895bd4	356	2
 SuccessionAsUsage	chainingFeature	d5400e2f88ea9a92	356	0
@@ -8891,7 +8976,7 @@ SuccessionAsUsage	connectorEnd	8c7030b92a19e9a7	356	356
 SuccessionAsUsage	crossFeature	012077da79fc58ca	356	0
 SuccessionAsUsage	declaredName	36ab6ad4428a518d	356	2
 SuccessionAsUsage	declaredShortName	012077da79fc58ca	356	0
-SuccessionAsUsage	defaultFeaturingType	cfdd98a2201c4f1c	356	218
+SuccessionAsUsage	defaultFeaturingType	9a746ad2df2f7a3f	356	356
 SuccessionAsUsage	definition	c4376bd39c895bd4	356	2
 SuccessionAsUsage	differencingType	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	directedFeature	d5400e2f88ea9a92	356	0
@@ -8910,20 +8995,20 @@ SuccessionAsUsage	inheritedFeature	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	inheritedMembership	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	input	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	intersectingType	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	isAbstract	9e7dbb2f8a89d02a	356	0
+SuccessionAsUsage	isAbstract	b6a2658f4713cabe	356	0
 SuccessionAsUsage	isComposite	b6a2658f4713cabe	356	0
 SuccessionAsUsage	isConjugated	b6a2658f4713cabe	356	0
-SuccessionAsUsage	isConstant	9e7dbb2f8a89d02a	356	0
-SuccessionAsUsage	isDerived	9e7dbb2f8a89d02a	356	0
-SuccessionAsUsage	isEnd	9e7dbb2f8a89d02a	356	0
-SuccessionAsUsage	isImplied	012077da79fc58ca	356	0
+SuccessionAsUsage	isConstant	b6a2658f4713cabe	356	0
+SuccessionAsUsage	isDerived	b6a2658f4713cabe	356	0
+SuccessionAsUsage	isEnd	b6a2658f4713cabe	356	0
+SuccessionAsUsage	isImplied	b6a2658f4713cabe	356	0
 SuccessionAsUsage	isImpliedIncluded	42d1c513cb61a322	356	356
 SuccessionAsUsage	isLibraryElement	b6a2658f4713cabe	356	0
-SuccessionAsUsage	isOrdered	9e7dbb2f8a89d02a	356	0
-SuccessionAsUsage	isPortion	012077da79fc58ca	356	0
+SuccessionAsUsage	isOrdered	b6a2658f4713cabe	356	0
+SuccessionAsUsage	isPortion	b6a2658f4713cabe	356	0
 SuccessionAsUsage	isReference	42d1c513cb61a322	356	356
-SuccessionAsUsage	isSufficient	012077da79fc58ca	356	0
-SuccessionAsUsage	isUnique	07eca5a3f5660a21	356	107
+SuccessionAsUsage	isSufficient	b6a2658f4713cabe	356	0
+SuccessionAsUsage	isUnique	42d1c513cb61a322	356	356
 SuccessionAsUsage	isVariable	012077da79fc58ca	356	0
 SuccessionAsUsage	isVariation	b6a2658f4713cabe	356	0
 SuccessionAsUsage	mayTimeVary	012077da79fc58ca	356	0
@@ -8942,7 +9027,7 @@ SuccessionAsUsage	nestedConnection	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedConstraint	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedEnumeration	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedFlow	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	nestedInterface	8c7030b92a19e9a7	356	356
+SuccessionAsUsage	nestedInterface	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedItem	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedMetadata	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	nestedOccurrence	d5400e2f88ea9a92	356	0
@@ -8977,9 +9062,9 @@ SuccessionAsUsage	ownedMembership	877e06218e4285ba	356	356
 SuccessionAsUsage	ownedRedefinition	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	ownedReferenceSubsetting	012077da79fc58ca	356	0
 SuccessionAsUsage	ownedRelatedElement	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	ownedRelationship	7812a74b6c3aa4aa	356	356
-SuccessionAsUsage	ownedSpecialization	c60973f7965c7e66	356	2
-SuccessionAsUsage	ownedSubsetting	d5400e2f88ea9a92	356	0
+SuccessionAsUsage	ownedRelationship	285f9d3310657c90	356	356
+SuccessionAsUsage	ownedSpecialization	843733ffef3e7990	356	356
+SuccessionAsUsage	ownedSubsetting	e409fc2a179e2980	356	356
 SuccessionAsUsage	ownedTypeFeaturing	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	ownedTyping	c60973f7965c7e66	356	2
 SuccessionAsUsage	ownedUnioning	d5400e2f88ea9a92	356	0
@@ -8993,13 +9078,13 @@ SuccessionAsUsage	owningRelationship	40a4315b27313067	356	356
 SuccessionAsUsage	owningType	638d27ea01b3830a	356	245
 SuccessionAsUsage	owningUsage	d8ac5a6d01571977	356	195
 SuccessionAsUsage	qualifiedName	a10c5b10da92029f	356	2
-SuccessionAsUsage	relatedElement	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	relatedFeature	2c4fce7aa318d8e6	356	218
+SuccessionAsUsage	relatedElement	2ee683170a58ee05	356	356
+SuccessionAsUsage	relatedFeature	2ee683170a58ee05	356	356
 SuccessionAsUsage	shortName	012077da79fc58ca	356	0
-SuccessionAsUsage	source	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	sourceFeature	f724583f95bacdc4	356	218
-SuccessionAsUsage	target	d5400e2f88ea9a92	356	0
-SuccessionAsUsage	targetFeature	afb235c93d6ab67a	356	55
+SuccessionAsUsage	source	bc747b4c352fdd9a	356	285
+SuccessionAsUsage	sourceFeature	a0660033dd65d53b	356	285
+SuccessionAsUsage	target	43d45b857ed9b6d9	356	356
+SuccessionAsUsage	targetFeature	43d45b857ed9b6d9	356	356
 SuccessionAsUsage	textualRepresentation	d5400e2f88ea9a92	356	0
 SuccessionAsUsage	type	c4376bd39c895bd4	356	2
 SuccessionAsUsage	unioningType	d5400e2f88ea9a92	356	0
@@ -9044,14 +9129,14 @@ SuccessionFlowUsage	isConjugated	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isConstant	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isDerived	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isEnd	cb289e8ed617283b	4	0
-SuccessionFlowUsage	isImplied	92150e0a7bf2a241	4	0
+SuccessionFlowUsage	isImplied	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isImpliedIncluded	2e66253feab21bbf	4	4
-SuccessionFlowUsage	isIndividual	92150e0a7bf2a241	4	0
+SuccessionFlowUsage	isIndividual	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isLibraryElement	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isOrdered	cb289e8ed617283b	4	0
-SuccessionFlowUsage	isPortion	92150e0a7bf2a241	4	0
+SuccessionFlowUsage	isPortion	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isReference	cb289e8ed617283b	4	0
-SuccessionFlowUsage	isSufficient	92150e0a7bf2a241	4	0
+SuccessionFlowUsage	isSufficient	cb289e8ed617283b	4	0
 SuccessionFlowUsage	isUnique	2e66253feab21bbf	4	4
 SuccessionFlowUsage	isVariable	92150e0a7bf2a241	4	0
 SuccessionFlowUsage	isVariation	cb289e8ed617283b	4	0
@@ -9107,9 +9192,9 @@ SuccessionFlowUsage	ownedMembership	8798b973d8c0f0bd	4	4
 SuccessionFlowUsage	ownedRedefinition	1a16647131364873	4	0
 SuccessionFlowUsage	ownedReferenceSubsetting	92150e0a7bf2a241	4	0
 SuccessionFlowUsage	ownedRelatedElement	1a16647131364873	4	0
-SuccessionFlowUsage	ownedRelationship	6675855455139686	4	4
-SuccessionFlowUsage	ownedSpecialization	0e80f570bb0530a0	4	4
-SuccessionFlowUsage	ownedSubsetting	0e80f570bb0530a0	4	4
+SuccessionFlowUsage	ownedRelationship	827fa3db8368651c	4	4
+SuccessionFlowUsage	ownedSpecialization	95c7c173b50096a0	4	4
+SuccessionFlowUsage	ownedSubsetting	95c7c173b50096a0	4	4
 SuccessionFlowUsage	ownedTypeFeaturing	1a16647131364873	4	0
 SuccessionFlowUsage	ownedTyping	1a16647131364873	4	0
 SuccessionFlowUsage	ownedUnioning	1a16647131364873	4	0
@@ -9127,13 +9212,13 @@ SuccessionFlowUsage	payloadFeature	92150e0a7bf2a241	4	0
 SuccessionFlowUsage	payloadType	1a16647131364873	4	0
 SuccessionFlowUsage	portionKind	92150e0a7bf2a241	4	0
 SuccessionFlowUsage	qualifiedName	d50748fde18fd1cf	4	2
-SuccessionFlowUsage	relatedElement	1a16647131364873	4	0
+SuccessionFlowUsage	relatedElement	eff36c57baf34f35	4	4
 SuccessionFlowUsage	relatedFeature	eff36c57baf34f35	4	4
 SuccessionFlowUsage	shortName	92150e0a7bf2a241	4	0
-SuccessionFlowUsage	source	1a16647131364873	4	0
+SuccessionFlowUsage	source	fde08b785ab11726	4	4
 SuccessionFlowUsage	sourceFeature	98515f5218d1c97c	4	4
 SuccessionFlowUsage	sourceOutputFeature	609d29cb4c2fa7ab	4	4
-SuccessionFlowUsage	target	1a16647131364873	4	0
+SuccessionFlowUsage	target	38bf899553dc5542	4	4
 SuccessionFlowUsage	targetFeature	38bf899553dc5542	4	4
 SuccessionFlowUsage	targetInputFeature	16ff0a5a0926d172	4	4
 SuccessionFlowUsage	textualRepresentation	1a16647131364873	4	0
@@ -9175,12 +9260,12 @@ TerminateActionUsage	isConstant	bb69398771b07dad	6	0
 TerminateActionUsage	isDerived	bb69398771b07dad	6	0
 TerminateActionUsage	isEnd	bb69398771b07dad	6	0
 TerminateActionUsage	isImpliedIncluded	60428e81319bc42b	6	6
-TerminateActionUsage	isIndividual	b67e248bc2758a97	6	0
+TerminateActionUsage	isIndividual	bb69398771b07dad	6	0
 TerminateActionUsage	isLibraryElement	bb69398771b07dad	6	0
 TerminateActionUsage	isOrdered	bb69398771b07dad	6	0
-TerminateActionUsage	isPortion	b67e248bc2758a97	6	0
+TerminateActionUsage	isPortion	bb69398771b07dad	6	0
 TerminateActionUsage	isReference	bb69398771b07dad	6	0
-TerminateActionUsage	isSufficient	b67e248bc2758a97	6	0
+TerminateActionUsage	isSufficient	bb69398771b07dad	6	0
 TerminateActionUsage	isUnique	60428e81319bc42b	6	6
 TerminateActionUsage	isVariable	b67e248bc2758a97	6	0
 TerminateActionUsage	isVariation	bb69398771b07dad	6	0
@@ -9200,7 +9285,7 @@ TerminateActionUsage	nestedConnection	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedConstraint	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedEnumeration	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedFlow	bc05246ed5a395d7	6	0
-TerminateActionUsage	nestedInterface	25e8566260dd7c43	6	3
+TerminateActionUsage	nestedInterface	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedItem	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedMetadata	bc05246ed5a395d7	6	0
 TerminateActionUsage	nestedOccurrence	bc05246ed5a395d7	6	0
@@ -9260,31 +9345,31 @@ TerminateActionUsage	unioningType	bc05246ed5a395d7	6	0
 TerminateActionUsage	usage	25e8566260dd7c43	6	3
 TerminateActionUsage	variant	bc05246ed5a395d7	6	0
 TerminateActionUsage	variantMembership	bc05246ed5a395d7	6	0
-TextualRepresentation	aliasIds	cc7f384e80bcf2a4	91	0
-TextualRepresentation	annotatedElement	5045116fd5e43490	91	91
-TextualRepresentation	annotation	cc7f384e80bcf2a4	91	0
-TextualRepresentation	body	7558077c3f99ea49	91	91
-TextualRepresentation	declaredName	888dbabc419e7589	91	1
-TextualRepresentation	declaredShortName	7cc2e7bcfc261c2f	91	0
-TextualRepresentation	documentation	cc7f384e80bcf2a4	91	0
-TextualRepresentation	elementId	8f62583c8c589568	91	91
-TextualRepresentation	isImpliedIncluded	eb1697f69c479fe8	91	91
-TextualRepresentation	isLibraryElement	89c6220491d34211	91	0
-TextualRepresentation	language	f4677481bc3f7cc6	91	91
-TextualRepresentation	name	888dbabc419e7589	91	1
-TextualRepresentation	ownedAnnotatingRelationship	cc7f384e80bcf2a4	91	0
-TextualRepresentation	ownedAnnotation	cc7f384e80bcf2a4	91	0
-TextualRepresentation	ownedElement	cc7f384e80bcf2a4	91	0
-TextualRepresentation	ownedRelationship	cc7f384e80bcf2a4	91	0
-TextualRepresentation	owner	141a00a481a50e58	91	91
-TextualRepresentation	owningAnnotatingRelationship	7cc2e7bcfc261c2f	91	0
-TextualRepresentation	owningMembership	6c70ef80928dc075	91	91
-TextualRepresentation	owningNamespace	141a00a481a50e58	91	91
-TextualRepresentation	owningRelationship	6c70ef80928dc075	91	91
-TextualRepresentation	qualifiedName	3d5c736455001fb6	91	1
-TextualRepresentation	representedElement	141a00a481a50e58	91	91
-TextualRepresentation	shortName	7cc2e7bcfc261c2f	91	0
-TextualRepresentation	textualRepresentation	cc7f384e80bcf2a4	91	0
+TextualRepresentation	aliasIds	e1f791c919535e6b	46	0
+TextualRepresentation	annotatedElement	d5db23e262623ded	46	46
+TextualRepresentation	annotation	e1f791c919535e6b	46	0
+TextualRepresentation	body	7f5861ed8e364f99	46	46
+TextualRepresentation	declaredName	7b72eb8045a1555d	46	1
+TextualRepresentation	declaredShortName	6fa818810028fc03	46	0
+TextualRepresentation	documentation	e1f791c919535e6b	46	0
+TextualRepresentation	elementId	951cd3522c0df110	46	46
+TextualRepresentation	isImpliedIncluded	43b24ed5e3f76b07	46	46
+TextualRepresentation	isLibraryElement	d25a2a4e34eb48e9	46	0
+TextualRepresentation	language	2997928dfe59361e	46	46
+TextualRepresentation	name	7b72eb8045a1555d	46	1
+TextualRepresentation	ownedAnnotatingRelationship	e1f791c919535e6b	46	0
+TextualRepresentation	ownedAnnotation	e1f791c919535e6b	46	0
+TextualRepresentation	ownedElement	e1f791c919535e6b	46	0
+TextualRepresentation	ownedRelationship	e1f791c919535e6b	46	0
+TextualRepresentation	owner	57f8508e256b295d	46	46
+TextualRepresentation	owningAnnotatingRelationship	6fa818810028fc03	46	0
+TextualRepresentation	owningMembership	f241d1172a30fa1e	46	46
+TextualRepresentation	owningNamespace	57f8508e256b295d	46	46
+TextualRepresentation	owningRelationship	f241d1172a30fa1e	46	46
+TextualRepresentation	qualifiedName	3041a4285902ff8a	46	1
+TextualRepresentation	representedElement	57f8508e256b295d	46	46
+TextualRepresentation	shortName	6fa818810028fc03	46	0
+TextualRepresentation	textualRepresentation	e1f791c919535e6b	46	0
 TransitionFeatureMembership	aliasIds	0b64d66525dd20d3	121	0
 TransitionFeatureMembership	declaredName	d8a8a69e000efbf2	121	0
 TransitionFeatureMembership	declaredShortName	d8a8a69e000efbf2	121	0
@@ -9322,7 +9407,7 @@ TransitionFeatureMembership	source	0d843b6838aecefd	121	121
 TransitionFeatureMembership	target	2238239f6a686d86	121	121
 TransitionFeatureMembership	textualRepresentation	0b64d66525dd20d3	121	0
 TransitionFeatureMembership	transitionFeature	68baa2b1caec201c	121	121
-TransitionFeatureMembership	visibility	d8a8a69e000efbf2	121	0
+TransitionFeatureMembership	visibility	01fb7ffd7acf6b90	121	121
 TransitionUsage	actionDefinition	f9a7ca87f242d57f	111	0
 TransitionUsage	aliasIds	f9a7ca87f242d57f	111	0
 TransitionUsage	behavior	f9a7ca87f242d57f	111	0
@@ -9358,12 +9443,12 @@ TransitionUsage	isConstant	e407cb80643287b4	111	0
 TransitionUsage	isDerived	e407cb80643287b4	111	0
 TransitionUsage	isEnd	e407cb80643287b4	111	0
 TransitionUsage	isImpliedIncluded	5b47a9ebd492ed37	111	111
-TransitionUsage	isIndividual	e8a1c0f7bb6230a0	111	0
+TransitionUsage	isIndividual	e407cb80643287b4	111	0
 TransitionUsage	isLibraryElement	e407cb80643287b4	111	0
 TransitionUsage	isOrdered	e407cb80643287b4	111	0
-TransitionUsage	isPortion	e8a1c0f7bb6230a0	111	0
+TransitionUsage	isPortion	e407cb80643287b4	111	0
 TransitionUsage	isReference	e407cb80643287b4	111	0
-TransitionUsage	isSufficient	e8a1c0f7bb6230a0	111	0
+TransitionUsage	isSufficient	e407cb80643287b4	111	0
 TransitionUsage	isUnique	5b47a9ebd492ed37	111	111
 TransitionUsage	isVariable	e8a1c0f7bb6230a0	111	0
 TransitionUsage	isVariation	e407cb80643287b4	111	0
@@ -9383,7 +9468,7 @@ TransitionUsage	nestedConnection	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedConstraint	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedEnumeration	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedFlow	f9a7ca87f242d57f	111	0
-TransitionUsage	nestedInterface	f10d5764ec8b754e	111	80
+TransitionUsage	nestedInterface	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedItem	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedMetadata	f9a7ca87f242d57f	111	0
 TransitionUsage	nestedOccurrence	9d8ade2413b53cb0	111	82
@@ -9471,25 +9556,25 @@ TriggerInvocationExpression	inheritedMembership	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	input	6a6a643b887551b5	18	18
 TriggerInvocationExpression	instantiatedType	a6d53a07e32d69bc	18	18
 TriggerInvocationExpression	intersectingType	50fbaf39e2c234ef	18	0
-TriggerInvocationExpression	isAbstract	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isComposite	124868eb6a7f3283	18	0
+TriggerInvocationExpression	isAbstract	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isComposite	1d938dca5b647ae1	18	0
 TriggerInvocationExpression	isConjugated	1d938dca5b647ae1	18	0
-TriggerInvocationExpression	isConstant	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isDerived	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isEnd	124868eb6a7f3283	18	0
+TriggerInvocationExpression	isConstant	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isDerived	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isEnd	1d938dca5b647ae1	18	0
 TriggerInvocationExpression	isImpliedIncluded	b6f1e2589d392cd3	18	18
 TriggerInvocationExpression	isLibraryElement	1d938dca5b647ae1	18	0
 TriggerInvocationExpression	isModelLevelEvaluable	1d938dca5b647ae1	18	0
-TriggerInvocationExpression	isOrdered	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isPortion	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isSufficient	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isUnique	124868eb6a7f3283	18	0
-TriggerInvocationExpression	isVariable	124868eb6a7f3283	18	0
+TriggerInvocationExpression	isOrdered	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isPortion	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isSufficient	1d938dca5b647ae1	18	0
+TriggerInvocationExpression	isUnique	b6f1e2589d392cd3	18	18
+TriggerInvocationExpression	isVariable	1d938dca5b647ae1	18	0
 TriggerInvocationExpression	kind	f79b4cb85fca6653	18	18
 TriggerInvocationExpression	member	6a6a643b887551b5	18	18
 TriggerInvocationExpression	membership	6305f23c2da9f348	18	18
 TriggerInvocationExpression	multiplicity	124868eb6a7f3283	18	0
-TriggerInvocationExpression	name	124868eb6a7f3283	18	0
+TriggerInvocationExpression	name	da601d2e4cdbf9fd	18	3
 TriggerInvocationExpression	output	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedAnnotation	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedConjugator	124868eb6a7f3283	18	0
@@ -9506,11 +9591,11 @@ TriggerInvocationExpression	ownedImport	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedIntersecting	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedMember	6a6a643b887551b5	18	18
 TriggerInvocationExpression	ownedMembership	6305f23c2da9f348	18	18
-TriggerInvocationExpression	ownedRedefinition	50fbaf39e2c234ef	18	0
+TriggerInvocationExpression	ownedRedefinition	de901e42e45122b0	18	18
 TriggerInvocationExpression	ownedReferenceSubsetting	124868eb6a7f3283	18	0
-TriggerInvocationExpression	ownedRelationship	6305f23c2da9f348	18	18
-TriggerInvocationExpression	ownedSpecialization	50fbaf39e2c234ef	18	0
-TriggerInvocationExpression	ownedSubsetting	50fbaf39e2c234ef	18	0
+TriggerInvocationExpression	ownedRelationship	88a6896cc438d1f1	18	18
+TriggerInvocationExpression	ownedSpecialization	662cb64d12a224fa	18	18
+TriggerInvocationExpression	ownedSubsetting	662cb64d12a224fa	18	18
 TriggerInvocationExpression	ownedTypeFeaturing	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedTyping	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	ownedUnioning	50fbaf39e2c234ef	18	0
@@ -9527,6 +9612,33 @@ TriggerInvocationExpression	shortName	124868eb6a7f3283	18	0
 TriggerInvocationExpression	textualRepresentation	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	type	50fbaf39e2c234ef	18	0
 TriggerInvocationExpression	unioningType	50fbaf39e2c234ef	18	0
+TypeFeaturing	aliasIds	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	declaredName	35cf6ede2b5011b3	5016	0
+TypeFeaturing	declaredShortName	35cf6ede2b5011b3	5016	0
+TypeFeaturing	documentation	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	elementId	b1d4bb5f49304220	5016	5016
+TypeFeaturing	featureOfType	1916380df9404283	5016	5016
+TypeFeaturing	featuringType	5d28016015ffc24b	5016	5016
+TypeFeaturing	isImplied	2455adb2eb5a83b9	5016	5016
+TypeFeaturing	isImpliedIncluded	2455adb2eb5a83b9	5016	5016
+TypeFeaturing	isLibraryElement	5ac108256cecc609	5016	0
+TypeFeaturing	name	35cf6ede2b5011b3	5016	0
+TypeFeaturing	ownedAnnotation	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	ownedElement	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	ownedRelatedElement	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	ownedRelationship	eb1f17fb26d9ab6d	5016	0
+TypeFeaturing	owner	35cf6ede2b5011b3	5016	0
+TypeFeaturing	owningFeatureOfType	1916380df9404283	5016	5016
+TypeFeaturing	owningMembership	35cf6ede2b5011b3	5016	0
+TypeFeaturing	owningNamespace	35cf6ede2b5011b3	5016	0
+TypeFeaturing	owningRelatedElement	1916380df9404283	5016	5016
+TypeFeaturing	owningRelationship	35cf6ede2b5011b3	5016	0
+TypeFeaturing	qualifiedName	35cf6ede2b5011b3	5016	0
+TypeFeaturing	relatedElement	ba4a94319ee080cb	5016	5016
+TypeFeaturing	shortName	35cf6ede2b5011b3	5016	0
+TypeFeaturing	source	0ca41e32c988b6c3	5016	5016
+TypeFeaturing	target	cf069deec0494b97	5016	5016
+TypeFeaturing	textualRepresentation	eb1f17fb26d9ab6d	5016	0
 Usage	aliasIds	7124f405e7fc7804	55	0
 Usage	chainingFeature	7124f405e7fc7804	55	0
 Usage	crossFeature	b358be3d3f6eea5b	55	0
@@ -9559,9 +9671,9 @@ Usage	isEnd	a3f0e11651bf3eee	55	21
 Usage	isImpliedIncluded	12d554d43f67eb48	55	55
 Usage	isLibraryElement	2b88e0366a5360fb	55	14
 Usage	isOrdered	10cb1016c62d6a95	55	0
-Usage	isPortion	b358be3d3f6eea5b	55	0
+Usage	isPortion	10cb1016c62d6a95	55	0
 Usage	isReference	dbcc6035e54fac36	55	29
-Usage	isSufficient	b358be3d3f6eea5b	55	0
+Usage	isSufficient	10cb1016c62d6a95	55	0
 Usage	isUnique	12d554d43f67eb48	55	55
 Usage	isVariable	e53d23f47d3f10ea	55	21
 Usage	isVariation	10cb1016c62d6a95	55	0
@@ -9569,7 +9681,7 @@ Usage	mayTimeVary	e53d23f47d3f10ea	55	21
 Usage	member	961196f4e342c6b3	55	55
 Usage	membership	b9331f0bcb354240	55	55
 Usage	multiplicity	b358be3d3f6eea5b	55	0
-Usage	name	2773712493333c76	55	55
+Usage	name	c9f688d2423b7c43	55	45
 Usage	nestedAction	a104f706cb113789	55	4
 Usage	nestedAllocation	7124f405e7fc7804	55	0
 Usage	nestedAnalysisCase	7124f405e7fc7804	55	0
@@ -9581,7 +9693,7 @@ Usage	nestedConnection	71788698e95b3e21	55	1
 Usage	nestedConstraint	f62736f3c6c191b6	55	1
 Usage	nestedEnumeration	7124f405e7fc7804	55	0
 Usage	nestedFlow	7124f405e7fc7804	55	0
-Usage	nestedInterface	7800df4719793ff5	55	4
+Usage	nestedInterface	7124f405e7fc7804	55	0
 Usage	nestedItem	4333decdb3c8f62c	55	1
 Usage	nestedMetadata	7124f405e7fc7804	55	0
 Usage	nestedOccurrence	f81624bc75a2cf63	55	6
@@ -9613,11 +9725,11 @@ Usage	ownedImport	7124f405e7fc7804	55	0
 Usage	ownedIntersecting	7124f405e7fc7804	55	0
 Usage	ownedMember	961196f4e342c6b3	55	55
 Usage	ownedMembership	b9331f0bcb354240	55	55
-Usage	ownedRedefinition	80a03df7257185ff	55	2
+Usage	ownedRedefinition	c2b0578667851db6	55	6
 Usage	ownedReferenceSubsetting	001a19ff15471ac1	55	16
-Usage	ownedRelationship	086ed0cb8efbe199	55	55
-Usage	ownedSpecialization	e337b5786b96e097	55	37
-Usage	ownedSubsetting	0869e6e290631d71	55	21
+Usage	ownedRelationship	14721c612e428b78	55	55
+Usage	ownedSpecialization	1003d1338452fd24	55	55
+Usage	ownedSubsetting	7824cd5a3bb7e256	55	55
 Usage	ownedTypeFeaturing	7124f405e7fc7804	55	0
 Usage	ownedTyping	a689d0dfaf2dd0a6	55	17
 Usage	ownedUnioning	7124f405e7fc7804	55	0
@@ -9661,7 +9773,7 @@ UseCaseDefinition	intersectingType	8bd937d1bf3987c4	8	0
 UseCaseDefinition	isAbstract	5573c45512a99a74	8	0
 UseCaseDefinition	isConjugated	5573c45512a99a74	8	0
 UseCaseDefinition	isImpliedIncluded	79e0d9990e6215cc	8	8
-UseCaseDefinition	isIndividual	59061534173d1b48	8	0
+UseCaseDefinition	isIndividual	5573c45512a99a74	8	0
 UseCaseDefinition	isLibraryElement	5573c45512a99a74	8	0
 UseCaseDefinition	isModelLevelEvaluable	5573c45512a99a74	8	0
 UseCaseDefinition	isSufficient	5573c45512a99a74	8	0
@@ -9692,7 +9804,7 @@ UseCaseDefinition	ownedFeature	82a6e617abb4c6ac	8	7
 UseCaseDefinition	ownedFeatureMembership	bfd1abcfcc0c84a5	8	7
 UseCaseDefinition	ownedFlow	8bd937d1bf3987c4	8	0
 UseCaseDefinition	ownedImport	8bd937d1bf3987c4	8	0
-UseCaseDefinition	ownedInterface	961b34a38733eaf1	8	7
+UseCaseDefinition	ownedInterface	8bd937d1bf3987c4	8	0
 UseCaseDefinition	ownedIntersecting	8bd937d1bf3987c4	8	0
 UseCaseDefinition	ownedItem	dec7caf3cabd3889	8	7
 UseCaseDefinition	ownedMember	82a6e617abb4c6ac	8	7
@@ -9749,8 +9861,8 @@ UseCaseUsage	documentation	a285ee2a5d843e24	19	0
 UseCaseUsage	elementId	396524a0e5f04fd8	19	19
 UseCaseUsage	endFeature	a285ee2a5d843e24	19	0
 UseCaseUsage	endOwningType	a9dc2ad030387ca3	19	0
-UseCaseUsage	feature	847130c857bf9586	19	14
-UseCaseUsage	featureMembership	44cf9dc754fc873f	19	14
+UseCaseUsage	feature	995ad9956cb09787	19	14
+UseCaseUsage	featureMembership	19b927c5ee5ffe50	19	14
 UseCaseUsage	featureTarget	6059a2601e140b63	19	0
 UseCaseUsage	featuringType	a285ee2a5d843e24	19	0
 UseCaseUsage	function	a03488b329e7b51e	19	7
@@ -9768,36 +9880,36 @@ UseCaseUsage	isConstant	dbc1da3fb3a85961	19	0
 UseCaseUsage	isDerived	dbc1da3fb3a85961	19	0
 UseCaseUsage	isEnd	dbc1da3fb3a85961	19	0
 UseCaseUsage	isImpliedIncluded	8b4a028b0d2e5240	19	19
-UseCaseUsage	isIndividual	a9dc2ad030387ca3	19	0
+UseCaseUsage	isIndividual	dbc1da3fb3a85961	19	0
 UseCaseUsage	isLibraryElement	dbc1da3fb3a85961	19	0
 UseCaseUsage	isModelLevelEvaluable	dbc1da3fb3a85961	19	0
 UseCaseUsage	isOrdered	dbc1da3fb3a85961	19	0
-UseCaseUsage	isPortion	a9dc2ad030387ca3	19	0
+UseCaseUsage	isPortion	dbc1da3fb3a85961	19	0
 UseCaseUsage	isReference	04e0ac924bb31289	19	16
-UseCaseUsage	isSufficient	a9dc2ad030387ca3	19	0
+UseCaseUsage	isSufficient	dbc1da3fb3a85961	19	0
 UseCaseUsage	isUnique	8b4a028b0d2e5240	19	19
 UseCaseUsage	isVariable	a9dc2ad030387ca3	19	0
 UseCaseUsage	isVariation	178809e01a399c5e	19	1
 UseCaseUsage	mayTimeVary	a9dc2ad030387ca3	19	0
-UseCaseUsage	member	43dd5f1120221f37	19	15
-UseCaseUsage	membership	1c0113dd5d7c3feb	19	15
+UseCaseUsage	member	58c707de35132138	19	15
+UseCaseUsage	membership	f0ea9ddbf6dfb6fc	19	15
 UseCaseUsage	multiplicity	a9dc2ad030387ca3	19	0
 UseCaseUsage	name	667d9584b56cba49	19	19
-UseCaseUsage	nestedAction	b24b71e29d1caf70	19	9
+UseCaseUsage	nestedAction	c7351aafb20db171	19	9
 UseCaseUsage	nestedAllocation	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedAnalysisCase	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedAttribute	a285ee2a5d843e24	19	0
-UseCaseUsage	nestedCalculation	d98ec61b66cdff4a	19	5
-UseCaseUsage	nestedCase	d98ec61b66cdff4a	19	5
+UseCaseUsage	nestedCalculation	ee786ee87bbf014b	19	5
+UseCaseUsage	nestedCase	ee786ee87bbf014b	19	5
 UseCaseUsage	nestedConcern	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedConnection	55396b46eb7b49b8	19	6
 UseCaseUsage	nestedConstraint	d6eb9d37a8e4ba76	19	1
 UseCaseUsage	nestedEnumeration	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedFlow	a285ee2a5d843e24	19	0
-UseCaseUsage	nestedInterface	4fee5f77da3b335d	19	8
+UseCaseUsage	nestedInterface	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedItem	3d76f3e6aca22f63	19	7
 UseCaseUsage	nestedMetadata	a285ee2a5d843e24	19	0
-UseCaseUsage	nestedOccurrence	1c2049fe4c0e2cf7	19	14
+UseCaseUsage	nestedOccurrence	3109f2cb60ff2ef8	19	14
 UseCaseUsage	nestedPart	3d76f3e6aca22f63	19	7
 UseCaseUsage	nestedPort	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedReference	4fee5f77da3b335d	19	8
@@ -9805,8 +9917,8 @@ UseCaseUsage	nestedRendering	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedRequirement	d6eb9d37a8e4ba76	19	1
 UseCaseUsage	nestedState	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedTransition	a285ee2a5d843e24	19	0
-UseCaseUsage	nestedUsage	847130c857bf9586	19	14
-UseCaseUsage	nestedUseCase	d98ec61b66cdff4a	19	5
+UseCaseUsage	nestedUsage	995ad9956cb09787	19	14
+UseCaseUsage	nestedUseCase	ee786ee87bbf014b	19	5
 UseCaseUsage	nestedVerificationCase	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedView	a285ee2a5d843e24	19	0
 UseCaseUsage	nestedViewpoint	a285ee2a5d843e24	19	0
@@ -9818,21 +9930,21 @@ UseCaseUsage	ownedConjugator	a9dc2ad030387ca3	19	0
 UseCaseUsage	ownedCrossSubsetting	a9dc2ad030387ca3	19	0
 UseCaseUsage	ownedDifferencing	a285ee2a5d843e24	19	0
 UseCaseUsage	ownedDisjoining	a285ee2a5d843e24	19	0
-UseCaseUsage	ownedElement	5dcf2dcba0806532	19	15
+UseCaseUsage	ownedElement	72b8d698b5716733	19	15
 UseCaseUsage	ownedEndFeature	a285ee2a5d843e24	19	0
-UseCaseUsage	ownedFeature	847130c857bf9586	19	14
+UseCaseUsage	ownedFeature	995ad9956cb09787	19	14
 UseCaseUsage	ownedFeatureChaining	a285ee2a5d843e24	19	0
 UseCaseUsage	ownedFeatureInverting	a285ee2a5d843e24	19	0
-UseCaseUsage	ownedFeatureMembership	44cf9dc754fc873f	19	14
+UseCaseUsage	ownedFeatureMembership	19b927c5ee5ffe50	19	14
 UseCaseUsage	ownedImport	a285ee2a5d843e24	19	0
 UseCaseUsage	ownedIntersecting	a285ee2a5d843e24	19	0
-UseCaseUsage	ownedMember	5dcf2dcba0806532	19	15
-UseCaseUsage	ownedMembership	1c0113dd5d7c3feb	19	15
+UseCaseUsage	ownedMember	72b8d698b5716733	19	15
+UseCaseUsage	ownedMembership	f0ea9ddbf6dfb6fc	19	15
 UseCaseUsage	ownedRedefinition	a285ee2a5d843e24	19	0
 UseCaseUsage	ownedReferenceSubsetting	a9dc2ad030387ca3	19	0
-UseCaseUsage	ownedRelationship	8ca4dde86e65c320	19	19
-UseCaseUsage	ownedSpecialization	0321a3b408631937	19	19
-UseCaseUsage	ownedSubsetting	78a2d12c4a3fec69	19	19
+UseCaseUsage	ownedRelationship	02e18a9e7fe771b8	19	19
+UseCaseUsage	ownedSpecialization	03f72aaef9981900	19	19
+UseCaseUsage	ownedSubsetting	67bfa32f0beb35fa	19	19
 UseCaseUsage	ownedTypeFeaturing	a285ee2a5d843e24	19	0
 UseCaseUsage	ownedTyping	6d0e035b323165d0	19	7
 UseCaseUsage	ownedUnioning	a285ee2a5d843e24	19	0
@@ -9853,7 +9965,7 @@ UseCaseUsage	subjectParameter	10e47a82428db30f	19	8
 UseCaseUsage	textualRepresentation	a285ee2a5d843e24	19	0
 UseCaseUsage	type	35190a62f15e8870	19	7
 UseCaseUsage	unioningType	a285ee2a5d843e24	19	0
-UseCaseUsage	usage	847130c857bf9586	19	14
+UseCaseUsage	usage	995ad9956cb09787	19	14
 UseCaseUsage	useCaseDefinition	a03488b329e7b51e	19	7
 UseCaseUsage	variant	3621a53d41c54081	19	1
 UseCaseUsage	variantMembership	45f5cc7d19849c39	19	1
@@ -9915,7 +10027,7 @@ VerificationCaseDefinition	intersectingType	c5e1b725371404b2	8	0
 VerificationCaseDefinition	isAbstract	a67d779d22394b1a	8	0
 VerificationCaseDefinition	isConjugated	a67d779d22394b1a	8	0
 VerificationCaseDefinition	isImpliedIncluded	9e43ab194033b6fa	8	8
-VerificationCaseDefinition	isIndividual	d7e0f288d05a3302	8	0
+VerificationCaseDefinition	isIndividual	a67d779d22394b1a	8	0
 VerificationCaseDefinition	isLibraryElement	a67d779d22394b1a	8	0
 VerificationCaseDefinition	isModelLevelEvaluable	a67d779d22394b1a	8	0
 VerificationCaseDefinition	isSufficient	a67d779d22394b1a	8	0
@@ -9946,7 +10058,7 @@ VerificationCaseDefinition	ownedFeature	bf8be791fb8157d8	8	4
 VerificationCaseDefinition	ownedFeatureMembership	6caa258e3c288bd3	8	4
 VerificationCaseDefinition	ownedFlow	c5e1b725371404b2	8	0
 VerificationCaseDefinition	ownedImport	5ab819eadd40e064	8	1
-VerificationCaseDefinition	ownedInterface	1ada936cb2db025d	8	3
+VerificationCaseDefinition	ownedInterface	c5e1b725371404b2	8	0
 VerificationCaseDefinition	ownedIntersecting	c5e1b725371404b2	8	0
 VerificationCaseDefinition	ownedItem	c5e1b725371404b2	8	0
 VerificationCaseDefinition	ownedMember	bf8be791fb8157d8	8	4
@@ -10022,13 +10134,13 @@ VerificationCaseUsage	isConstant	ce22b7215500567c	7	0
 VerificationCaseUsage	isDerived	ce22b7215500567c	7	0
 VerificationCaseUsage	isEnd	ce22b7215500567c	7	0
 VerificationCaseUsage	isImpliedIncluded	2e605d4757f4e0ff	7	7
-VerificationCaseUsage	isIndividual	4f2c344fdb1aef78	7	0
+VerificationCaseUsage	isIndividual	ce22b7215500567c	7	0
 VerificationCaseUsage	isLibraryElement	ce22b7215500567c	7	0
 VerificationCaseUsage	isModelLevelEvaluable	ce22b7215500567c	7	0
 VerificationCaseUsage	isOrdered	ce22b7215500567c	7	0
-VerificationCaseUsage	isPortion	4f2c344fdb1aef78	7	0
+VerificationCaseUsage	isPortion	ce22b7215500567c	7	0
 VerificationCaseUsage	isReference	edb94498058572ad	7	5
-VerificationCaseUsage	isSufficient	4f2c344fdb1aef78	7	0
+VerificationCaseUsage	isSufficient	ce22b7215500567c	7	0
 VerificationCaseUsage	isUnique	2e605d4757f4e0ff	7	7
 VerificationCaseUsage	isVariable	4f2c344fdb1aef78	7	0
 VerificationCaseUsage	isVariation	d1691d40d1979ae1	7	1
@@ -10047,8 +10159,8 @@ VerificationCaseUsage	nestedConcern	02b68886545128ef	7	0
 VerificationCaseUsage	nestedConnection	3d3177d653609b7c	7	1
 VerificationCaseUsage	nestedConstraint	652d187178af0d44	7	3
 VerificationCaseUsage	nestedEnumeration	02b68886545128ef	7	0
-VerificationCaseUsage	nestedFlow	02b68886545128ef	7	0
-VerificationCaseUsage	nestedInterface	bb78f69beb70e941	7	4
+VerificationCaseUsage	nestedFlow	df8feda03c92a421	7	1
+VerificationCaseUsage	nestedInterface	02b68886545128ef	7	0
 VerificationCaseUsage	nestedItem	e891dee753a59e6e	7	1
 VerificationCaseUsage	nestedMetadata	02b68886545128ef	7	0
 VerificationCaseUsage	nestedOccurrence	394ef5480a5408c3	7	3
@@ -10084,9 +10196,9 @@ VerificationCaseUsage	ownedMember	886a091542b0f255	7	5
 VerificationCaseUsage	ownedMembership	bb7a81cfe16a3bf7	7	5
 VerificationCaseUsage	ownedRedefinition	02b68886545128ef	7	0
 VerificationCaseUsage	ownedReferenceSubsetting	4f2c344fdb1aef78	7	0
-VerificationCaseUsage	ownedRelationship	bf063f1fb6b9aa87	7	7
-VerificationCaseUsage	ownedSpecialization	53c4f05df5dd3b0f	7	7
-VerificationCaseUsage	ownedSubsetting	a314727b26ffe2b1	7	7
+VerificationCaseUsage	ownedRelationship	e7cc3fd5580259c1	7	7
+VerificationCaseUsage	ownedSpecialization	4be274e315599ae9	7	7
+VerificationCaseUsage	ownedSubsetting	31197126ab223565	7	7
 VerificationCaseUsage	ownedTypeFeaturing	02b68886545128ef	7	0
 VerificationCaseUsage	ownedTyping	8dcc690cd2fe0fb3	7	6
 VerificationCaseUsage	ownedUnioning	02b68886545128ef	7	0
@@ -10111,7 +10223,7 @@ VerificationCaseUsage	usage	3cf6669ba04574a0	7	5
 VerificationCaseUsage	variant	02b68886545128ef	7	0
 VerificationCaseUsage	variantMembership	02b68886545128ef	7	0
 VerificationCaseUsage	verificationCaseDefinition	38ff9586a9e6f8c4	7	6
-VerificationCaseUsage	verifiedRequirement	cf7fca608bd4e735	7	2
+VerificationCaseUsage	verifiedRequirement	be22543386ddae6f	7	2
 ViewDefinition	aliasIds	86c52aa119d18c10	10	0
 ViewDefinition	declaredName	b93ad6908fe682a6	10	10
 ViewDefinition	declaredShortName	d9eb4dca7215301a	10	0
@@ -10131,7 +10243,7 @@ ViewDefinition	intersectingType	86c52aa119d18c10	10	0
 ViewDefinition	isAbstract	e5e0f84d9d95ac96	10	0
 ViewDefinition	isConjugated	e5e0f84d9d95ac96	10	0
 ViewDefinition	isImpliedIncluded	609bc5ac833245b8	10	10
-ViewDefinition	isIndividual	d9eb4dca7215301a	10	0
+ViewDefinition	isIndividual	e5e0f84d9d95ac96	10	0
 ViewDefinition	isLibraryElement	e5e0f84d9d95ac96	10	0
 ViewDefinition	isSufficient	e5e0f84d9d95ac96	10	0
 ViewDefinition	isVariation	e5e0f84d9d95ac96	10	0
@@ -10250,7 +10362,7 @@ ViewUsage	documentation	4789f8737172dea1	12	0
 ViewUsage	elementId	e5d679ca1f676f90	12	12
 ViewUsage	endFeature	4789f8737172dea1	12	0
 ViewUsage	endOwningType	c23e8ae6760020e3	12	0
-ViewUsage	exposedElement	9e6ca563d86b791e	12	5
+ViewUsage	exposedElement	7e23031b3a5afdc4	12	8
 ViewUsage	feature	15475ca54b215094	12	10
 ViewUsage	featureMembership	6702e120b0532c5e	12	10
 ViewUsage	featureTarget	f57e1995ecd98326	12	0
@@ -10268,12 +10380,12 @@ ViewUsage	isConstant	f8f067f2de2253a1	12	0
 ViewUsage	isDerived	f8f067f2de2253a1	12	0
 ViewUsage	isEnd	f8f067f2de2253a1	12	0
 ViewUsage	isImpliedIncluded	9e820901655ae95d	12	12
-ViewUsage	isIndividual	c23e8ae6760020e3	12	0
+ViewUsage	isIndividual	f8f067f2de2253a1	12	0
 ViewUsage	isLibraryElement	f8f067f2de2253a1	12	0
 ViewUsage	isOrdered	f8f067f2de2253a1	12	0
-ViewUsage	isPortion	c23e8ae6760020e3	12	0
+ViewUsage	isPortion	f8f067f2de2253a1	12	0
 ViewUsage	isReference	905279dacca004b4	12	7
-ViewUsage	isSufficient	c23e8ae6760020e3	12	0
+ViewUsage	isSufficient	f8f067f2de2253a1	12	0
 ViewUsage	isUnique	9e820901655ae95d	12	12
 ViewUsage	isVariable	c23e8ae6760020e3	12	0
 ViewUsage	isVariation	f8f067f2de2253a1	12	0
@@ -10380,7 +10492,7 @@ ViewpointDefinition	intersectingType	e7140edd4730e611	3	0
 ViewpointDefinition	isAbstract	97e223e37ced5052	3	0
 ViewpointDefinition	isConjugated	97e223e37ced5052	3	0
 ViewpointDefinition	isImpliedIncluded	e690276988f49a41	3	3
-ViewpointDefinition	isIndividual	03658292af8df35a	3	0
+ViewpointDefinition	isIndividual	97e223e37ced5052	3	0
 ViewpointDefinition	isLibraryElement	97e223e37ced5052	3	0
 ViewpointDefinition	isModelLevelEvaluable	97e223e37ced5052	3	0
 ViewpointDefinition	isSufficient	97e223e37ced5052	3	0
@@ -10490,13 +10602,13 @@ ViewpointUsage	isConstant	ba5a91332de4822a	3	0
 ViewpointUsage	isDerived	ba5a91332de4822a	3	0
 ViewpointUsage	isEnd	ba5a91332de4822a	3	0
 ViewpointUsage	isImpliedIncluded	8188466a89f7f4c9	3	3
-ViewpointUsage	isIndividual	581ee364b0a1115a	3	0
+ViewpointUsage	isIndividual	ba5a91332de4822a	3	0
 ViewpointUsage	isLibraryElement	ba5a91332de4822a	3	0
 ViewpointUsage	isModelLevelEvaluable	ba5a91332de4822a	3	0
 ViewpointUsage	isOrdered	ba5a91332de4822a	3	0
-ViewpointUsage	isPortion	581ee364b0a1115a	3	0
+ViewpointUsage	isPortion	ba5a91332de4822a	3	0
 ViewpointUsage	isReference	c663e41cc256f564	3	2
-ViewpointUsage	isSufficient	581ee364b0a1115a	3	0
+ViewpointUsage	isSufficient	ba5a91332de4822a	3	0
 ViewpointUsage	isUnique	8188466a89f7f4c9	3	3
 ViewpointUsage	isVariable	581ee364b0a1115a	3	0
 ViewpointUsage	isVariation	ba5a91332de4822a	3	0
@@ -10551,9 +10663,9 @@ ViewpointUsage	ownedMember	ceaba62886d56995	3	3
 ViewpointUsage	ownedMembership	2db63f4c9c54e15d	3	3
 ViewpointUsage	ownedRedefinition	255edb3661d089f1	3	0
 ViewpointUsage	ownedReferenceSubsetting	581ee364b0a1115a	3	0
-ViewpointUsage	ownedRelationship	38998e8cc1946910	3	3
-ViewpointUsage	ownedSpecialization	d1d30699af5eacd8	3	1
-ViewpointUsage	ownedSubsetting	255edb3661d089f1	3	0
+ViewpointUsage	ownedRelationship	6fd4c5d0c1079551	3	3
+ViewpointUsage	ownedSpecialization	7f22cd0d22463991	3	3
+ViewpointUsage	ownedSubsetting	17f4dbbd86173f9e	3	3
 ViewpointUsage	ownedTypeFeaturing	255edb3661d089f1	3	0
 ViewpointUsage	ownedTyping	d1d30699af5eacd8	3	1
 ViewpointUsage	ownedUnioning	255edb3661d089f1	3	0
@@ -10619,12 +10731,12 @@ WhileLoopActionUsage	isConstant	800365b9f081c72b	5	0
 WhileLoopActionUsage	isDerived	800365b9f081c72b	5	0
 WhileLoopActionUsage	isEnd	800365b9f081c72b	5	0
 WhileLoopActionUsage	isImpliedIncluded	bbe0803b15cfe2bc	5	5
-WhileLoopActionUsage	isIndividual	806f5382440121f5	5	0
+WhileLoopActionUsage	isIndividual	800365b9f081c72b	5	0
 WhileLoopActionUsage	isLibraryElement	800365b9f081c72b	5	0
 WhileLoopActionUsage	isOrdered	800365b9f081c72b	5	0
-WhileLoopActionUsage	isPortion	806f5382440121f5	5	0
+WhileLoopActionUsage	isPortion	800365b9f081c72b	5	0
 WhileLoopActionUsage	isReference	800365b9f081c72b	5	0
-WhileLoopActionUsage	isSufficient	806f5382440121f5	5	0
+WhileLoopActionUsage	isSufficient	800365b9f081c72b	5	0
 WhileLoopActionUsage	isUnique	bbe0803b15cfe2bc	5	5
 WhileLoopActionUsage	isVariable	806f5382440121f5	5	0
 WhileLoopActionUsage	isVariation	800365b9f081c72b	5	0
@@ -10644,7 +10756,7 @@ WhileLoopActionUsage	nestedConnection	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedConstraint	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedEnumeration	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedFlow	af37b64d85605618	5	0
-WhileLoopActionUsage	nestedInterface	50aef5c1d55c7795	5	4
+WhileLoopActionUsage	nestedInterface	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedItem	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedMetadata	af37b64d85605618	5	0
 WhileLoopActionUsage	nestedOccurrence	c205b7ebdb4471a0	5	5
@@ -10679,9 +10791,9 @@ WhileLoopActionUsage	ownedMember	ad9edd2c31fb89fb	5	5
 WhileLoopActionUsage	ownedMembership	c050ed9fc295f679	5	5
 WhileLoopActionUsage	ownedRedefinition	af37b64d85605618	5	0
 WhileLoopActionUsage	ownedReferenceSubsetting	806f5382440121f5	5	0
-WhileLoopActionUsage	ownedRelationship	c050ed9fc295f679	5	5
-WhileLoopActionUsage	ownedSpecialization	af37b64d85605618	5	0
-WhileLoopActionUsage	ownedSubsetting	af37b64d85605618	5	0
+WhileLoopActionUsage	ownedRelationship	541fc58f1c0a8283	5	5
+WhileLoopActionUsage	ownedSpecialization	40ea3955f5c0bce0	5	5
+WhileLoopActionUsage	ownedSubsetting	40ea3955f5c0bce0	5	5
 WhileLoopActionUsage	ownedTypeFeaturing	af37b64d85605618	5	0
 WhileLoopActionUsage	ownedTyping	af37b64d85605618	5	0
 WhileLoopActionUsage	ownedUnioning	af37b64d85605618	5	0
diff --git a/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline-library.json b/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline-library.json
index bee303a..b0e256d 100644
--- a/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline-library.json
+++ b/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline-library.json
@@ -223,10 +223,10 @@
     "diagnostics": [
       {
         "end": 151,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 151
+        "start": 150
       }
     ],
     "status": "diagnostic baseline"
@@ -235,10 +235,10 @@
     "diagnostics": [
       {
         "end": 170,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 170
+        "start": 169
       }
     ],
     "status": "diagnostic baseline"
@@ -246,18 +246,11 @@
   "negative/grammar/g11-assignment-without-target.sysml": {
     "diagnostics": [
       {
-        "end": 178,
-        "message": "expected `:=` in assignment, found `}`",
-        "severity": "Error",
-        "stage": "parse",
-        "start": 177
-      },
-      {
-        "end": 178,
-        "message": "expected an expression, found `}`",
+        "end": 172,
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 171
       }
     ],
     "status": "diagnostic baseline"
@@ -381,10 +374,10 @@
     "diagnostics": [
       {
         "end": 182,
-        "message": "missing `;` after filter expression",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 182
+        "start": 181
       }
     ],
     "status": "diagnostic baseline"
@@ -637,10 +630,10 @@
     "diagnostics": [
       {
         "end": 173,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 173
+        "start": 172
       }
     ],
     "status": "diagnostic baseline"
@@ -649,10 +642,10 @@
     "diagnostics": [
       {
         "end": 177,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 176
       }
     ],
     "status": "diagnostic baseline"
@@ -661,10 +654,10 @@
     "diagnostics": [
       {
         "end": 169,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 169
+        "start": 168
       }
     ],
     "status": "diagnostic baseline"
@@ -673,10 +666,10 @@
     "diagnostics": [
       {
         "end": 182,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 182
+        "start": 181
       }
     ],
     "status": "diagnostic baseline"
@@ -692,10 +685,10 @@
       },
       {
         "end": 177,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 176
       }
     ],
     "status": "diagnostic baseline"
@@ -752,10 +745,10 @@
     "diagnostics": [
       {
         "end": 220,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 220
+        "start": 219
       }
     ],
     "status": "diagnostic baseline"
@@ -776,10 +769,10 @@
     "diagnostics": [
       {
         "end": 168,
-        "message": "missing `;` at end of declaration",
+        "message": "expected a name, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 168
+        "start": 167
       }
     ],
     "status": "diagnostic baseline"
@@ -807,10 +800,10 @@
     "diagnostics": [
       {
         "end": 169,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 169
+        "start": 168
       }
     ],
     "status": "diagnostic baseline"
@@ -837,6 +830,13 @@
         "severity": "Error",
         "stage": "parse",
         "start": 219
+      },
+      {
+        "end": 221,
+        "message": "unsupported or unexpected construct at `;`",
+        "severity": "Error",
+        "stage": "parse",
+        "start": 220
       }
     ],
     "status": "diagnostic baseline"
@@ -845,10 +845,10 @@
     "diagnostics": [
       {
         "end": 218,
-        "message": "missing `;` at end of declaration",
+        "message": "expected a name, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 218
+        "start": 217
       }
     ],
     "status": "diagnostic baseline"
@@ -1832,11 +1832,11 @@
   "negative/semantic/k35-metadata-annotates-wrong-kind.kerml": {
     "diagnostics": [
       {
-        "end": 292,
-        "message": "unresolved reference `annotatedElement`",
-        "severity": "Warning",
-        "stage": "referential",
-        "start": 276
+        "end": 376,
+        "message": "The annotated element's metaclass does not conform to annotatedElement's type [validateMetadataFeatureAnnotatedElement]",
+        "severity": "Error",
+        "stage": "semantics",
+        "start": 362
       }
     ],
     "status": "diagnostic baseline"
@@ -2868,14 +2868,14 @@
     "diagnostics": [
       {
         "end": 374,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `S46FeatureValueOverriding::P::a`, bound at negative/semantic/s46-feature-value-overriding.sysml:5:33; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 373
       },
       {
         "end": 431,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `S46FeatureValueOverriding::P::a`, bound at negative/semantic/s46-feature-value-overriding.sysml:5:33; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 430
@@ -4584,7 +4584,7 @@
     "diagnostics": [
       {
         "end": 254,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `P::C::a`, bound at probes/validateFeatureValueOverriding.kerml:6:31; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 253
@@ -4596,7 +4596,7 @@
     "diagnostics": [
       {
         "end": 234,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `P::D::a`, bound at probes/validateFeatureValueOverriding.sysml:3:88; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 233
diff --git a/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline.json b/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline.json
index 5d2d857..e5e723b 100644
--- a/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline.json
+++ b/crates/sysmlv2-parser/tests/fixtures/opensysml/baseline.json
@@ -223,10 +223,10 @@
     "diagnostics": [
       {
         "end": 151,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 151
+        "start": 150
       }
     ],
     "status": "diagnostic baseline"
@@ -235,10 +235,10 @@
     "diagnostics": [
       {
         "end": 170,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 170
+        "start": 169
       }
     ],
     "status": "diagnostic baseline"
@@ -246,18 +246,11 @@
   "negative/grammar/g11-assignment-without-target.sysml": {
     "diagnostics": [
       {
-        "end": 178,
-        "message": "expected `:=` in assignment, found `}`",
-        "severity": "Error",
-        "stage": "parse",
-        "start": 177
-      },
-      {
-        "end": 178,
-        "message": "expected an expression, found `}`",
+        "end": 172,
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 171
       }
     ],
     "status": "diagnostic baseline"
@@ -381,10 +374,10 @@
     "diagnostics": [
       {
         "end": 182,
-        "message": "missing `;` after filter expression",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 182
+        "start": 181
       }
     ],
     "status": "diagnostic baseline"
@@ -637,10 +630,10 @@
     "diagnostics": [
       {
         "end": 173,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 173
+        "start": 172
       }
     ],
     "status": "diagnostic baseline"
@@ -649,10 +642,10 @@
     "diagnostics": [
       {
         "end": 177,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 176
       }
     ],
     "status": "diagnostic baseline"
@@ -661,10 +654,10 @@
     "diagnostics": [
       {
         "end": 169,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 169
+        "start": 168
       }
     ],
     "status": "diagnostic baseline"
@@ -673,10 +666,10 @@
     "diagnostics": [
       {
         "end": 182,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 182
+        "start": 181
       }
     ],
     "status": "diagnostic baseline"
@@ -692,10 +685,10 @@
       },
       {
         "end": 177,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 177
+        "start": 176
       }
     ],
     "status": "diagnostic baseline"
@@ -752,10 +745,10 @@
     "diagnostics": [
       {
         "end": 220,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 220
+        "start": 219
       }
     ],
     "status": "diagnostic baseline"
@@ -776,10 +769,10 @@
     "diagnostics": [
       {
         "end": 168,
-        "message": "missing `;` at end of declaration",
+        "message": "expected a name, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 168
+        "start": 167
       }
     ],
     "status": "diagnostic baseline"
@@ -807,10 +800,10 @@
     "diagnostics": [
       {
         "end": 169,
-        "message": "missing `;` at end of declaration",
+        "message": "expected an expression, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 169
+        "start": 168
       }
     ],
     "status": "diagnostic baseline"
@@ -837,6 +830,13 @@
         "severity": "Error",
         "stage": "parse",
         "start": 219
+      },
+      {
+        "end": 221,
+        "message": "unsupported or unexpected construct at `;`",
+        "severity": "Error",
+        "stage": "parse",
+        "start": 220
       }
     ],
     "status": "diagnostic baseline"
@@ -845,10 +845,10 @@
     "diagnostics": [
       {
         "end": 218,
-        "message": "missing `;` at end of declaration",
+        "message": "expected a name, found `;`",
         "severity": "Error",
         "stage": "parse",
-        "start": 218
+        "start": 217
       }
     ],
     "status": "diagnostic baseline"
@@ -2924,14 +2924,14 @@
       },
       {
         "end": 374,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `S46FeatureValueOverriding::P::a`, bound at negative/semantic/s46-feature-value-overriding.sysml:5:33; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 373
       },
       {
         "end": 431,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `S46FeatureValueOverriding::P::a`, bound at negative/semantic/s46-feature-value-overriding.sysml:5:33; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 430
@@ -4892,7 +4892,7 @@
       },
       {
         "end": 254,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `P::C::a`, bound at probes/validateFeatureValueOverriding.kerml:6:31; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 253
@@ -4918,7 +4918,7 @@
       },
       {
         "end": 234,
-        "message": "Cannot override an inherited binding value; the redefined value must be default [validateFeatureValueOverriding]",
+        "message": "Cannot override the non-default value of `P::D::a`, bound at probes/validateFeatureValueOverriding.sysml:3:88; the inherited value must be default to allow a new value [validateFeatureValueOverriding]",
         "severity": "Error",
         "stage": "semantics",
         "start": 233
diff --git a/crates/sysmlv2-parser/tests/full_baseline.rs b/crates/sysmlv2-parser/tests/full_baseline.rs
index eddccc5..6d0b19c 100644
--- a/crates/sysmlv2-parser/tests/full_baseline.rs
+++ b/crates/sysmlv2-parser/tests/full_baseline.rs
@@ -2,7 +2,7 @@
 //! element the standard corpus emits, digested per (metaclass, property)
 //! and pinned in `tests/fixtures/full-form-baseline.tsv`.
 //!
-//! The gate that the derived-property port (plan §33) runs under: a
+//! The gate that the derived-property port runs under: a
 //! change to the emitter must leave every (metaclass, property) digest
 //! identical except for the names the change deliberately promotes. A
 //! difference prints the changed pairs, so a promotion is adjudicated
diff --git a/crates/sysmlv2-parser/tests/full_json.rs b/crates/sysmlv2-parser/tests/full_json.rs
index 083a1e1..893b802 100644
--- a/crates/sysmlv2-parser/tests/full_json.rs
+++ b/crates/sysmlv2-parser/tests/full_json.rs
@@ -648,6 +648,12 @@ fn relationship_side_owners_derive() {
         ref_of_prop(featuring, "owningFeatureOfType").as_deref(),
         Some(f.as_str())
     );
+    assert_eq!(
+        ref_of_prop(featuring, "featureOfType").as_deref(),
+        Some(f.as_str()),
+        "owned featuring's source is its Feature, never the relationship itself"
+    );
+    assert_eq!(refs_of_prop(featuring, "source"), [f.as_str()]);
 
     // The anonymous redefining feature in C owns its Redefinition.
     let redefinition = elements
@@ -702,6 +708,15 @@ fn relationship_side_owners_derive() {
             );
         }
     }
+    let featuring = standalone
+        .iter()
+        .find(|e| e["@type"] == "TypeFeaturing")
+        .unwrap();
+    let g = elem_id(find_named(elements, "g"));
+    assert_eq!(ref_of_prop(featuring, "featureOfType"), Some(g.clone()));
+    assert_eq!(refs_of_prop(featuring, "source"), [g.as_str()]);
+    assert_eq!(ref_of_prop(featuring, "featuringType"), Some(b.clone()));
+
     // A standalone conjugation still has its spelled ends.
     let conj = standalone
         .iter()
@@ -1108,10 +1123,10 @@ fn closure_policy_writes_the_closures() {
     assert_eq!(find(&passthrough, "R")["membership"], serde_json::json!([]));
     // The policy is restored after the emission.
     assert_eq!(r.closure_policy(), ClosurePolicy::Passthrough);
-    // A heritage deeper than the budget.
-    let mut src = String::from("package P { part def D0;");
+    // Import traversal still has a depth budget; acyclic inheritance does not.
+    let mut src = String::from("package P { package D0 { part leaf; }");
     for i in 1..=26 {
-        src.push_str(&format!(" part def D{i} :> D{};", i - 1));
+        src.push_str(&format!(" package D{i} {{ public import D{}::*; }}", i - 1));
     }
     src.push('}');
     let mut deep = Model::new();
@@ -1135,3 +1150,157 @@ fn closure_policy_writes_the_closures() {
     assert_eq!(r.closure_policy(), ClosurePolicy::Passthrough);
     assert!(resolved_to_full_json(&mut r, &deep, EmissionPolicy::default()).is_ok());
 }
+
+#[test]
+fn conjugated_port_typing_exports_the_original_definition() {
+    use sysmlv2_parser::json::{
+        Derived, DerivedValue, Derives, ElementRef, ResolvedModel, derives,
+    };
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "ports.sysml",
+                "port def Signal; part def Device { port input : ~Signal; }"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut resolved = ResolvedModel::build(&model);
+    let original = resolved.resolve_qualified("Signal").unwrap();
+    let full = model_to_full_json(&model);
+    let typing = full
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|row| row["@type"] == "ConjugatedPortTyping")
+        .unwrap();
+    let id = resolved.element_id(original).to_string();
+    assert_eq!(typing["portDefinition"], json!({"@id": id}));
+    assert_ne!(typing["portDefinition"]["@id"], typing["@id"]);
+    let e: ElementRef = resolved
+        .element_by_id(typing["@id"].as_str().unwrap())
+        .unwrap();
+    assert_eq!(
+        derives("ConjugatedPortTyping", "portDefinition"),
+        Derives::Exact
+    );
+    assert_eq!(
+        resolved.derived(e, "portDefinition"),
+        Derived::Value(DerivedValue::Element(original))
+    );
+    assert_eq!(
+        resolved.property(e, "portDefinition").unwrap(),
+        typing["portDefinition"]
+    );
+    let port = resolved.resolve_qualified("Device::input").unwrap();
+    assert!(matches!(
+        resolved.derived(port, "portDefinition"),
+        Derived::Value(DerivedValue::References(_))
+    ));
+}
+
+#[test]
+fn full_export_preserves_owned_scalar_defaults_and_explicit_values() {
+    use sysmlv2_parser::json::ResolvedModel;
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "defaults.sysml",
+                "part def Box; individual part def OneBox; abstract part def AbstractBox;"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut resolved = ResolvedModel::build(&model);
+    let full = model_to_full_json(&model);
+    for (name, individual, abstract_) in [
+        ("Box", false, false),
+        ("OneBox", true, false),
+        ("AbstractBox", false, true),
+    ] {
+        let e = resolved.resolve_qualified(name).unwrap();
+        let id = resolved.element_id(e).to_string();
+        let row = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|row| row["@id"] == id)
+            .unwrap();
+        for (property, expected) in [("isIndividual", individual), ("isAbstract", abstract_)] {
+            assert_eq!(row[property], json!(expected), "{name}.{property}");
+            assert_eq!(resolved.property(e, property).unwrap(), row[property]);
+        }
+    }
+}
+
+#[test]
+fn operator_result_exports_the_library_return_parameter() {
+    use sysmlv2_parser::json::{Derived, DerivedValue, ResolvedModel};
+    let mut model = Model::new();
+    assert!(model.add_library_source("operators.kerml", "standard library package DataFunctions { function '+' { in x; in y; return sum; } }").diagnostics.is_empty());
+    assert!(
+        model
+            .add_source("sum.sysml", "attribute total = 1 + 2;")
+            .diagnostics
+            .is_empty()
+    );
+    let mut resolved = ResolvedModel::build(&model);
+    let result = resolved
+        .resolve_qualified("DataFunctions::'+'::sum")
+        .unwrap();
+    let full = model_to_full_json(&model);
+    let operator = full
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|row| row["@type"] == "OperatorExpression")
+        .unwrap();
+    let e = resolved
+        .element_by_id(operator["@id"].as_str().unwrap())
+        .unwrap();
+    assert_eq!(
+        resolved.derived(e, "result"),
+        Derived::Value(DerivedValue::Element(result))
+    );
+    assert_eq!(
+        operator["result"],
+        json!({"@id": resolved.element_id(result).to_string()})
+    );
+    assert_ne!(operator["result"]["@id"], operator["@id"]);
+    // The compatibility improvement does not claim complete checked expression evidence.
+    assert!(resolved.property(e, "result").is_err());
+}
+
+#[test]
+fn missing_port_and_operator_targets_remain_unavailable_to_checked_reads() {
+    use sysmlv2_parser::json::{Derived, DerivedValue, ResolvedModel};
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "missing.sysml",
+                "part def Device { port input : ~Missing; attribute total = 1 + 2; }"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut resolved = ResolvedModel::build(&model);
+    let receivers: Vec<_> = resolved
+        .elements()
+        .filter_map(|e| match resolved.element_type(e) {
+            "ConjugatedPortTyping" => Some((e, "portDefinition")),
+            "OperatorExpression" => Some((e, "result")),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(receivers.len(), 2);
+    for (e, property) in receivers {
+        assert_eq!(
+            resolved.derived(e, property),
+            Derived::Value(DerivedValue::Null)
+        );
+        assert!(resolved.property(e, property).is_err());
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/grammar_edge.rs b/crates/sysmlv2-parser/tests/grammar_edge.rs
index 67e4fcd..943520a 100644
--- a/crates/sysmlv2-parser/tests/grammar_edge.rs
+++ b/crates/sysmlv2-parser/tests/grammar_edge.rs
@@ -380,15 +380,6 @@ fn transition_effect_remaining_alternatives() {
     sysml_ok("package P { state def S { do action work { out x; } transition x then y; } }");
 }
 
-#[test]
-fn sysml_semicolon_expression_bodies() {
-    sysml_ok("package P { attribute a = ;; }");
-    sysml_ok("package P { attribute a = 1 + ;; }");
-    sysml_ok("package P { attribute a = xs.;; }");
-    sysml_ok("package P { attribute a = xs.?;; }");
-    sysml_ok("package P { attribute a = xs->F ;; }");
-}
-
 #[test]
 fn empty_usage_after_special_prefixes_and_in_enumerations() {
     sysml_ok("package P { connection def C { end; } }");
diff --git a/crates/sysmlv2-parser/tests/import_memberships.rs b/crates/sysmlv2-parser/tests/import_memberships.rs
new file mode 100644
index 0000000..1b99591
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/import_memberships.rs
@@ -0,0 +1,704 @@
+//! Imported Membership identity is distinct from the element its name denotes.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, DerivedValue, ElementRef, Reference, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    let mut base = Model::new();
+    base.add_library_source("library.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    let _ = ResolvedModel::build(&base);
+    let cache = base.take_recorded_library_cache().unwrap();
+    let cache = LibraryCache::from_bytes(&cache.to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let prepared =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(7).unwrap(), 7).unwrap());
+    (0..3)
+        .map(|mode| {
+            let mut model = Model::new();
+            if mode == 2 {
+                prepared.clone().install(&mut model).unwrap();
+            } else {
+                model.add_library_source("library.kerml", library);
+                if mode == 1 {
+                    model.set_library_cache(cache.clone());
+                }
+            }
+            model.add_source("user.kerml", user);
+            assert!(
+                !model.has_errors(),
+                "{:?}",
+                model
+                    .units()
+                    .iter()
+                    .flat_map(|u| &u.diagnostics)
+                    .collect::<Vec<_>>()
+            );
+            ResolvedModel::build(&model)
+        })
+        .collect()
+}
+
+fn many(r: &mut ResolvedModel, e: ElementRef, name: &str) -> Vec<ElementRef> {
+    match r.derived(e, name) {
+        Derived::Value(DerivedValue::Elements(v)) => v,
+        other => panic!("{name}: {other:?}"),
+    }
+}
+
+fn one(r: &mut ResolvedModel, e: ElementRef, name: &str) -> ElementRef {
+    match r.derived(e, name) {
+        Derived::Value(DerivedValue::Element(e))
+        | Derived::Value(DerivedValue::Reference(Reference::Element(e))) => e,
+        Derived::NotDeclared => {
+            let value = r.element_properties(e);
+            let id = value[name]["@id"].as_str().unwrap();
+            r.element_by_id(id).unwrap()
+        }
+        other => panic!("{name}: {other:?}"),
+    }
+}
+
+fn alias(r: &mut ResolvedModel, scope: &str, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(scope).unwrap();
+    many(r, owner, "ownedMembership")
+        .into_iter()
+        .find(|&m| r.membership_is_alias(m) && r.membership_member_name(m).as_deref() == Some(name))
+        .unwrap()
+}
+
+#[test]
+fn named_imports_preserve_alias_membership_through_reexports_and_qualification() {
+    let library = "package L {
+        class T { feature x; }
+        alias A for T; alias B for T;
+    }
+    package Bridge { public import L::A; public import L::B; }
+    package Wild { public import Bridge::*; }
+    package Named { public import Wild::A; }
+    ";
+    let user = "package U { private import Named::A; private import Wild::B; }
+        package Child { private import L::A::x; }
+        package Both { private import L::T; private import L::A; private import L::B; }
+        package Renamed { alias C for Wild::A; }
+        package Last { private import Renamed::C; }
+        class Base { public import L::A; } class Derived :> Base;";
+    for mut r in models(library, user) {
+        let a = alias(&mut r, "L", "A");
+        let b = alias(&mut r, "L", "B");
+        let t = r.resolve_qualified("L::T").unwrap();
+        let home = one(&mut r, t, "owningMembership");
+        for name in ["U", "Bridge", "Wild"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.imported_memberships(owner), [a, b], "{name}");
+        }
+        for name in ["U", "Bridge", "Named"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            let imports = many(&mut r, owner, "ownedImport");
+            assert_eq!(one(&mut r, imports[0], "importedMembership"), a, "{name}");
+            assert_eq!(one(&mut r, imports[0], "importedElement"), t);
+        }
+        let owner = r.resolve_qualified("Both").unwrap();
+        assert_eq!(r.imported_memberships(owner), [home, a, b]);
+        let child = r.resolve_qualified("Child").unwrap();
+        let x = r.resolve_qualified("L::T::x").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        assert_eq!(
+            r.imported_memberships(child),
+            [xm],
+            "qualifier alias must not replace final membership"
+        );
+        let c = alias(&mut r, "Renamed", "C");
+        let last = r.resolve_qualified("Last").unwrap();
+        assert_eq!(r.imported_memberships(last), [c], "last named alias wins");
+        let derived = r.resolve_qualified("Derived").unwrap();
+        assert_eq!(r.inherited_memberships(derived, false), [a]);
+        assert_eq!(
+            r.resolve_qualified("U::A"),
+            Some(t),
+            "ordinary lookup still returns element"
+        );
+    }
+}
+
+#[test]
+fn cycles_exclude_the_import_owner_without_suppressing_independent_filtered_paths() {
+    let library = "package A { class Own; public import B::*; }
+        package B { class Other; public import all A::*; }
+        package Self { class Local; public import Self::*; }
+        package Leaf { class Item; }
+        package Filtered { public import Leaf::*[false]; }
+        package Open { public import Leaf::*[true]; }";
+    let user = "package U { private import Filtered::*; private import Open::*; }
+        package V { private import Open::*; private import Filtered::*; }";
+    for mut r in models(library, user) {
+        let a = r.resolve_qualified("A").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        let own = r.resolve_qualified("A::Own").unwrap();
+        let other = r.resolve_qualified("B::Other").unwrap();
+        let own_m = one(&mut r, own, "owningMembership");
+        let other_m = one(&mut r, other, "owningMembership");
+        assert_eq!(r.imported_memberships(a), [other_m]);
+        assert_eq!(r.imported_memberships(b), [own_m]);
+        let self_ = r.resolve_qualified("Self").unwrap();
+        assert!(r.imported_memberships(self_).is_empty());
+        let item = r.resolve_qualified("Leaf::Item").unwrap();
+        let item_m = one(&mut r, item, "owningMembership");
+        for name in ["U", "V"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.imported_memberships(owner), [item_m]);
+        }
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: false,
+        });
+        let membership = many(&mut r, a, "membership");
+        assert_eq!(membership, [own_m, other_m]);
+    }
+}
+
+#[test]
+fn alias_imports_apply_visibility_filters_and_recursive_scope_policy() {
+    let library = "package L { class T { feature x; }
+        private alias Hidden for T; public alias Visible for T;
+    }
+    package Blocked { private import L::Hidden; }
+    package All { private import all L::Hidden; }
+    package Rejected { public import L::Visible[false]; }
+    package Accepted { public import L::Visible[true]; }
+    package Recursive { public import L::Visible::**; }";
+    for mut r in models(library, "package U { private import Accepted::*; }") {
+        let hidden = alias(&mut r, "L", "Hidden");
+        let visible = alias(&mut r, "L", "Visible");
+        for name in ["Blocked", "Rejected"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert!(r.imported_memberships(owner).is_empty(), "{name}");
+        }
+        let all = r.resolve_qualified("All").unwrap();
+        assert_eq!(r.imported_memberships(all), [hidden]);
+        let imp = many(&mut r, all, "ownedImport")[0];
+        assert_eq!(one(&mut r, imp, "importedMembership"), hidden);
+        let accepted = r.resolve_qualified("Accepted").unwrap();
+        assert_eq!(r.imported_memberships(accepted), [visible]);
+        let u = r.resolve_qualified("U").unwrap();
+        assert_eq!(r.imported_memberships(u), [visible]);
+        let recursive = r.resolve_qualified("Recursive").unwrap();
+        let x = r.resolve_qualified("L::T::x").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        assert_eq!(r.imported_memberships(recursive), [visible, xm]);
+    }
+}
+
+#[test]
+fn cycle_boundaries_do_not_hide_a_wider_independent_path() {
+    let library = "package B { class Public; private class Secret; public import C::*; }
+        package C { public import all B::*; }";
+    let user = "package Narrow { private import B::*; }
+        package Wide { private import B::*; private import C::*; }
+        package Reverse { private import C::*; private import B::*; }";
+    for mut r in models(library, user) {
+        let public = r.resolve_qualified("B::Public").unwrap();
+        let secret = r.resolve_qualified("B::Secret").unwrap();
+        let pm = one(&mut r, public, "owningMembership");
+        let sm = one(&mut r, secret, "owningMembership");
+        let narrow = r.resolve_qualified("Narrow").unwrap();
+        assert_eq!(
+            r.imported_memberships(narrow),
+            [pm],
+            "cycle cannot widen access to an ancestor"
+        );
+        for name in ["Wide", "Reverse"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(
+                r.imported_memberships(owner),
+                [pm, sm],
+                "{name}: independent path may widen access"
+            );
+        }
+    }
+}
+
+#[test]
+fn short_alias_names_select_the_same_membership_as_the_long_name() {
+    let library = "package L { class T; alias <Short> Long for T; alias <Only> for T; }";
+    for mut r in models(library, "package U { import L::Short; import L::Only; }") {
+        let long = alias(&mut r, "L", "Long");
+        let l = r.resolve_qualified("L").unwrap();
+        let only = many(&mut r, l, "ownedMembership")
+            .into_iter()
+            .find(|&m| {
+                r.element_properties(m)
+                    .get("memberShortName")
+                    .and_then(|v| v.as_str())
+                    == Some("Only")
+            })
+            .unwrap();
+        let u = r.resolve_qualified("U").unwrap();
+        assert_eq!(r.imported_memberships(u), [long, only]);
+        let imports = many(&mut r, u, "ownedImport");
+        assert_eq!(one(&mut r, imports[0], "importedMembership"), long);
+        assert_eq!(one(&mut r, imports[1], "importedMembership"), only);
+    }
+}
+
+#[test]
+fn layered_import_diamonds_share_completed_visits() {
+    // There are over sixteen million paths but only 49 imported scopes.
+    // Enumeration must reuse complete visits without losing leaf identity.
+    let mut src = String::new();
+    for level in 0..24 {
+        for suffix in ['a', 'b'] {
+            src += &format!("package N{level}{suffix} {{");
+            if level < 23 {
+                src += &format!(
+                    "public import N{}a::*; public import N{}b::*;",
+                    level + 1,
+                    level + 1
+                );
+            } else {
+                src += "public import Leaf::*;";
+            }
+            src += "}";
+        }
+    }
+    src += "package Leaf { class Item; } package Root { import N0a::*; import N0b::*; }";
+    let mut model = Model::new();
+    model.add_source("diamond.kerml", &src);
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    let root = r.resolve_qualified("Root").unwrap();
+    let leaf = r.resolve_qualified("Leaf::Item").unwrap();
+    let membership = one(&mut r, leaf, "owningMembership");
+    assert_eq!(r.imported_memberships(root), [membership]);
+}
+
+#[test]
+fn interchange_reload_preserves_local_and_cross_document_alias_imports() {
+    let mut model = Model::new();
+    model.add_source(
+        "decl.kerml",
+        "package L { class T; alias A for T; alias <S> Short for T; } alias RootAlias for L::T;",
+    );
+    model.add_source(
+        "use.kerml",
+        "package U { import L::A; import L::S; import RootAlias; }",
+    );
+    let compact = sysmlv2_parser::json::model_to_compact_json(&model);
+    let mut original = ResolvedModel::build(&model);
+    let original_u = original.resolve_qualified("U").unwrap();
+    let expected: Vec<_> = original
+        .imported_memberships(original_u)
+        .into_iter()
+        .map(|m| original.element_id(m))
+        .collect();
+    let (_, mut loaded, _, warnings) =
+        sysmlv2_parser::loader::load_document(&compact, &Default::default()).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    let u = loaded.resolve_qualified("U").unwrap();
+    let actual: Vec<_> = loaded
+        .imported_memberships(u)
+        .into_iter()
+        .map(|m| loaded.element_id(m))
+        .collect();
+    assert_eq!(actual, expected);
+    for (i, imp) in many(&mut loaded, u, "ownedImport").into_iter().enumerate() {
+        let membership = one(&mut loaded, imp, "importedMembership");
+        assert_eq!(loaded.element_id(membership), expected[i]);
+    }
+}
+
+#[test]
+fn same_membership_diamonds_resolve_but_distinct_same_named_aliases_are_ambiguous() {
+    let library = "package L { class T; alias A for T; }
+        package Left { public import L::*; }
+        package Right { public import L::*; }
+        package Other { alias A for L::T; }
+        package AliasToHome { alias T for L::T; }
+        package Diamond { public import Left::*; public import Right::*; }
+        package Collision { public import Left::*; public import Other::*; }
+        package HomeCollision { public import L::*; public import AliasToHome::*; }";
+    let user = "package Good { import Diamond::A; }
+        package Bad { import Collision::A; }
+        package BadHome { import HomeCollision::T; }";
+    for mut r in models(library, user) {
+        let a = alias(&mut r, "L", "A");
+        let good = r.resolve_qualified("Good").unwrap();
+        assert_eq!(r.imported_memberships(good), [a]);
+        let import = many(&mut r, good, "ownedImport")[0];
+        assert_eq!(one(&mut r, import, "importedMembership"), a);
+        for scope in ["Bad", "BadHome"] {
+            let owner = r.resolve_qualified(scope).unwrap();
+            assert!(r.imported_memberships(owner).is_empty());
+            let imp = many(&mut r, owner, "ownedImport")[0];
+            assert!(
+                r.element_properties(imp)["importedMembership"]
+                    .get("@ref")
+                    .is_some()
+            );
+        }
+        assert!(r.resolve_qualified("Collision::A").is_none());
+        assert!(r.resolve_qualified("HomeCollision::T").is_none());
+    }
+}
+
+#[test]
+fn mixed_imports_retain_declaration_order_and_recursive_membership_prefix() {
+    let library = "package L { class T { feature x; } alias A for T; }
+        package Extra { class E; }
+        package Reexport { public import L::A; public import Extra::*; public import L::T; }";
+    let user = "package U { import L::A; import L::T; }
+        package Mixed { import L::A; import Extra::*; import L::T; }
+        package Through { import Reexport::*; }";
+    for mut r in models(library, user) {
+        let a = alias(&mut r, "L", "A");
+        let t = r.resolve_qualified("L::T").unwrap();
+        let tm = one(&mut r, t, "owningMembership");
+        let e = r.resolve_qualified("Extra::E").unwrap();
+        let em = one(&mut r, e, "owningMembership");
+        let u = r.resolve_qualified("U").unwrap();
+        assert_eq!(r.imported_memberships(u), [a, tm]);
+        for name in ["Mixed", "Through", "Reexport"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.imported_memberships(owner), [a, em, tm], "{name}");
+        }
+    }
+}
+
+#[test]
+fn namespace_imports_include_unnamed_memberships_and_recursive_anonymous_namespaces() {
+    let library = "package L { feature; private feature; package { class Nested; } }";
+    let user = "package U { import L::*; } package All { import all L::*; }
+        package Recursive { import L::**; }";
+    for mut r in models(library, user) {
+        let l = r.resolve_qualified("L").unwrap();
+        let all_owned = many(&mut r, l, "ownedMembership");
+        assert_eq!(all_owned.len(), 3);
+        let public = vec![all_owned[0], all_owned[2]];
+        let u = r.resolve_qualified("U").unwrap();
+        assert_eq!(r.imported_memberships(u), public);
+        let all = r.resolve_qualified("All").unwrap();
+        assert_eq!(r.imported_memberships(all), all_owned);
+        let anonymous_package = r.membership_member(all_owned[2]).unwrap();
+        let nested = many(&mut r, anonymous_package, "ownedMembership")[0];
+        let lm = one(&mut r, l, "owningMembership");
+        let recursive = r.resolve_qualified("Recursive").unwrap();
+        assert_eq!(
+            r.imported_memberships(recursive),
+            [lm, public[0], public[1], nested]
+        );
+    }
+}
+
+#[test]
+fn inherited_import_context_admits_protected_aliases_but_not_private_ones() {
+    let library = "package L { class T; } class Base {
+        protected alias Protected for L::T; private alias Private for L::T;
+    }";
+    for mut r in models(
+        library,
+        "class Child :> Base { import Base::Protected; import Base::Private; }",
+    ) {
+        let protected = alias(&mut r, "Base", "Protected");
+        let child = r.resolve_qualified("Child").unwrap();
+        assert_eq!(r.imported_memberships(child), [protected]);
+        let imports = many(&mut r, child, "ownedImport");
+        assert_eq!(one(&mut r, imports[0], "importedMembership"), protected);
+        assert!(
+            r.element_properties(imports[1])["importedMembership"]
+                .get("@ref")
+                .is_some()
+        );
+    }
+}
+
+#[test]
+fn imported_collisions_remove_both_peers_and_respect_cross_names_and_member_types() {
+    let library = "package L { class <S> Long; class Same; feature Different; class Shared; }
+        package R { class S; class Same; class Different; alias Shared for L::Shared; }
+        package SameAlias { alias Shared for L::Shared; }
+        package Diamond { public import L::*; public import L::*; }";
+    let user = "package U { import L::*; import R::*; }
+        package Owned { private class <Long> Local; import L::*; }
+        package Aliases { import R::Shared; import SameAlias::Shared; }
+        package Reexport { import U::*; }";
+    for mut r in models(library, user) {
+        let lf = r.resolve_qualified("L::Different").unwrap();
+        let rc = r.resolve_qualified("R::Different").unwrap();
+        let fm = one(&mut r, lf, "owningMembership");
+        let cm = one(&mut r, rc, "owningMembership");
+        for name in ["U", "Reexport"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.imported_memberships(owner), [fm, cm], "{name}");
+        }
+        let own = r.resolve_qualified("Owned").unwrap();
+        let long = r.resolve_qualified("L::Long").unwrap();
+        let lm = one(&mut r, long, "owningMembership");
+        assert!(!r.imported_memberships(own).contains(&lm));
+        let aliases = r.resolve_qualified("Aliases").unwrap();
+        assert!(
+            r.imported_memberships(aliases).is_empty(),
+            "distinct memberships to same target collide"
+        );
+        let diamond = r.resolve_qualified("Diamond").unwrap();
+        let l = r.resolve_qualified("L").unwrap();
+        assert_eq!(
+            r.imported_memberships(diamond),
+            many(&mut r, l, "ownedMembership")
+        );
+    }
+}
+
+#[test]
+fn namespace_pruning_is_distinct_from_visibility_specific_reexport() {
+    let library = "package A { class X; } package B { class X; }
+        package Bridge { public import A::*; private import B::*; }";
+    for mut r in models(library, "package U { import Bridge::*; }") {
+        let bridge = r.resolve_qualified("Bridge").unwrap();
+        assert!(r.imported_memberships(bridge).is_empty());
+        let u = r.resolve_qualified("U").unwrap();
+        let x = r.resolve_qualified("A::X").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        assert_eq!(r.imported_memberships(u), [xm]);
+    }
+}
+
+#[test]
+fn package_filter_follows_pruning_but_import_filter_precedes_it() {
+    let mut model = Model::new();
+    model.add_source(
+        "filters.sysml",
+        "metadata def Safety;
+        package A { #Safety part def X; }
+        package B { part def X; }
+        package Collision { public import A::*; public import B::*; }
+        package Outer { import Collision::*[@Safety]; }
+        package PackageFilter { filter @Safety; public import A::*; public import B::*; }
+        package EntryFilter { public import A::*; public import B::*[@Safety]; }",
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    for name in ["Collision", "PackageFilter"] {
+        let owner = r.resolve_qualified(name).unwrap();
+        assert!(r.imported_memberships(owner).is_empty(), "{name}");
+    }
+    let owner = r.resolve_qualified("EntryFilter").unwrap();
+    let x = r.resolve_qualified("A::X").unwrap();
+    let membership = one(&mut r, x, "owningMembership");
+    assert_eq!(r.imported_memberships(owner), [membership]);
+    let outer = r.resolve_qualified("Outer").unwrap();
+    assert_eq!(r.imported_memberships(outer), [membership]);
+}
+
+#[test]
+fn cyclic_collision_results_are_recomputed_for_changed_exclusions() {
+    let library = "package A { class X; public import C::*; }
+        package B { class X; }
+        package C { public import A::*; public import B::*; }
+        package First { public import A::*; public import C::*; }
+        package Reverse { public import C::*; public import A::*; }";
+    for mut r in models(
+        library,
+        "package U { import First::*; } package V { import Reverse::*; }",
+    ) {
+        // Visibility traversal is raw; the two identities collide only at
+        // each queried Namespace importedMemberships projection.
+        for name in ["First", "Reverse", "U", "V"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert!(r.imported_memberships(owner).is_empty(), "{name}");
+        }
+    }
+}
+
+#[test]
+fn stored_feature_naming_does_not_invent_reference_or_partial_declared_names() {
+    let library = "package A { feature X; }
+        package Redefined { feature :>> A::X; }
+        package Referenced { feature references A::X; }
+        package Short { feature <S> :>> A::X; }";
+    let user = "package Collision { import A::*; import Redefined::*; }
+        package Reference { import A::*; import Referenced::*; }
+        package Declared { import A::*; import Short::*; }";
+    for mut r in models(library, user) {
+        let collision = r.resolve_qualified("Collision").unwrap();
+        assert!(r.imported_memberships(collision).is_empty());
+        for name in ["Reference", "Declared"] {
+            let owner = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.imported_memberships(owner).len(), 2, "{name}");
+        }
+    }
+}
+
+#[test]
+fn named_self_import_collides_with_the_owned_membership() {
+    for mut r in models("package L { class X; import L::X; }", "") {
+        let l = r.resolve_qualified("L").unwrap();
+        assert!(r.imported_memberships(l).is_empty());
+    }
+}
+
+#[test]
+fn inheritance_filters_distinct_memberships_of_one_feature_but_not_diamond_repeats() {
+    let library = "package L {
+        class Values { feature x; class T; }
+        class Aliases { alias a for Values::x; alias b for Values::x; }
+        class Mixed { feature x; alias a for x; }
+        class Types { alias a for Values::T; alias b for Values::T; }
+        class Single { alias a for Values::x; }
+        class Left specializes Single;
+        class Right specializes Single;
+    }";
+    let user = "class A specializes L::Aliases;
+        class B specializes L::Mixed;
+        class C specializes L::Types;
+        class D specializes L::Left, L::Right;";
+    for mut r in models(library, user) {
+        let single = alias(&mut r, "L::Single", "a");
+        let types = [
+            alias(&mut r, "L::Types", "a"),
+            alias(&mut r, "L::Types", "b"),
+        ];
+        for include_implied in [false, true, false] {
+            r.set_closure_policy(ClosurePolicy::Closure { include_implied });
+            for name in ["A", "B"] {
+                let e = r.resolve_qualified(name).unwrap();
+                assert!(
+                    r.inherited_memberships(e, include_implied).is_empty(),
+                    "{name}"
+                );
+                assert!(many(&mut r, e, "inheritedMembership").is_empty());
+                assert!(many(&mut r, e, "inheritedFeature").is_empty());
+            }
+            let c = r.resolve_qualified("C").unwrap();
+            assert_eq!(r.inherited_memberships(c, include_implied), types);
+            let d = r.resolve_qualified("D").unwrap();
+            assert_eq!(r.inherited_memberships(d, include_implied), [single]);
+        }
+    }
+}
+
+#[test]
+fn inherited_feature_aliases_are_redefinition_candidates_and_blockers() {
+    let library = "package L {
+        class Values { feature x; }
+        class Redefiners specializes Values { feature y redefines x; }
+        class Old { public import Values::x; }
+        class Alias { alias renamed for Redefiners::y; }
+    }";
+    let user = "class Inherited specializes L::Old, L::Alias;
+        class Owned specializes L::Alias { feature z redefines L::Values::x; }
+        class Combined specializes L::Old, L::Alias { feature z redefines L::Redefiners::y; }
+        class OwnedAlias specializes L::Old { alias local for L::Redefiners::y; }";
+    for mut r in models(library, user) {
+        let a = alias(&mut r, "L::Alias", "renamed");
+        let x = r.resolve_qualified("L::Values::x").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        for include_implied in [true, false, true] {
+            let inherited = r.resolve_qualified("Inherited").unwrap();
+            assert_eq!(r.inherited_memberships(inherited, include_implied), [a]);
+            let owned = r.resolve_qualified("Owned").unwrap();
+            assert!(r.inherited_memberships(owned, include_implied).is_empty());
+            let combined = r.resolve_qualified("Combined").unwrap();
+            assert!(
+                r.inherited_memberships(combined, include_implied)
+                    .is_empty()
+            );
+            let owned_alias = r.resolve_qualified("OwnedAlias").unwrap();
+            assert_eq!(r.inherited_memberships(owned_alias, include_implied), [xm]);
+        }
+    }
+}
+
+#[test]
+fn private_aliases_do_not_suppress_inherited_public_features() {
+    let library = "class Base { feature x; private alias hidden for x; }
+        class ProtectedBase { feature x; protected alias visible for x; }";
+    for mut r in models(
+        library,
+        "class Sub specializes Base; class Other specializes ProtectedBase;",
+    ) {
+        let x = r.resolve_qualified("Base::x").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        for include_implied in [false, true] {
+            let sub = r.resolve_qualified("Sub").unwrap();
+            assert_eq!(r.inherited_memberships(sub, include_implied), [xm]);
+            let other = r.resolve_qualified("Other").unwrap();
+            assert!(r.inherited_memberships(other, include_implied).is_empty());
+        }
+    }
+}
+
+#[test]
+fn mutual_redefinition_cycles_remove_both_memberships() {
+    // Deliberately malformed semantic graph; both targets must really bind.
+    let library = "class Root;
+        class Pair specializes Root { feature x redefines Pair::y; feature y redefines Pair::x; }";
+    for mut r in models(library, "class Double specializes Pair;") {
+        let x = r.resolve_qualified("Pair::x").unwrap();
+        let y = r.resolve_qualified("Pair::y").unwrap();
+        for (source, target) in [(x, y), (y, x)] {
+            let edge = r
+                .owned_relationships(source)
+                .into_iter()
+                .find(|&edge| r.element_type(edge) == "Redefinition")
+                .unwrap();
+            assert_eq!(
+                r.element_properties(edge)["redefinedFeature"]["@id"],
+                r.element_id(target).to_string()
+            );
+        }
+        for include_implied in [false, true] {
+            let double = r.resolve_qualified("Double").unwrap();
+            assert!(r.inherited_memberships(double, include_implied).is_empty());
+        }
+    }
+}
+
+#[test]
+fn unavailable_alias_targets_qualify_inheritance_without_removing_known_members() {
+    for mut r in models(
+        "class Base { feature x; alias unknown for Missing; }",
+        "class Child specializes Base;",
+    ) {
+        let child = r.resolve_qualified("Child").unwrap();
+        let unknown = alias(&mut r, "Base", "unknown");
+        let x = r.resolve_qualified("Base::x").unwrap();
+        let xm = one(&mut r, x, "owningMembership");
+        for include_implied in [false, true] {
+            assert_eq!(
+                r.inherited_memberships(child, include_implied),
+                [xm, unknown]
+            );
+            assert!(r.inheritance_incomplete(child, include_implied));
+        }
+    }
+}
+
+#[test]
+fn layered_inheritance_diamonds_keep_one_alias_identity() {
+    let mut library =
+        String::from("class Values { feature x; } class Root { alias a for Values::x; }\n");
+    for level in 0..24 {
+        let bases = if level == 0 {
+            "Root".to_owned()
+        } else {
+            format!("Left{}, Right{}", level - 1, level - 1)
+        };
+        library.push_str(&format!(
+            "class Left{level} specializes {bases}; class Right{level} specializes {bases};\n"
+        ));
+    }
+    for mut r in models(&library, "class Leaf specializes Left23, Right23;") {
+        let a = alias(&mut r, "Root", "a");
+        let leaf = r.resolve_qualified("Leaf").unwrap();
+        for include_implied in [false, true, false] {
+            assert_eq!(r.inherited_memberships(leaf, include_implied), [a]);
+            assert!(!r.inheritance_walk_truncated(leaf, include_implied));
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/inherited_base_context.rs b/crates/sysmlv2-parser/tests/inherited_base_context.rs
new file mode 100644
index 0000000..22642be
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/inherited_base_context.rs
@@ -0,0 +1,97 @@
+//! Derived base scopes retain the target selected by a redefinition header.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    source_models(library, user)
+        .iter()
+        .map(ResolvedModel::build)
+        .collect()
+}
+
+fn source_models(library: &str, user: &str) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("lookup.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    let _ = ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(23).unwrap(), 23).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lookup.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("user.kerml", user);
+            assert!(!model.has_errors());
+            model
+        })
+        .collect()
+}
+
+#[test]
+fn redefining_features_inherit_members_from_their_suppressed_target() {
+    let library = "package Lib { class Base { feature x[2..4] { feature leaf; } } }";
+    let user = "package P { private import Lib::*;
+        class Child specializes Base { feature y redefines x; }
+        feature useMember references Child::y::leaf;
+    }";
+    for mut r in models(library, user) {
+        let base = r.resolve_qualified("Lib::Base::x").unwrap();
+        let member = r.resolve_qualified("Lib::Base::x::leaf").unwrap();
+        let derived = r.resolve_qualified("P::Child::y").unwrap();
+        assert_eq!(r.resolve_qualified("P::Child::x"), None);
+        assert_eq!(r.resolve_qualified("P::Child::y::leaf"), Some(member));
+        let expected: Vec<_> = r
+            .owned_relationships(base)
+            .into_iter()
+            .filter(|&e| r.membership_member(e).is_some())
+            .collect();
+        assert!(expected.iter().any(|&e| {
+            let target = r.membership_member(e).unwrap();
+            r.element_type(target) == "MultiplicityRange"
+        }));
+        for implied in [false, true] {
+            assert_eq!(r.inherited_memberships(derived, implied), expected);
+        }
+        let relation = r
+            .owned_relationships(derived)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "Redefinition")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(relation)["redefinedFeature"]["@id"],
+            r.element_id(base).to_string()
+        );
+        let selected = r.resolve_qualified("P::useMember").unwrap();
+        let reference = r
+            .owned_relationships(selected)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "ReferenceSubsetting")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(reference)["referencedFeature"]["@id"],
+            r.element_id(member).to_string()
+        );
+        let site = r
+            .reference_sites()
+            .iter()
+            .find(|s| s.owner == reference)
+            .unwrap();
+        assert!(site.via_imports.is_empty());
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/inherited_battery.rs b/crates/sysmlv2-parser/tests/inherited_battery.rs
index 9ee9baa..bff1a36 100644
--- a/crates/sysmlv2-parser/tests/inherited_battery.rs
+++ b/crates/sysmlv2-parser/tests/inherited_battery.rs
@@ -178,7 +178,7 @@ fn direct_import_filter_applies_at_first_hop() {
 fn alias_with_short_name_only_inherits() {
     let mut r = build(
         "package P {
-            part def Base { attribute mass; alias <m2> for mass; }
+            part def Base { part def Mass; alias <m2> for Mass; }
             part def Sub :> Base;
          }",
     );
@@ -290,9 +290,9 @@ fn owned_redefinition_seed_is_one_hop() {
 }
 
 #[test]
-fn deep_heritage_reports_truncation_and_terminates() {
-    // The walk shares lookup's recursion budget; past it the enumeration
-    // says so instead of silently presenting a cut result.
+fn deep_heritage_is_complete_independent_of_cache_warming() {
+    // Acyclic membership dependencies are evaluated iteratively, including
+    // chains deeper than name lookup's recursion budget.
     let chain = |n: usize| -> String {
         let mut src = String::from("package P { part def T0 { attribute a0; }");
         for i in 1..=n {
@@ -309,14 +309,21 @@ fn deep_heritage_reports_truncation_and_terminates() {
     assert!(!r.inheritance_walk_truncated(leaf, false));
     assert_eq!(r.inherited_features(leaf, false).len(), 10);
 
-    let mut r = build(&chain(30));
-    let leaf = r.resolve_qualified("P::T30").unwrap();
-    assert!(r.inheritance_walk_truncated(leaf, false));
-    let n = r.inherited_features(leaf, false).len();
-    assert!((24..30).contains(&n), "cut at the budget, got {n}");
-    // A shallow type in the same model is complete.
-    let mid = r.resolve_qualified("P::T5").unwrap();
-    assert!(!r.inheritance_walk_truncated(mid, false));
+    let mut snapshots = Vec::new();
+    for warm in [false, true] {
+        let mut r = build(&chain(40));
+        if warm {
+            for i in 1..40 {
+                let e = r.resolve_qualified(&format!("P::T{i}")).unwrap();
+                r.inherited_memberships(e, false);
+            }
+        }
+        let leaf = r.resolve_qualified("P::T40").unwrap();
+        assert!(!r.inheritance_walk_truncated(leaf, false));
+        assert_eq!(r.inherited_features(leaf, false).len(), 40);
+        snapshots.push(inherited_names(&mut r, "P::T40"));
+    }
+    assert_eq!(snapshots[0], snapshots[1]);
 }
 
 #[test]
diff --git a/crates/sysmlv2-parser/tests/inherited_default_report.rs b/crates/sysmlv2-parser/tests/inherited_default_report.rs
new file mode 100644
index 0000000..4d7ed08
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/inherited_default_report.rs
@@ -0,0 +1,486 @@
+//! Evaluation reports retain causes hidden by inherited-default fallback.
+#![cfg(feature = "json")]
+
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    eval::{EvalError, Value},
+    json::ResolvedModel,
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_with_users(library, &[("receivers.kerml", user)])
+}
+
+fn models_with_users(library: &str, users: &[(&str, &str)]) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    let unit = base.add_library_source("defaults.kerml", library);
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(37).unwrap(), 37).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("defaults.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for &(name, source) in users {
+                let unit = model.add_source(name, source);
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            }
+            assert!(!model.has_errors());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn same_error_kind(actual: &EvalError, expected: &EvalError) {
+    assert_eq!(
+        std::mem::discriminant(actual),
+        std::mem::discriminant(expected),
+        "{actual:?} versus {expected:?}"
+    );
+}
+
+#[test]
+fn inherited_errors_preserve_causes_and_provider_locations_in_every_representation() {
+    let library = "package A { class Base {
+        feature absent default = missing;
+        feature zero default = 1/0;
+        feature badType default = true+1;
+        feature unsupported default = ~1;
+        feature budget default = 1..1000001;
+    } }";
+    let user = "package B { class Child specializes A::Base {
+        feature redefines absent; feature redefines zero; feature redefines badType;
+        feature redefines unsupported; feature redefines budget;
+    } }";
+    for (model, mut r) in models(library, user) {
+        let loaded = model.loaded_library_unit_count();
+        let owner = r.resolve_qualified("B::Child").unwrap();
+        let receiver = r.element_scope(owner).unwrap();
+        for name in ["absent", "zero", "badType", "unsupported", "budget"] {
+            let origin = r.resolve_qualified(&format!("A::Base::{name}")).unwrap();
+            let requested = r.resolve_qualified(&format!("B::Child::{name}")).unwrap();
+            let source_span = r.value_expr(origin).unwrap().1.span;
+            let direct = r.evaluate_report(origin);
+            assert!(!direct.diagnostics_truncated);
+            let expected = direct.result.unwrap_err();
+            assert!(direct.inherited_default_failures.is_empty());
+            let legacy = r.evaluate(requested);
+            for _ in 0..2 {
+                let report = r.evaluate_report(requested);
+                assert!(!report.diagnostics_truncated);
+                assert_eq!(report.result, legacy, "{name}");
+                assert_eq!(report.inherited_default_failures.len(), 1, "{name}");
+                let failure = &report.inherited_default_failures[0];
+                assert_eq!(failure.requested, requested);
+                assert_eq!(failure.origin, origin);
+                assert_eq!(failure.receiver, receiver);
+                assert_eq!(failure.source_unit, 0);
+                assert_eq!(failure.source_span, source_span);
+                assert_eq!(failure.error, expected);
+                let terminal = failure.dependency_path.last().unwrap();
+                assert_eq!(terminal.requested, requested);
+                assert_eq!(terminal.origin, origin);
+                assert_eq!(terminal.receiver, receiver);
+            }
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn inherited_recursion_reports_cycle_without_changing_the_fallback() {
+    for (model, mut r) in models(
+        "package A { class Base { feature loop default = loop; } }",
+        "package B { class Child specializes A::Base { feature redefines loop; } }",
+    ) {
+        let loaded = model.loaded_library_unit_count();
+        let origin = r.resolve_qualified("A::Base::loop").unwrap();
+        let requested = r.resolve_qualified("B::Child::loop").unwrap();
+        let legacy = r.evaluate(requested);
+        let report = r.evaluate_report(requested);
+        assert!(!report.diagnostics_truncated);
+        assert_eq!(report.result, legacy);
+        assert!(!report.inherited_default_failures.is_empty());
+        assert!(report.inherited_default_failures.iter().any(|failure| {
+            failure.requested == requested
+                && failure.origin == origin
+                && matches!(failure.error, EvalError::Cycle(_))
+        }));
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn nested_fallback_remains_visible_when_the_result_is_concrete() {
+    for (model, mut r) in models(
+        "package A { class Base { feature inner[0] default = 1/0;
+            feature outer default = size(inner);
+        } }",
+        "package B { class Child specializes A::Base {
+            feature redefines inner; feature redefines outer;
+            feature masked = size(inner);
+        } }",
+    ) {
+        let loaded = model.loaded_library_unit_count();
+        let inner = r.resolve_qualified("B::Child::inner").unwrap();
+        let origin = r.resolve_qualified("A::Base::inner").unwrap();
+        for name in ["outer", "masked"] {
+            let outer = r.resolve_qualified(&format!("B::Child::{name}")).unwrap();
+            let legacy = r.evaluate(outer);
+            let report = r.evaluate_report(outer);
+            assert!(!report.diagnostics_truncated);
+            assert_eq!(report.result, legacy);
+            assert_eq!(report.result, Ok(Value::Integer(0)));
+            assert_eq!(report.inherited_default_failures.len(), 1);
+            let failure = &report.inherited_default_failures[0];
+            assert_eq!(failure.requested, inner);
+            assert_eq!(failure.origin, origin);
+            assert_eq!(failure.error, EvalError::DivisionByZero);
+            assert!(failure.dependency_path.iter().any(|d| d.requested == outer));
+            assert_eq!(failure.dependency_path.last().unwrap().requested, inner);
+            let rejected = report.into_checked_result().unwrap_err();
+            assert_eq!(rejected.result, Ok(Value::Integer(0)));
+            assert_eq!(rejected.inherited_default_failures.len(), 1);
+        }
+        let masked = r.resolve_qualified("B::Child::masked").unwrap();
+        let (scope, expr) = r.value_expr(masked).unwrap();
+        let legacy = r.evaluate_in(scope, &expr);
+        let report = r.evaluate_in_report(scope, &expr);
+        assert!(!report.diagnostics_truncated);
+        assert_eq!(report.result, legacy);
+        assert_eq!(report.inherited_default_failures.len(), 1);
+        assert_eq!(report.inherited_default_failures[0].requested, inner);
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn ordinary_unknowns_successful_defaults_and_unvisited_branches_are_not_failures() {
+    for (model, mut r) in models(
+        "package A { class Base { feature empty; feature fixed = 7;
+            feature good default = 4; feature broken default = 1/0;
+        } }",
+        "package B { class Child specializes A::Base {
+            feature redefines empty; feature redefines fixed; feature redefines good;
+            feature override redefines A::Base::broken = 9;
+            feature redefines broken;
+            feature dead = if true ? 3 else broken;
+        } }",
+    ) {
+        let loaded = model.loaded_library_unit_count();
+        let broken = r.resolve_qualified("B::Child::broken").unwrap();
+        assert!(
+            !r.evaluate_report(broken)
+                .inherited_default_failures
+                .is_empty()
+        );
+        for (name, expected) in [
+            ("empty", None),
+            ("fixed", None),
+            ("good", Some(Value::Integer(4))),
+            ("override", Some(Value::Integer(9))),
+            ("dead", Some(Value::Integer(3))),
+        ] {
+            let e = r.resolve_qualified(&format!("B::Child::{name}")).unwrap();
+            let legacy = r.evaluate(e);
+            let report = r.evaluate_report(e);
+            assert!(!report.diagnostics_truncated);
+            assert_eq!(report.result, legacy);
+            if let Some(expected) = expected {
+                assert_eq!(report.result, Ok(expected));
+            }
+            assert!(report.inherited_default_failures.is_empty(), "{name}");
+            let checked = report.into_checked_result().unwrap();
+            if matches!(name, "empty" | "fixed") {
+                assert!(matches!(checked, Value::Unbound(_)));
+            }
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn separate_receivers_and_terminal_errors_keep_their_own_failure_context() {
+    for (model, mut r) in models(
+        "package A { class Base { feature broken[0] default = 1/0; } }",
+        "package B {
+            class Left specializes A::Base { feature redefines broken; }
+            class Right specializes A::Base { feature redefines broken; }
+            feature answer = (Left::broken, Right::broken, 1/0);
+        }",
+    ) {
+        let loaded = model.loaded_library_unit_count();
+        let answer = r.resolve_qualified("B::answer").unwrap();
+        let legacy = r.evaluate(answer);
+        let report = r.evaluate_report(answer);
+        assert!(!report.diagnostics_truncated);
+        assert_eq!(report.result, legacy);
+        same_error_kind(&report.result.unwrap_err(), &EvalError::DivisionByZero);
+        assert_eq!(report.inherited_default_failures.len(), 2);
+        for (failure, name) in report
+            .inherited_default_failures
+            .iter()
+            .zip(["Left", "Right"])
+        {
+            let owner = r.resolve_qualified(&format!("B::{name}")).unwrap();
+            let feature = r.resolve_qualified(&format!("B::{name}::broken")).unwrap();
+            assert_eq!(failure.requested, feature);
+            assert_eq!(failure.receiver, r.element_scope(owner).unwrap());
+            assert_eq!(failure.error, EvalError::DivisionByZero);
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn unknown_receiver_default_is_not_an_attempted_failure() {
+    let mut model = Model::new();
+    let unit = model.add_source(
+        "receiver.sysml",
+        "part def Base { attribute broken default = 1/0; }
+        part def Child :> Base { attribute :>> broken; }
+        requirement def R { subject unit : Child[1]; }
+        attribute answer = R::unit.broken;",
+    );
+    assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+    let mut r = ResolvedModel::build(&model);
+    let answer = r.resolve_qualified("answer").unwrap();
+    let legacy = r.evaluate(answer);
+    let report = r.evaluate_report(answer);
+    assert!(!report.diagnostics_truncated);
+    assert_eq!(report.result, legacy);
+    assert_eq!(report.result, Ok(Value::Indeterminate));
+    assert!(report.inherited_default_failures.is_empty());
+}
+
+#[test]
+fn inherited_id_bound_defaults_report_the_authored_provider_not_the_reference_target() {
+    const ID: &str = "99999999-9999-4999-8999-999999999999";
+    for foreign_zero in [true, false] {
+        let foreign = if foreign_zero { 0 } else { 1 };
+        let ordinary = if foreign_zero { 1 } else { 0 };
+        let library = format!("package Support {{ feature denominator = {foreign}; }}");
+        let a = format!(
+            "package A {{ class Base {{ feature '{ID}' = {ordinary}; feature v default = 1/'{ID}'; }} }}"
+        );
+        let b = a.replacen("package A", "package B", 1);
+        let receivers = "package C {
+            class Left specializes A::Base { feature redefines v; }
+            class Right specializes B::Base { feature redefines v; }
+        }";
+        for (mode, (model, mut r)) in models_with_users(
+            &library,
+            &[
+                ("a.kerml", &a),
+                ("b.kerml", &b),
+                ("receivers.kerml", receivers),
+            ],
+        )
+        .into_iter()
+        .enumerate()
+        {
+            let loaded = model.loaded_library_unit_count();
+            let foreign = r.resolve_qualified("Support::denominator").unwrap();
+            let ordinary_a = r.resolve_qualified(&format!("A::Base::'{ID}'")).unwrap();
+            let sites = r.references_to(ordinary_a);
+            assert_eq!(sites.len(), 1);
+            assert_eq!(sites[0].unit, 1);
+            let mut hints = HashMap::from([(
+                (r.element_id(sites[0].owner), sites[0].kind.clone()),
+                ID.parse().unwrap(),
+            )]);
+            r.override_ids(&HashMap::from([(
+                r.element_id(foreign),
+                ID.parse().unwrap(),
+            )]));
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            let a_origin = r.resolve_qualified("A::Base::v").unwrap();
+            let b_origin = r.resolve_qualified("B::Base::v").unwrap();
+            // Equal expression spans make a wrong source origin choose a real,
+            // differently bound reference instead of merely failing lookup.
+            let a_span = r.value_expr(a_origin).unwrap().1.span;
+            let b_span = r.value_expr(b_origin).unwrap().1.span;
+            assert_eq!(a_span, b_span);
+            for _ in 0..2 {
+                for (side, origin, unit, fails) in [
+                    ("Left", a_origin, 1, foreign_zero),
+                    ("Right", b_origin, 2, !foreign_zero),
+                ] {
+                    let owner = r.resolve_qualified(&format!("C::{side}")).unwrap();
+                    let requested = r.resolve_qualified(&format!("C::{side}::v")).unwrap();
+                    let receiver = r.element_scope(owner).unwrap();
+                    let legacy = r.evaluate(requested);
+                    let report = r.evaluate_report(requested);
+                    assert!(!report.diagnostics_truncated);
+                    assert_eq!(report.result, legacy, "mode={mode} {side}");
+                    assert_eq!(report.inherited_default_failures.len(), usize::from(fails));
+                    if fails {
+                        assert!(matches!(report.result, Ok(Value::Unbound(_))));
+                        let failure = &report.inherited_default_failures[0];
+                        assert_eq!(failure.requested, requested);
+                        assert_eq!(failure.origin, origin);
+                        assert_eq!(failure.receiver, receiver);
+                        assert_eq!(failure.source_unit, unit);
+                        assert_eq!(failure.source_span, a_span);
+                        assert_eq!(failure.error, EvalError::DivisionByZero);
+                        let terminal = failure.dependency_path.last().unwrap();
+                        assert_eq!(terminal.requested, requested);
+                        assert_eq!(terminal.origin, origin);
+                        assert_eq!(terminal.receiver, receiver);
+                        assert!(report.into_checked_result().is_err());
+                    } else {
+                        assert_eq!(report.into_checked_result().unwrap(), Value::Integer(1));
+                    }
+                    // Error provenance belongs to the provider expression in
+                    // unit 1/2, never the foreign denominator in library unit 0
+                    // or the receiving redefinition in user unit 3.
+                    let direct = r.evaluate_report(origin);
+                    assert!(!direct.diagnostics_truncated);
+                    assert!(direct.inherited_default_failures.is_empty());
+                    assert_eq!(direct.result, r.evaluate(origin));
+                    if fails {
+                        assert_eq!(direct.result, Err(EvalError::DivisionByZero));
+                    }
+                }
+            }
+            assert_eq!(model.loaded_library_unit_count(), loaded);
+            if mode == 3 {
+                assert_eq!(loaded, 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn exhausted_reporting_capacity_preserves_the_legacy_value_and_rejects_checked_conversion() {
+    let reads = std::iter::repeat_n("Child::broken", 300)
+        .collect::<Vec<_>>()
+        .join(",");
+    let user = format!(
+        "package B {{ class Child specializes A::Base {{ feature redefines broken; }}
+         feature answer = ({reads}); }}"
+    );
+    for (mode, (model, mut r)) in models(
+        "package A { class Base { feature broken[0] default = 1/0; } }",
+        &user,
+    )
+    .into_iter()
+    .enumerate()
+    {
+        let loaded = model.loaded_library_unit_count();
+        let answer = r.resolve_qualified("B::answer").unwrap();
+        let requested = r.resolve_qualified("B::Child::broken").unwrap();
+        let origin = r.resolve_qualified("A::Base::broken").unwrap();
+        let legacy = r.evaluate(answer);
+        assert_eq!(legacy, Ok(Value::Sequence(Vec::new())));
+        for _ in 0..2 {
+            let report = r.evaluate_report(answer);
+            assert_eq!(report.result, legacy, "mode={mode}");
+            assert!(report.diagnostics_truncated);
+            assert_eq!(report.inherited_default_failures.len(), 256);
+            for failure in &report.inherited_default_failures {
+                assert_eq!(failure.requested, requested);
+                assert_eq!(failure.origin, origin);
+                assert_eq!(failure.error, EvalError::DivisionByZero);
+                assert_eq!(failure.dependency_path.first().unwrap().requested, answer);
+                assert_eq!(failure.dependency_path.last().unwrap().requested, requested);
+            }
+            let rejected = report.into_checked_result().unwrap_err();
+            assert_eq!(rejected.result, legacy);
+            assert!(rejected.diagnostics_truncated);
+        }
+        let direct = r.evaluate_report(origin);
+        assert_eq!(direct.result, Err(EvalError::DivisionByZero));
+        assert!(direct.inherited_default_failures.is_empty());
+        assert!(!direct.diagnostics_truncated);
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+        if mode == 3 {
+            assert_eq!(loaded, 0);
+        }
+    }
+}
+
+#[test]
+fn warmed_unit_reductions_cannot_hide_failed_inherited_conversion_defaults() {
+    for (expression, cycle) in [("1/0", false), ("conversionFactor", true)] {
+        let library = format!(
+            "package A {{ class C {{ feature conversionFactor default = {expression}; }}
+             feature s; }}"
+        );
+        let user = "package B {
+            feature unit {
+                feature unitConversion : A::C {
+                    feature referenceUnit = A::s;
+                    feature redefines conversionFactor;
+                }
+            }
+            feature answer = 1[unit];
+        }";
+        for (mode, (model, _)) in models(&library, user).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            for legacy_first in [true, false] {
+                let mut r = ResolvedModel::build(&model);
+                let answer = r.resolve_qualified("B::answer").unwrap();
+                let requested = r
+                    .resolve_qualified("B::unit::unitConversion::conversionFactor")
+                    .unwrap();
+                let origin = r.resolve_qualified("A::C::conversionFactor").unwrap();
+                let source_span = r.value_expr(origin).unwrap().1.span;
+                let (scope, expr) = r.value_expr(answer).unwrap();
+                let mut legacy = legacy_first.then(|| r.evaluate_in(scope, &expr));
+                for _ in 0..3 {
+                    let report = r.evaluate_in_report(scope, &expr);
+                    assert!(!report.diagnostics_truncated);
+                    assert!(matches!(report.result, Ok(Value::Quantity(..))));
+                    if let Some(expected) = &legacy {
+                        assert_eq!(&report.result, expected);
+                    }
+                    assert_eq!(
+                        report.inherited_default_failures.len(),
+                        1,
+                        "mode={mode} cycle={cycle} legacy_first={legacy_first}"
+                    );
+                    let failure = &report.inherited_default_failures[0];
+                    assert_eq!(failure.requested, requested);
+                    assert_eq!(failure.origin, origin);
+                    assert_eq!(failure.source_unit, 0);
+                    assert_eq!(failure.source_span, source_span);
+                    if cycle {
+                        assert!(matches!(failure.error, EvalError::Cycle(_)));
+                    } else {
+                        assert_eq!(failure.error, EvalError::DivisionByZero);
+                    }
+                    let result = report.result.clone();
+                    assert!(report.into_checked_result().is_err());
+                    legacy = Some(r.evaluate_in(scope, &expr));
+                    assert_eq!(legacy.as_ref().unwrap(), &result);
+                }
+            }
+            assert_eq!(model.loaded_library_unit_count(), loaded);
+            if mode == 3 {
+                assert_eq!(loaded, 0);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/inherited_lookup.rs b/crates/sysmlv2-parser/tests/inherited_lookup.rs
new file mode 100644
index 0000000..a8c6ffe
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/inherited_lookup.rs
@@ -0,0 +1,888 @@
+//! Inherited name selection must agree with stored reference endpoints.
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    source_models(library, user)
+        .iter()
+        .map(ResolvedModel::build)
+        .collect()
+}
+
+fn source_models(library: &str, user: &str) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("lookup.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    let _ = ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(23).unwrap(), 23).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lookup.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("user.kerml", user);
+            assert!(!model.has_errors());
+            model
+        })
+        .collect()
+}
+
+fn edge(r: &mut ResolvedModel, owner: &str, kind: &str) -> ElementRef {
+    let e = r.resolve_qualified(owner).unwrap();
+    r.owned_relationships(e)
+        .into_iter()
+        .find(|&e| r.element_type(e) == kind)
+        .unwrap()
+}
+
+fn endpoint(r: &mut ResolvedModel, owner: &str, kind: &str, property: &str, target: Option<&str>) {
+    let e = edge(r, owner, kind);
+    let value = r.element_properties(e);
+    match target {
+        Some(name) => {
+            let target = r.resolve_qualified(name).unwrap();
+            assert_eq!(
+                value[property]["@id"],
+                r.element_id(target).to_string(),
+                "{owner}"
+            );
+            // Library sites are deliberately absent from reference-site records.
+            if !r.is_library_element(e) {
+                assert!(
+                    r.reference_sites()
+                        .iter()
+                        .any(|s| { s.owner == e && s.kind == property && s.target == target }),
+                    "missing reference site for {owner}"
+                );
+            }
+        }
+        None => {
+            assert!(value[property]["@ref"].is_string(), "{owner}: {value:?}");
+            assert!(
+                !r.reference_sites()
+                    .iter()
+                    .any(|s| s.owner == e && s.kind == property)
+            );
+            assert!(r.unresolved_references().iter().any(|s| s.owner == e));
+        }
+    }
+}
+
+#[test]
+fn distinct_feature_memberships_are_removed_before_lookup_and_binding() {
+    let library = "class Base { feature x; alias ax for x; } class Child specializes Base;";
+    let user = "feature useX subsets Child::x; feature useAlias references Child::ax;";
+    for mut r in models(library, user) {
+        for warm in [false, true] {
+            if warm {
+                let child = r.resolve_qualified("Child").unwrap();
+                assert!(r.inherited_memberships(child, false).is_empty());
+            }
+            assert_eq!(r.resolve_qualified("Child::x"), None);
+            assert_eq!(r.resolve_qualified("Child::ax"), None);
+            endpoint(&mut r, "useX", "Subsetting", "subsettedFeature", None);
+            endpoint(
+                &mut r,
+                "useAlias",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                None,
+            );
+        }
+    }
+}
+
+#[test]
+fn redefinitions_under_other_names_remove_inherited_lookup_candidates() {
+    for library in [
+        "class A { feature x; } class B specializes A { feature y redefines A::x; } class Child specializes A, B;",
+        "class Child specializes A, B; class B specializes A { feature y redefines A::x; } class A { feature x; }",
+    ] {
+        for mut r in models(
+            library,
+            "feature gone subsets Child::x; feature kept subsets Child::y;",
+        ) {
+            assert_eq!(r.resolve_qualified("Child::x"), None);
+            let y = r.resolve_qualified("B::y").unwrap();
+            assert_eq!(r.resolve_qualified("Child::y"), Some(y));
+            endpoint(&mut r, "gone", "Subsetting", "subsettedFeature", None);
+            endpoint(
+                &mut r,
+                "kept",
+                "Subsetting",
+                "subsettedFeature",
+                Some("B::y"),
+            );
+        }
+    }
+}
+
+#[test]
+fn descendant_filtering_can_recover_a_candidate_from_ancestor_ambiguity() {
+    let library = "class A { feature x; } class B { feature x; }
+        class Mid specializes A, B;
+        class Child specializes Mid { feature z redefines A::x; }";
+    for mut r in models(library, "feature selected subsets Child::x;") {
+        assert_eq!(r.resolve_qualified("Mid::x"), None);
+        let x = r.resolve_qualified("B::x").unwrap();
+        assert_eq!(r.resolve_qualified("Child::x"), Some(x));
+        endpoint(
+            &mut r,
+            "selected",
+            "Subsetting",
+            "subsettedFeature",
+            Some("B::x"),
+        );
+        endpoint(
+            &mut r,
+            "Child::z",
+            "Redefinition",
+            "redefinedFeature",
+            Some("A::x"),
+        );
+    }
+}
+
+#[test]
+fn redefinition_headers_keep_their_inherited_target_on_replay() {
+    let library = "class Base { feature x; }";
+    for user in [
+        "class Child specializes Base { feature y redefines x; feature z redefines x; feature use references x; }",
+        "class Child specializes Base { feature use references x; feature z redefines x; feature y redefines x; }",
+    ] {
+        for mut r in models(library, user) {
+            for name in ["Child::y", "Child::z"] {
+                endpoint(
+                    &mut r,
+                    name,
+                    "Redefinition",
+                    "redefinedFeature",
+                    Some("Base::x"),
+                );
+            }
+            assert_eq!(r.resolve_qualified("Child::x"), None);
+            endpoint(
+                &mut r,
+                "Child::use",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                None,
+            );
+        }
+    }
+}
+
+#[test]
+fn alias_visibility_applies_to_the_membership_instead_of_its_target() {
+    let library = "class PublicAlias { private feature x; alias ax for x; }
+        class PrivateAlias { feature x; private alias ax for x; }
+        class A specializes PublicAlias;
+        class B specializes PrivateAlias;";
+    for mut r in models(library, "feature a subsets A::ax; feature b subsets B::x;") {
+        let ax = r.resolve_qualified("PublicAlias::x").unwrap();
+        let bx = r.resolve_qualified("PrivateAlias::x").unwrap();
+        assert_eq!(r.resolve_qualified("A::ax"), Some(ax));
+        assert_eq!(r.resolve_qualified("A::x"), None);
+        assert_eq!(r.resolve_qualified("B::x"), Some(bx));
+        assert_eq!(r.resolve_qualified("B::ax"), None);
+        endpoint(
+            &mut r,
+            "a",
+            "Subsetting",
+            "subsettedFeature",
+            Some("PublicAlias::x"),
+        );
+        endpoint(
+            &mut r,
+            "b",
+            "Subsetting",
+            "subsettedFeature",
+            Some("PrivateAlias::x"),
+        );
+    }
+}
+
+#[test]
+fn a_shared_alias_identity_survives_a_diamond_but_distinct_aliases_do_not() {
+    let library = "class Values { feature x; }
+        class Base { alias ax for Values::x; }
+        class Left specializes Base; class Right specializes Base;
+        class Shared specializes Left, Right;
+        class Other { alias bx for Values::x; }
+        class Distinct specializes Base, Other;";
+    for mut r in models(
+        library,
+        "feature a subsets Shared::ax; feature b subsets Distinct::ax;",
+    ) {
+        let x = r.resolve_qualified("Values::x").unwrap();
+        assert_eq!(r.resolve_qualified("Shared::ax"), Some(x));
+        assert_eq!(r.resolve_qualified("Distinct::ax"), None);
+        assert_eq!(r.resolve_qualified("Distinct::bx"), None);
+        endpoint(
+            &mut r,
+            "a",
+            "Subsetting",
+            "subsettedFeature",
+            Some("Values::x"),
+        );
+        endpoint(&mut r, "b", "Subsetting", "subsettedFeature", None);
+    }
+}
+
+#[test]
+fn library_origin_references_use_the_same_selection_after_cache_replay() {
+    let library = "feature before references Child::ax;
+        class Base { feature x; alias ax for x; }
+        class Child specializes Base;
+        feature after subsets Child::x;";
+    for mut r in models(library, "feature userReference references Child::ax;") {
+        endpoint(
+            &mut r,
+            "before",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            None,
+        );
+        endpoint(&mut r, "after", "Subsetting", "subsettedFeature", None);
+        endpoint(
+            &mut r,
+            "userReference",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            None,
+        );
+    }
+}
+
+#[test]
+fn identity_overrides_preserve_cached_membership_selection_and_reference_endpoints() {
+    let library = "class Base { feature x; alias ax for x; feature safe; }
+        class Child specializes Base;";
+    for mut r in models(
+        library,
+        "feature gone subsets Child::ax; feature kept subsets Child::safe;",
+    ) {
+        let child = r.resolve_qualified("Child").unwrap();
+        r.inherited_memberships(child, true);
+        r.resolve_qualified("Child::safe");
+        let x = r.resolve_qualified("Base::x").unwrap();
+        let safe = r.resolve_qualified("Base::safe").unwrap();
+        let replacement = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"lookup target override");
+        let replacement_safe =
+            uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"lookup safe override");
+        r.override_ids(&std::collections::HashMap::from([
+            (r.element_id(x), replacement),
+            (r.element_id(safe), replacement_safe),
+        ]));
+        assert_eq!(r.resolve_qualified("Child::x"), None);
+        assert_eq!(r.resolve_qualified("Child::ax"), None);
+        assert_eq!(r.resolve_qualified("Child::safe"), Some(safe));
+        endpoint(&mut r, "gone", "Subsetting", "subsettedFeature", None);
+        endpoint(
+            &mut r,
+            "kept",
+            "Subsetting",
+            "subsettedFeature",
+            Some("Base::safe"),
+        );
+    }
+}
+
+#[test]
+fn unknown_and_cyclic_dependencies_remain_qualified_without_losing_known_members() {
+    let library = "class Base { feature x; alias unknown for Missing; }
+        class Child specializes Base;
+        class A specializes B { feature a; } class B specializes A;";
+    for mut r in models(
+        library,
+        "feature useX subsets Child::x; feature useA subsets B::a;",
+    ) {
+        let child = r.resolve_qualified("Child").unwrap();
+        let b = r.resolve_qualified("B").unwrap();
+        assert!(r.inheritance_incomplete(child, false));
+        assert!(r.inheritance_incomplete(b, false));
+        endpoint(
+            &mut r,
+            "useX",
+            "Subsetting",
+            "subsettedFeature",
+            Some("Base::x"),
+        );
+        endpoint(
+            &mut r,
+            "useA",
+            "Subsetting",
+            "subsettedFeature",
+            Some("A::a"),
+        );
+    }
+}
+
+#[test]
+fn user_completion_rechecks_library_references_that_depend_on_alias_membership() {
+    let library = "class Base { feature x; alias ax for Future::x; }
+        class Child specializes Base;
+        feature libraryReference references Child::x;";
+    for mut r in models(
+        library,
+        "class Future { alias x for Base::x; } feature userReference references Child::ax;",
+    ) {
+        assert_eq!(r.resolve_qualified("Child::x"), None);
+        assert_eq!(r.resolve_qualified("Child::ax"), None);
+        endpoint(
+            &mut r,
+            "libraryReference",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            None,
+        );
+        endpoint(
+            &mut r,
+            "userReference",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            None,
+        );
+    }
+    let library = "class Base { alias ax for Future::x; }
+        class Child specializes Base;
+        feature libraryReference references Child::ax;";
+    for mut r in models(library, "class Future { feature x; }") {
+        endpoint(
+            &mut r,
+            "libraryReference",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            Some("Future::x"),
+        );
+    }
+}
+
+#[test]
+fn an_actual_self_redefinition_does_not_remove_its_only_membership() {
+    let target_id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"self redefinition target");
+    let mut model = Model::new();
+    model.add_source(
+        "self.kerml",
+        &format!(
+            "assoc SelfCycle {{ end feature x redefines '{target_id}'; }}
+             assoc Child specializes SelfCycle {{ end feature slot; }}"
+        ),
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    let x = r.resolve_qualified("SelfCycle::x").unwrap();
+    let child = r.resolve_qualified("Child").unwrap();
+    let _ = r.inherited_memberships(child, false);
+    r.override_ids(&std::collections::HashMap::from([(
+        r.element_id(x),
+        target_id,
+    )]));
+    assert!(r.bind_id_spelled_references().contains(&target_id));
+    let relation = edge(&mut r, "SelfCycle::x", "Redefinition");
+    assert_eq!(
+        r.element_properties(relation)["redefinedFeature"]["@id"],
+        target_id.to_string(),
+        "the fixture must contain a resolved self-edge"
+    );
+    assert_eq!(r.inherited_memberships(child, false).len(), 1);
+    assert_eq!(r.resolve_qualified("Child::x"), Some(x));
+    let slot = r.resolve_qualified("Child::slot").unwrap();
+    let targets: Vec<_> = r
+        .implied_relationships(slot)
+        .into_iter()
+        .filter(|&edge| r.element_type(edge) == "Redefinition")
+        .map(|edge| r.element_properties(edge)["redefinedFeature"]["@id"].clone())
+        .collect();
+    assert_eq!(targets, [serde_json::json!(target_id.to_string())]);
+}
+
+#[test]
+fn redefinition_targets_start_in_direct_bases_before_declaring_type_locals() {
+    for (bases, local) in [("A, B", ""), ("B, A", ""), ("A", "feature x;")] {
+        let library = "class A { feature x; } class B { feature x; }";
+        let user = format!("class Child specializes {bases} {{ {local} feature y redefines x; }}");
+        for mut r in models(library, &user) {
+            endpoint(
+                &mut r,
+                "Child::y",
+                "Redefinition",
+                "redefinedFeature",
+                Some(if bases.starts_with('A') {
+                    "A::x"
+                } else {
+                    "B::x"
+                }),
+            );
+            let remaining = r.resolve_qualified("Child::x").unwrap();
+            if bases == "A" {
+                let child = r.resolve_qualified("Child").unwrap();
+                assert!(r.owned_features(child).contains(&remaining));
+            } else {
+                let unselected = if bases.starts_with('A') {
+                    "B::x"
+                } else {
+                    "A::x"
+                };
+                assert_eq!(Some(remaining), r.resolve_qualified(unselected));
+            }
+        }
+    }
+}
+
+#[test]
+fn inherited_effective_names_retain_the_unnamed_redefining_feature() {
+    for mut r in models(
+        "class Base { feature x; }",
+        "class Mid specializes Base { feature redefines x; }
+         class Child specializes Mid; feature useX references Child::x;",
+    ) {
+        let inherited = r.resolve_qualified("Child::x").unwrap();
+        let original = r.resolve_qualified("Base::x").unwrap();
+        assert_ne!(inherited, original);
+        let mid = r.resolve_qualified("Mid").unwrap();
+        assert!(r.owned_features(mid).contains(&inherited));
+        endpoint(
+            &mut r,
+            "useX",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            Some("Child::x"),
+        );
+    }
+}
+
+#[test]
+fn unstable_reference_dependencies_restore_a_consistent_qualified_result() {
+    let library = "class A { feature x; }
+        class B specializes A { feature y redefines C::x; }
+        class C specializes A, B;
+        feature libraryReference references C::x;";
+    for mut r in models(library, "feature userReference references C::x;") {
+        let c = r.resolve_qualified("C").unwrap();
+        assert!(r.inheritance_incomplete(c, false));
+        // The contextual bootstrap consistently binds all three endpoints.
+        // Never expose endpoints or diagnostics from an arbitrary replay pass.
+        for (owner, kind, property) in [
+            ("B::y", "Redefinition", "redefinedFeature"),
+            (
+                "libraryReference",
+                "ReferenceSubsetting",
+                "referencedFeature",
+            ),
+            ("userReference", "ReferenceSubsetting", "referencedFeature"),
+        ] {
+            endpoint(&mut r, owner, kind, property, Some("A::x"));
+        }
+        assert_eq!(r.resolve_qualified("C::x"), r.resolve_qualified("A::x"));
+        assert!(r.unresolved_references().is_empty());
+    }
+}
+
+#[test]
+fn replay_preserves_ambiguity_and_missing_diagnostic_categories() {
+    let library = "class A { feature x; } class B { feature x; }
+        class Mid specializes A, B;
+        class Child specializes Mid { feature z redefines A::x; }
+        feature libraryAmbiguous references Mid::x;";
+    let user = "feature ambiguousUse references Mid::x;
+        feature missingUse references Child::absent;
+        feature resolvedUse references Child::x;";
+    for model in source_models(library, user) {
+        let report = sysmlv2_parser::json::model_resolution_report(&model);
+        let ambiguous: Vec<_> = report
+            .ambiguous
+            .iter()
+            .map(|(unit, qn)| (*unit, qn.to_ref_string()))
+            .collect();
+        assert_eq!(ambiguous, [(0, "Mid::x".into()), (1, "Mid::x".into())]);
+        assert!(
+            report
+                .unresolved
+                .iter()
+                .any(|(unit, qn)| { *unit == 1 && qn.to_ref_string() == "Child::absent" })
+        );
+        assert!(
+            !report
+                .unresolved
+                .iter()
+                .any(|(_, qn)| qn.to_ref_string() == "Child::x")
+        );
+    }
+}
+
+#[test]
+fn global_redefinition_targets_still_require_a_direct_base_starting_context() {
+    for mut r in models(
+        "class A { feature x; }",
+        "class C { feature y redefines $::A::x; }
+         class D specializes A { feature y redefines $::A::x; }",
+    ) {
+        endpoint(&mut r, "C::y", "Redefinition", "redefinedFeature", None);
+        endpoint(
+            &mut r,
+            "D::y",
+            "Redefinition",
+            "redefinedFeature",
+            Some("A::x"),
+        );
+    }
+}
+
+#[test]
+fn inherited_aliases_preserve_import_provenance_from_enclosing_namespaces() {
+    let library = "package Q { feature importedFeature; }
+        package P { private import Q::*;
+            class Base { alias ax for importedFeature; }
+            class Child specializes Base;
+        }";
+    for mut r in models(library, "feature useAlias references P::Child::ax;") {
+        endpoint(
+            &mut r,
+            "useAlias",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            Some("Q::importedFeature"),
+        );
+        let reference = edge(&mut r, "useAlias", "ReferenceSubsetting");
+        let import = edge(&mut r, "P", "NamespaceImport");
+        let site = r
+            .reference_sites()
+            .iter()
+            .find(|s| s.owner == reference && s.kind == "referencedFeature")
+            .unwrap();
+        assert!(site.via_imports.iter().any(|&(e, _)| e == import));
+        assert!(r.unresolved_references().is_empty());
+    }
+}
+
+#[test]
+fn imported_explicit_bases_filter_names_without_inheriting_import_walks() {
+    let library = "package Lib {
+        class A { feature x; }
+        class B specializes A { feature y redefines x; }
+    }";
+    for imports in [
+        "private import Lib::*;",
+        "private import Lib::A; private import Lib::B;",
+    ] {
+        let user = format!(
+            "package P {{ {imports} package Nested {{
+                class Child specializes A, B;
+                feature useX references Child::x;
+                feature useY references Child::y;
+            }} }}"
+        );
+        for mut r in models(library, &user) {
+            endpoint(
+                &mut r,
+                "P::Nested::useX",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                None,
+            );
+            endpoint(
+                &mut r,
+                "P::Nested::useY",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                Some("Lib::B::y"),
+            );
+            for warm in [false, true] {
+                let child = r.resolve_qualified("P::Nested::Child").unwrap();
+                if warm {
+                    let _ = r.inherited_memberships(child, false);
+                }
+                assert_eq!(r.resolve_qualified("P::Nested::Child::x"), None);
+                let y = r.resolve_qualified("Lib::B::y").unwrap();
+                assert_eq!(r.resolve_qualified("P::Nested::Child::y"), Some(y));
+            }
+            let child = r.resolve_qualified("P::Nested::Child").unwrap();
+            for relation in r.owned_relationships(child) {
+                if r.element_type(relation) != "Subclassification" {
+                    continue;
+                }
+                let site = r
+                    .reference_sites()
+                    .iter()
+                    .find(|s| s.owner == relation && s.kind == "superclassifier")
+                    .unwrap();
+                assert_eq!(site.via_imports.len(), 1);
+                assert_eq!(site.via_imports[0].1, sysmlv2_parser::json::AccessMode::Any);
+                assert!(r.element_type(site.via_imports[0].0).ends_with("Import"));
+            }
+            let use_y = edge(&mut r, "P::Nested::useY", "ReferenceSubsetting");
+            let site = r
+                .reference_sites()
+                .iter()
+                .find(|s| s.owner == use_y && s.kind == "referencedFeature")
+                .unwrap();
+            assert!(
+                site.via_imports.is_empty(),
+                "base binding imports belong only to the specialization"
+            );
+            assert!(r.blocked_references().is_empty());
+        }
+    }
+}
+
+#[test]
+fn imported_base_redefinition_headers_ignore_declaring_type_shadowing() {
+    for mut r in models(
+        "package Lib { class Base { feature x; } }",
+        "package P { private import Lib::*;
+            class Child specializes Base { feature x; feature y redefines x; }
+        }",
+    ) {
+        endpoint(
+            &mut r,
+            "P::Child::y",
+            "Redefinition",
+            "redefinedFeature",
+            Some("Lib::Base::x"),
+        );
+        let edge = edge(&mut r, "P::Child::y", "Redefinition");
+        let site = r
+            .reference_sites()
+            .iter()
+            .find(|s| s.owner == edge && s.kind == "redefinedFeature")
+            .unwrap();
+        assert!(site.via_imports.is_empty());
+        assert!(r.unresolved_references().is_empty());
+    }
+}
+
+#[test]
+fn qualified_alias_targets_preserve_import_walks_outside_lexical_ancestors() {
+    for target in ["Exposed::x", "$::Exposed::x", "Intermediate::ax"] {
+        let library = format!(
+            "package Q {{ feature x; }}
+            package Exposed {{ public import Q::*; }}
+            class Intermediate {{ alias ax for Exposed::x; }}
+            class Base {{ alias ax for {target}; }}
+            class Mid specializes Base;
+            class Child specializes Mid;"
+        );
+        for mut r in models(&library, "feature selected references Child::ax;") {
+            endpoint(
+                &mut r,
+                "selected",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                Some("Q::x"),
+            );
+            let import = edge(&mut r, "Exposed", "NamespaceImport");
+            let relation = edge(&mut r, "selected", "ReferenceSubsetting");
+            let site = r
+                .reference_sites()
+                .iter()
+                .find(|s| s.owner == relation && s.kind == "referencedFeature")
+                .unwrap();
+            assert_eq!(
+                site.via_imports,
+                [(import, sysmlv2_parser::json::AccessMode::Public)],
+                "{target}"
+            );
+            let child = r.resolve_qualified("Child").unwrap();
+            let _ = r.inherited_memberships(child, false);
+            let expected = r.resolve_qualified("Q::x").unwrap();
+            assert_eq!(r.resolve_qualified("Child::ax"), Some(expected));
+        }
+    }
+}
+
+#[test]
+fn imports_in_base_bodies_keep_their_actual_member_access_walks() {
+    for visibility in ["public", "protected"] {
+        let library = format!(
+            "package Q {{ feature x; }}
+            class Base {{ {visibility} import Q::*; }}
+            class Child specializes Base;"
+        );
+        for mut r in models(
+            &library,
+            "class User specializes Child { feature selected references x; }",
+        ) {
+            endpoint(
+                &mut r,
+                "User::selected",
+                "ReferenceSubsetting",
+                "referencedFeature",
+                Some("Q::x"),
+            );
+            let import = edge(&mut r, "Base", "NamespaceImport");
+            let relation = edge(&mut r, "User::selected", "ReferenceSubsetting");
+            let site = r
+                .reference_sites()
+                .iter()
+                .find(|s| s.owner == relation && s.kind == "referencedFeature")
+                .unwrap();
+            assert_eq!(
+                site.via_imports,
+                [(import, sysmlv2_parser::json::AccessMode::Protected)]
+            );
+        }
+    }
+}
+
+#[test]
+fn suppressed_inheritance_cannot_certify_an_alias_lexical_fallback() {
+    let library = "package Q { feature x; }
+        class A { alias ax for Q::x; alias bx for Q::x; }
+        package P { private import A::*;
+            class B specializes A { class AliasOwner { alias selected for ax; } }
+        }
+        class Child specializes P::B::AliasOwner;";
+    for mut r in models(library, "feature selected references Child::selected;") {
+        endpoint(
+            &mut r,
+            "selected",
+            "ReferenceSubsetting",
+            "referencedFeature",
+            Some("Q::x"),
+        );
+        let import = edge(&mut r, "P", "NamespaceImport");
+        let relation = edge(&mut r, "selected", "ReferenceSubsetting");
+        let site = r
+            .reference_sites()
+            .iter()
+            .find(|s| s.owner == relation && s.kind == "referencedFeature")
+            .unwrap();
+        assert_eq!(
+            site.via_imports,
+            [(import, sysmlv2_parser::json::AccessMode::Any)]
+        );
+    }
+}
+
+#[test]
+fn positional_header_contexts_try_written_bases_in_order() {
+    let library = "class Transfer { end feature source; end feature target; }
+        feature transfers : Transfer { end feature source redefines Transfer::source;
+            end feature target redefines Transfer::target; }
+        ";
+    let user = "feature incoming : Transfer subsets transfers {
+        end feature source redefines source;
+        end feature target redefines target;
+    }";
+    for mut r in models(library, user) {
+        for name in ["source", "target"] {
+            endpoint(
+                &mut r,
+                &format!("incoming::{name}"),
+                "Redefinition",
+                "redefinedFeature",
+                Some(&format!("Transfer::{name}")),
+            );
+        }
+    }
+}
+
+#[test]
+fn redefinition_before_typing_is_the_first_header_context() {
+    let library = "class Anything { feature self; }
+        class Port specializes Anything { feature self redefines Anything::self; }
+        class Link { feature participant : Anything; }";
+    let user = "class Interface specializes Link {
+        feature participant redefines participant : Port {
+            feature thisParticipant redefines self;
+        }
+    }";
+    for mut r in models(library, user) {
+        endpoint(
+            &mut r,
+            "Interface::participant::thisParticipant",
+            "Redefinition",
+            "redefinedFeature",
+            Some("Anything::self"),
+        );
+    }
+}
+
+#[test]
+fn header_without_a_general_does_not_depend_on_unrelated_heritage() {
+    for mut r in models(
+        "class A { feature x; }",
+        "class C { feature y redefines $::A::x; }",
+    ) {
+        endpoint(&mut r, "C::y", "Redefinition", "redefinedFeature", None);
+    }
+}
+
+#[test]
+fn header_full_resolution_in_an_earlier_general_precedes_later_typing() {
+    let library = "package Quantities { feature width; }
+        package P { private import Quantities::*;
+            class First;
+            class Second { feature width; }
+        }";
+    let user = "class Child specializes P::First, P::Second {
+        feature dimension redefines width;
+    }";
+    for mut r in models(library, user) {
+        endpoint(
+            &mut r,
+            "Child::dimension",
+            "Redefinition",
+            "redefinedFeature",
+            Some("Quantities::width"),
+        );
+        let relation = edge(&mut r, "Child::dimension", "Redefinition");
+        let site = r
+            .reference_sites()
+            .iter()
+            .find(|site| site.owner == relation && site.kind == "redefinedFeature")
+            .unwrap();
+        assert_eq!(site.via_imports.len(), 1);
+    }
+}
+
+#[test]
+fn anonymous_chain_redefinitions_do_not_capture_a_leaf_name() {
+    let library = "package Measures { feature mass; }
+        class Vehicle { feature chassis { feature mass = 1; } }
+        class Anonymous specializes Vehicle { feature redefines chassis.mass = 2; }
+        class Named specializes Vehicle { feature mass redefines chassis.mass = 2; }";
+    let user = "package P {
+        private import Measures::*;
+        class A specializes Anonymous { feature redefines mass = 3; }
+        class N specializes Named { feature redefines mass = 3; }
+    }";
+    for mut r in models(library, user) {
+        assert!(r.resolve_qualified("Anonymous::mass").is_none());
+        endpoint(
+            &mut r,
+            "P::A::mass",
+            "Redefinition",
+            "redefinedFeature",
+            Some("Measures::mass"),
+        );
+        endpoint(
+            &mut r,
+            "P::N::mass",
+            "Redefinition",
+            "redefinedFeature",
+            Some("Named::mass"),
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/inherited_lookup_provenance.rs b/crates/sysmlv2-parser/tests/inherited_lookup_provenance.rs
new file mode 100644
index 0000000..bf532a7
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/inherited_lookup_provenance.rs
@@ -0,0 +1,47 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{json::ResolvedModel, model::Model};
+
+#[test]
+fn suppressed_public_aliases_are_not_reported_as_visibility_blocked() {
+    let mut m = Model::new();
+    m.add_source(
+        "aliases.kerml",
+        "class Base { private feature x; alias ax for x; alias bx for x; }
+        class Mid specializes Base; class Child specializes Mid; feature useX references Child::ax;",
+    );
+    assert!(!m.has_errors());
+    let mut r = ResolvedModel::build(&m);
+    assert!(r.resolve_qualified("Child::ax").is_none());
+    assert_eq!(r.unresolved_count(), 1);
+    assert!(
+        r.blocked_references().is_empty(),
+        "semantic removal is not a visibility failure"
+    );
+}
+
+#[test]
+fn header_qualifiers_keep_the_selected_base_context() {
+    for (source, qualifier) in [
+        (
+            "class A { feature x; } class Child specializes A { feature y redefines A::x; }",
+            "A",
+        ),
+        (
+            "class A { class Nested { feature x; } } class Child specializes A { feature y redefines Nested::x; }",
+            "A::Nested",
+        ),
+    ] {
+        let mut m = Model::new();
+        m.add_source("qualified.kerml", source);
+        assert!(!m.has_errors());
+        let mut r = ResolvedModel::build(&m);
+        assert_eq!(r.unresolved_count(), 0);
+        let target = r.resolve_qualified(qualifier).unwrap();
+        assert!(
+            r.reference_sites()
+                .iter()
+                .any(|site| site.kind == "qualifier" && site.target == target),
+            "missing qualifier {qualifier}"
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/kerml.rs b/crates/sysmlv2-parser/tests/kerml.rs
index e739183..05b6e8e 100644
--- a/crates/sysmlv2-parser/tests/kerml.rs
+++ b/crates/sysmlv2-parser/tests/kerml.rs
@@ -350,3 +350,41 @@ fn metadata_body_implicit_redefinition() {
     };
     assert!(matches!(targets.as_slice(), [TargetRef::Chain(links)] if links.len() == 2));
 }
+
+#[test]
+fn a_missing_feature_value_is_reported_at_its_terminator() {
+    // A `;` where a feature value's expression belongs: one error, at the
+    // `;`, which still ends the declaration — the feature stays in the
+    // tree without a value, and the member after it parses clean.
+    for value in ["=", ":=", "default", "default =", "default :="] {
+        let src = format!("package K {{ feature x {value} ; classifier Y; }}");
+        let semi = src.find(" ;").unwrap() + 1;
+        let Parse { unit, diagnostics } = parse_kerml_source(&src);
+        let errors: Vec<_> = diagnostics
+            .iter()
+            .map(|d| {
+                (
+                    d.span.start as usize,
+                    d.span.end as usize,
+                    d.message.as_str(),
+                )
+            })
+            .collect();
+        assert_eq!(
+            errors,
+            [(semi, semi + 1, "expected an expression, found `;`")],
+            "{src:?}"
+        );
+        let MemberKind::Package(p) = &unit.members[0].kind else {
+            panic!("{src:?}")
+        };
+        let [x, y] = p.body.as_deref().unwrap() else {
+            panic!("{src:?}")
+        };
+        let MemberKind::Usage(x) = &x.kind else {
+            panic!("{src:?}")
+        };
+        assert!(x.value.is_none(), "{src:?}: {x:#?}");
+        assert!(matches!(y.kind, MemberKind::Definition(_)), "{src:?}");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/libcache.rs b/crates/sysmlv2-parser/tests/libcache.rs
index de58b0d..0951d84 100644
--- a/crates/sysmlv2-parser/tests/libcache.rs
+++ b/crates/sysmlv2-parser/tests/libcache.rs
@@ -180,14 +180,15 @@ fn stale_fingerprint_disables_replay_soundly() {
     let cold = serde_json::to_string(&model_to_compact_json(&model)).unwrap();
     let cache = model.take_recorded_library_cache().unwrap();
 
-    // Flip the fingerprint on disk (offset: 8 magic + 1 + version len) and
-    // re-seal the trailing whole-file checksum, simulating a cache recorded
-    // against different lowering rather than plain corruption.
+    // Flip the fingerprint on disk (offset: 8 magic + 1 + build len + 1
+    // graph format + 1 fixed point) and re-seal the trailing whole-file
+    // checksum, simulating a cache recorded against different lowering
+    // rather than plain corruption.
     let dir = std::env::temp_dir().join(format!("sysmlv2-libcache-fp-{}", std::process::id()));
     let path = dir.join("stdlib.libcache");
     cache.save(&path).unwrap();
     let mut bytes = std::fs::read(&path).unwrap();
-    let fp_off = 9 + bytes[8] as usize;
+    let fp_off = 11 + bytes[8] as usize;
     bytes[fp_off] ^= 0xff;
     let body_len = bytes.len() - 8;
     let mut h: u64 = 0xcbf29ce484222325;
@@ -295,9 +296,11 @@ fn header_carries_a_source_fingerprint_beyond_the_crate_version() {
 fn cache_from_another_toolkit_build_is_rejected() {
     fn sealed_empty_cache(build: &[u8]) -> Vec<u8> {
         let mut buf = Vec::new();
-        buf.extend_from_slice(b"SYSML6LC");
+        buf.extend_from_slice(b"SYSML8LC");
         buf.push(build.len() as u8);
         buf.extend_from_slice(build);
+        buf.push(2); // legacy authored graph format
+        buf.push(1); // the library's own fixed point
         buf.extend_from_slice(&0u64.to_le_bytes()); // pending fingerprint
         for _ in 0..4 {
             buf.extend_from_slice(&0u64.to_le_bytes()); // empty tables
@@ -381,3 +384,255 @@ fn anonymous_redefinition_fanout_survives_library_replay() {
     assert_eq!(model_to_compact_json(&model), cold);
     assert!(sysmlv2_parser::check::validate_model(&model).is_empty());
 }
+
+/// xorshift64* — tiny, deterministic, no dependencies.
+struct Rng(u64);
+
+impl Rng {
+    fn next(&mut self) -> u64 {
+        let mut x = self.0;
+        x ^= x >> 12;
+        x ^= x << 25;
+        x ^= x >> 27;
+        self.0 = x;
+        x.wrapping_mul(0x2545F4914F6CDD1D)
+    }
+
+    fn pick<'a>(&mut self, choices: &[&'a str]) -> &'a str {
+        choices[(self.next() % choices.len() as u64) as usize]
+    }
+
+    fn below(&mut self, n: usize) -> usize {
+        (self.next() % n as u64) as usize
+    }
+}
+
+/// The keywords a generated source spells its definitions and features
+/// with, and the extension of its units.
+struct Dialect {
+    definition: &'static str,
+    feature: &'static str,
+    extension: &'static str,
+}
+
+const SYSML: Dialect = Dialect {
+    definition: "part def",
+    feature: "part",
+    extension: "sysml",
+};
+
+const KERML: Dialect = Dialect {
+    definition: "class",
+    feature: "feature",
+    extension: "kerml",
+};
+
+/// Members of a generated definition: typings, subsettings and
+/// redefinitions of names its bases may or may not supply, nested
+/// definitions, aliases and nested bodies.
+fn generated_members(rng: &mut Rng, d: &Dialect, depth: usize) -> String {
+    let (def, feature) = (d.definition, d.feature);
+    let mut out = String::new();
+    for k in 0..rng.below(5) {
+        out += &match rng.below(9) {
+            0 | 1 => {
+                let ty = rng.pick(&[
+                    "Inner", "Inner2", "X", "K", "T", "Y", "AX", "Q::T", "Other::X", "A",
+                ]);
+                format!("{feature} f{k} : {ty}; ")
+            }
+            2 => format!("{feature} :>> {}; ", rng.pick(&["y", "z", "w"])),
+            3 => format!("{feature} g{k} :> {}; ", rng.pick(&["y", "z", "w"])),
+            4 => match rng.pick(&["Inner", "Inner2", "T", "y"]) {
+                "y" => format!("{feature} y; "),
+                name => format!("{def} {name}; "),
+            },
+            5 if depth < 2 => {
+                let ty = rng.pick(&["Inner", "X", "K", "T"]);
+                format!(
+                    "{feature} h{k} : {ty} {{ {}}} ",
+                    generated_members(rng, d, depth + 1)
+                )
+            }
+            6 => format!("{feature} {}; ", rng.pick(&["y", "z"])),
+            7 => format!("alias Al{k} for {}; ", rng.pick(&["X", "K", "Inner"])),
+            _ => {
+                let redefined = rng.pick(&["y", "z", "w", "v"]);
+                let ty = rng.pick(&["Inner", "Inner2", "T"]);
+                format!("{feature} :>> {redefined} : {ty}; ")
+            }
+        };
+    }
+    out
+}
+
+/// A library whose references miss root names a model may supply: `X`
+/// and `Y` live in a package the library never imports, `Q` usually
+/// nowhere.
+fn generated_library(rng: &mut Rng, d: &Dialect) -> String {
+    let (def, feature) = (d.definition, d.feature);
+    let mut other = String::new();
+    for name in ["X", "Y"] {
+        let base = if rng.below(100) < 40 {
+            format!(" :> {}", rng.pick(&["L::K", "L::A", "Y"]))
+        } else {
+            String::new()
+        };
+        if name == "Y" && base.ends_with('Y') {
+            continue;
+        }
+        other += &format!(
+            "{def} {name}{base} {{ {feature} y; {feature} z; {def} Inner; \
+             {def} Inner2 {{ {feature} w; }} {}}} ",
+            generated_members(rng, d, 1)
+        );
+    }
+    let mut l = String::new();
+    for _ in 0..rng.below(3) {
+        l += rng.pick(&[
+            "import Q::*; ",
+            "private import Q::*; ",
+            "import X::*; ",
+            "private import Other::X; ",
+            "import Q::**; ",
+            "import Q::T; ",
+            "alias AX for X; ",
+        ]);
+    }
+    let names = ["K", "A", "B", "C", "D"];
+    for (i, name) in names.iter().take(2 + rng.below(4)).enumerate() {
+        let mut bases: Vec<&str> = Vec::new();
+        for _ in 0..rng.below(3) {
+            let base = rng.pick(&["X", "Y", "K", "A", "B", "AX", "Q::T", "Other::Y", "T"]);
+            if !names[i..].contains(&base) && !bases.contains(&base) {
+                bases.push(base);
+            }
+        }
+        let spec = if bases.is_empty() {
+            String::new()
+        } else {
+            format!(" :> {}", bases.join(", "))
+        };
+        l += &format!("{def} {name}{spec} {{ {}}} ", generated_members(rng, d, 0));
+    }
+    let q = if rng.below(100) < 20 {
+        format!("package Q {{ {def} T {{ {feature} y; }} }} ")
+    } else {
+        String::new()
+    };
+    format!("package Other {{ {other}}} package L {{ {l}}} {q}")
+}
+
+/// A model that supplies some of the names the library missed, through
+/// root declarations and root imports, and refers into the library.
+fn generated_model(rng: &mut Rng, d: &Dialect) -> String {
+    let (def, feature) = (d.definition, d.feature);
+    let mut out = String::new();
+    for _ in 0..=rng.below(3) {
+        out += &match rng.below(8) {
+            0 => "private import Other::*; ".to_string(),
+            1 => "public import Other::X; ".to_string(),
+            2 => format!("{def} X {{ {feature} y; {feature} z; {def} Inner; {def} Inner2; }} "),
+            3 => format!("package Q {{ {def} T {{ {feature} y; {feature} w; }} {def} Inner; }} "),
+            4 => format!("{def} Inner; "),
+            5 => format!("{def} T {{ {feature} z; }} "),
+            6 => format!("package X {{ {def} Inner; {def} Inner2 {{ {feature} y; }} }} "),
+            _ => format!("{feature} y; "),
+        };
+    }
+    out + &format!(
+        "package P {{ {feature} a : L::A; {feature} k : L::K; {feature} m :> L::K::y; }}"
+    )
+}
+
+/// Differential gate for library resolution recordings and prepared
+/// libraries: over generated libraries and models that supply names the
+/// library missed, a build replaying a recording of the library alone,
+/// one on the library prepared alone, and one on the library prepared
+/// while recording (whose joint builds replay that recording) must equal
+/// a cold build.
+/// Whatever an outcome reads — lookup caches another reference filled,
+/// other references' recorded outcomes, the recorded lookup graph — must
+/// carry the root misses behind it, or the replay keeps a stale outcome;
+/// and whether resolution runs its later passes must not depend on
+/// whether the library resolves alone. Each seed generates one pair per
+/// dialect. Deeper runs:
+/// `REPLAY_FUZZ_ITERS=100000 cargo test --release --test libcache`.
+#[test]
+fn replayed_generated_libraries_match_cold_builds() {
+    let iters: u64 = std::env::var("REPLAY_FUZZ_ITERS")
+        .ok()
+        .and_then(|n| n.parse().ok())
+        .unwrap_or(500);
+    let mut checked = 0;
+    for seed in 1..=iters {
+        for (d, stream) in [(&SYSML, 0), (&KERML, 0x5EED)] {
+            let mut rng = Rng((seed ^ stream).wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1);
+            let library = generated_library(&mut rng, d);
+            let user = generated_model(&mut rng, d);
+            let (library_unit, user_unit) = (
+                format!("lib.{}", d.extension),
+                format!("user.{}", d.extension),
+            );
+            let mut cold = Model::new();
+            let parsed = cold
+                .add_library_source(&library_unit, &library)
+                .diagnostics
+                .is_empty()
+                && cold.add_source(&user_unit, &user).diagnostics.is_empty();
+            if !parsed {
+                continue;
+            }
+            let mut recorder = Model::new();
+            recorder.add_library_source(&library_unit, &library);
+            recorder.record_library_cache();
+            let _ = library_to_compact_json(&recorder);
+            let recording = recorder.take_recorded_library_cache().unwrap();
+            let mut replay = Model::new();
+            replay.add_library_source(&library_unit, &library);
+            replay.set_library_cache(LibraryCache::from_bytes(&recording.to_bytes()).unwrap());
+            replay.add_source(&user_unit, &user);
+            let mut alone = Model::new();
+            alone.add_library_source(&library_unit, &library);
+            let mut prepared = Model::new();
+            alone
+                .prepare_library()
+                .unwrap()
+                .install(&mut prepared)
+                .unwrap();
+            prepared.add_source(&user_unit, &user);
+            let mut recording_alone = Model::new();
+            recording_alone.add_library_source(&library_unit, &library);
+            recording_alone.record_library_cache();
+            let mut replaying = Model::new();
+            recording_alone
+                .prepare_library()
+                .unwrap()
+                .install(&mut replaying)
+                .unwrap();
+            replaying.add_source(&user_unit, &user);
+            for (build, model) in [
+                ("replayed", &replay),
+                ("prepared", &prepared),
+                ("prepared-and-replaying", &replaying),
+            ] {
+                for (graph, of) in [
+                    (
+                        "user",
+                        model_to_compact_json as fn(&Model) -> serde_json::Value,
+                    ),
+                    ("library", library_to_compact_json),
+                ] {
+                    assert!(
+                        of(model) == of(&cold),
+                        "{} seed {seed}: the {build} {graph} graph diverged from a cold build\n\
+                         library: {library}\nmodel: {user}",
+                        d.extension
+                    );
+                }
+            }
+            checked += 1;
+        }
+    }
+    assert!(checked > iters, "most generated sources parse");
+}
diff --git a/crates/sysmlv2-parser/tests/literal_results.rs b/crates/sysmlv2-parser/tests/literal_results.rs
new file mode 100644
index 0000000..1c93f52
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/literal_results.rs
@@ -0,0 +1,587 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn assert_canonical_role(model: &Model, r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let role = r
+        .resolve_qualified(name)
+        .expect("required role is declared");
+    let names = sysmlv2_parser::json::library_element_name_map(model);
+    assert_eq!(
+        names.get(&r.element_id(role).to_string()),
+        Some(&name.split("::").map(str::to_owned).collect::<Vec<_>>())
+    );
+    role
+}
+
+const LIBRARY: &str = r#"standard library package Values {datatype Integer; datatype Boolean; datatype Real; datatype String; datatype Anything;}
+standard library package Performances {
+function IntegerEvaluation {return result: Values::Integer[1];}
+function BooleanEvaluation {return result: Values::Boolean[1];}
+function RationalEvaluation {return result: Values::Real[1];}
+function StringEvaluation {return result: Values::String[1];}
+function NullEvaluation {return result: Values::Anything[0..0];}
+expr literalIntegerEvaluations: IntegerEvaluation;
+expr literalBooleanEvaluations: BooleanEvaluation;
+expr literalRationalEvaluations: RationalEvaluation;
+expr literalStringEvaluations: StringEvaluation;
+expr nullEvaluations: NullEvaluation;
+}"#;
+const USER: &str =
+    r#"feature b=true; feature i=1; feature r=1.25; feature s="x"; feature inf=*; feature n=null;"#;
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let feature = r.resolve_qualified(name).unwrap();
+    let relation = r
+        .owned_relationships(feature)
+        .into_iter()
+        .find(|&x| r.element_type(x) == "FeatureValue")
+        .unwrap();
+    match r.derived(relation, "value") {
+        Derived::Value(v) => v.element().unwrap(),
+        x => panic!("{x:?}"),
+    }
+}
+fn result(r: &mut ResolvedModel, e: ElementRef) -> Option<ElementRef> {
+    match r.derived(e, "result") {
+        Derived::Value(v) => v.element(),
+        x => panic!("{x:?}"),
+    }
+}
+#[test]
+fn literal_results_reuse_library_return_identities_without_scopes_or_owned_results() {
+    for materialize_first in [false, true] {
+        for (mode, (model, mut r)) in models(LIBRARY, USER).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            assert_canonical_role(&model, &mut r, "Performances::literalIntegerEvaluations");
+            let explicit: Vec<_> = r
+                .elements()
+                .map(|e| {
+                    (
+                        r.element_id(e),
+                        r.element_type(e).to_string(),
+                        r.element_properties(e),
+                        r.owned_relationships(e),
+                    )
+                })
+                .collect();
+            for (name, function, kind) in [
+                ("b", "BooleanEvaluation", "Boolean"),
+                ("i", "IntegerEvaluation", "Integer"),
+                ("r", "RationalEvaluation", "Real"),
+                ("s", "StringEvaluation", "String"),
+                ("inf", "IntegerEvaluation", "Integer"),
+                ("n", "NullEvaluation", "Anything"),
+            ] {
+                let e = value(&mut r, name);
+                assert!(r.element_scope(e).is_none());
+                assert!(r.owned_relationships(e).is_empty());
+                if materialize_first {
+                    r.implied_relationships(e);
+                }
+                r.set_closure_policy(ClosurePolicy::Passthrough);
+                assert_eq!(result(&mut r, e), None);
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: false,
+                });
+                assert_eq!(result(&mut r, e), None);
+                assert!(r.inherited_memberships(e, false).is_empty());
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let expected = r
+                    .resolve_qualified(&format!("Performances::{function}::result"))
+                    .unwrap();
+                let expected_type = r.resolve_qualified(&format!("Values::{kind}")).unwrap();
+                for _ in 0..2 {
+                    assert_eq!(result(&mut r, e), Some(expected), "mode {mode} {name}");
+                    let returns: Vec<_> = r
+                        .inherited_memberships(e, true)
+                        .into_iter()
+                        .filter(|&m| r.element_type(m) == "ReturnParameterMembership")
+                        .collect();
+                    assert_eq!(returns.len(), 1);
+                    assert_eq!(r.membership_member(returns[0]), Some(expected));
+                    assert!(r.inherited_features(e, true).contains(&expected));
+                    assert!(!r.inheritance_incomplete(e, true));
+                    assert!(!r.inheritance_walk_truncated(e, true));
+                    assert_eq!(
+                        r.effective_cardinality(expected),
+                        Some(if name == "n" {
+                            (0, Some(0))
+                        } else {
+                            (1, Some(1))
+                        })
+                    );
+                    let typing = r
+                        .owned_relationships(expected)
+                        .into_iter()
+                        .find(|&rel| r.element_type(rel) == "FeatureTyping")
+                        .unwrap();
+                    assert_eq!(
+                        r.element_properties(typing)["type"]["@id"],
+                        r.element_id(expected_type).to_string()
+                    );
+                }
+                assert!(r.element_scope(e).is_none());
+                assert!(r.owned_relationships(e).is_empty());
+            }
+            let after: Vec<_> = r
+                .elements()
+                .map(|e| {
+                    (
+                        r.element_id(e),
+                        r.element_type(e).to_string(),
+                        r.element_properties(e),
+                        r.owned_relationships(e),
+                    )
+                })
+                .collect();
+            assert_eq!(explicit, after);
+            assert_eq!(loaded, model.loaded_library_unit_count());
+        }
+    }
+}
+#[test]
+fn absent_or_incomplete_literal_library_never_fabricates_a_result() {
+    for library in [
+        "",
+        "standard library package Performances {class literalIntegerEvaluations;}",
+        "standard library package Performances {expr literalIntegerEvaluations;}",
+        "standard library package Performances {function F; expr literalIntegerEvaluations:F;}",
+        "standard library package Performances {function F {return result:Missing;} expr literalIntegerEvaluations:F;}",
+        "standard library package Values {datatype T;} standard library package Performances {function A {return a:Values::T;} function B {return b:Values::T;} expr literalIntegerEvaluations:A,B;}",
+    ] {
+        for (model, mut r) in models(library, "feature i=1;") {
+            let role = (!library.is_empty()).then(|| {
+                assert_canonical_role(&model, &mut r, "Performances::literalIntegerEvaluations")
+            });
+            let e = value(&mut r, "i");
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            assert_eq!(result(&mut r, e), None, "{library}");
+            assert!(r.inheritance_incomplete(e, true), "{library}");
+            if let Some(role) = role {
+                let edges = r.implied_relationships(e);
+                if r.element_type(role) == "Expression" {
+                    assert_eq!(
+                        edges.len(),
+                        1,
+                        "the partial hierarchy must reach the canonical base"
+                    );
+                    assert_eq!(
+                        r.element_properties(edges[0])["subsettedFeature"]["@id"],
+                        r.element_id(role).to_string()
+                    );
+                } else {
+                    assert!(edges.is_empty());
+                }
+            }
+            assert!(r.owned_relationships(e).is_empty());
+            assert!(r.element_scope(e).is_none());
+        }
+    }
+}
+#[test]
+fn external_literal_base_retains_identity_but_has_no_in_model_return() {
+    use std::collections::HashMap;
+    for (_, mut r) in models("", "feature i=1;") {
+        let id = "b0200000-0000-4000-8000-000000000001";
+        r.set_library_names(&HashMap::from([(
+            id.to_owned(),
+            vec![
+                "Performances".to_owned(),
+                "literalIntegerEvaluations".to_owned(),
+            ],
+        )]));
+        let e = value(&mut r, "i");
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(result(&mut r, e), None);
+        assert!(r.inheritance_incomplete(e, true));
+        let relationships = r.implied_relationships(e);
+        assert_eq!(relationships.len(), 1);
+        assert_eq!(
+            r.element_properties(relationships[0])["subsettedFeature"]["@id"],
+            id
+        );
+    }
+}
+#[test]
+fn literal_plan_obeys_id_remaps_and_external_override_before_materialization() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    for override_names in [false, true] {
+        for (_, mut r) in models(LIBRARY, "feature i=1;") {
+            let e = value(&mut r, "i");
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            assert!(result(&mut r, e).is_some());
+            let target = r
+                .resolve_qualified("Performances::literalIntegerEvaluations")
+                .unwrap();
+            let new = Uuid::parse_str("b0200000-0000-4000-8000-000000000002").unwrap();
+            if override_names {
+                r.set_library_names(&HashMap::from([(
+                    new.to_string(),
+                    vec![
+                        "Performances".to_owned(),
+                        "literalIntegerEvaluations".to_owned(),
+                    ],
+                )]));
+                assert_eq!(result(&mut r, e), None);
+                assert!(r.inheritance_incomplete(e, true));
+            } else {
+                let ret = r
+                    .resolve_qualified("Performances::IntegerEvaluation::result")
+                    .unwrap();
+                let ret_id = Uuid::parse_str("b0200000-0000-4000-8000-000000000003").unwrap();
+                r.override_ids(&HashMap::from([
+                    (r.element_id(target), new),
+                    (r.element_id(ret), ret_id),
+                ]));
+                let actual = result(&mut r, e).unwrap();
+                assert_eq!(r.element_id(actual), ret_id);
+                assert!(!r.inheritance_incomplete(e, true));
+            }
+            let rels = r.implied_relationships(e);
+            assert_eq!(rels.len(), 1);
+            assert_eq!(
+                r.element_properties(rels[0])["subsettedFeature"]["@id"],
+                new.to_string()
+            );
+            let expected = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{}/implied/Subsetting/{new}", r.element_id(e)).as_bytes(),
+            );
+            assert_eq!(r.element_id(rels[0]), expected);
+        }
+    }
+}
+#[test]
+fn user_spelling_does_not_override_library_literal_identity() {
+    let user = "package U {package Performances {feature literalIntegerEvaluations;} feature i=1;}";
+    for (_, mut r) in models(LIBRARY, user) {
+        let e = value(&mut r, "U::i");
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let expected = r
+            .resolve_qualified("Performances::IntegerEvaluation::result")
+            .unwrap();
+        assert_eq!(result(&mut r, e), Some(expected));
+    }
+}
+
+#[test]
+fn supplied_names_cannot_promote_a_loaded_user_expression_into_literal_library_role() {
+    use std::collections::HashMap;
+    for (_, mut r) in models(
+        "standard library package Values {datatype T;}",
+        "function F {return result:Values::T;} expr replacement:F; feature i=1;",
+    ) {
+        let replacement = r.resolve_qualified("replacement").unwrap();
+        r.set_library_names(&HashMap::from([(
+            r.element_id(replacement).to_string(),
+            vec![
+                "Performances".to_owned(),
+                "literalIntegerEvaluations".to_owned(),
+            ],
+        )]));
+        let e = value(&mut r, "i");
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(result(&mut r, e), None);
+        assert!(r.inheritance_incomplete(e, true));
+        assert!(r.implied_relationships(e).is_empty());
+    }
+}
+
+#[test]
+fn loaded_standard_library_supplies_literal_integer_and_null_results() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.exists() {
+        eprintln!("skipping: library not present");
+        return;
+    }
+    let mut m = Model::new();
+    m.load_library_dir(&library).expect("library loads");
+    assert!(
+        m.add_source("literal-use.kerml", "feature i=1; feature n=null;")
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    for (name, function, scalar, range) in [
+        (
+            "i",
+            "Performances::LiteralIntegerEvaluation",
+            "ScalarValues::Integer",
+            (1, Some(1)),
+        ),
+        (
+            "n",
+            "Performances::NullEvaluation",
+            "Base::Anything",
+            (0, Some(0)),
+        ),
+    ] {
+        let e = value(&mut r, name);
+        let function = r.resolve_qualified(function).unwrap();
+        let scalar = r.resolve_qualified(scalar).unwrap();
+        let returns: Vec<_> = r
+            .owned_relationships(function)
+            .into_iter()
+            .filter(|&relationship| r.element_type(relationship) == "ReturnParameterMembership")
+            .collect();
+        assert_eq!(returns.len(), 1);
+        let expected = r.membership_member(returns[0]).unwrap();
+        for _ in 0..2 {
+            assert_eq!(result(&mut r, e), Some(expected), "{name}");
+            assert!(!r.inheritance_walk_truncated(e, true));
+            assert!(!r.inheritance_incomplete(e, true));
+            let membership: Vec<_> = r
+                .inherited_memberships(e, true)
+                .into_iter()
+                .filter(|&m| r.element_type(m) == "ReturnParameterMembership")
+                .collect();
+            assert_eq!(membership, returns);
+            let typing = r
+                .owned_relationships(expected)
+                .into_iter()
+                .find(|&rel| r.element_type(rel) == "FeatureTyping")
+                .unwrap();
+            assert_eq!(
+                r.element_properties(typing)["type"]["@id"],
+                r.element_id(scalar).to_string()
+            );
+            assert_eq!(r.effective_cardinality(expected), Some(range));
+            assert!(r.element_scope(e).is_none());
+            assert!(r.owned_relationships(e).is_empty());
+        }
+    }
+}
+
+#[test]
+fn existing_implied_relationships_keep_library_and_user_identity_schemes() {
+    use uuid::Uuid;
+    let library = LIBRARY.replace(
+        "standard library package Performances {",
+        "standard library package Performances {function Evaluation; function Marker;",
+    );
+    for (_, mut r) in models_named(
+        &library,
+        "enum def Color { red; } attribute i=1;",
+        "calls.sysml",
+    ) {
+        let marker = r.resolve_qualified("Performances::Marker").unwrap();
+        let evaluation = r.resolve_qualified("Performances::Evaluation").unwrap();
+        let variant = r.resolve_qualified("Color::red").unwrap();
+        let expected_library = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!(
+                "{}/implied/Subclassification/{}",
+                r.element_id(marker),
+                r.element_id(evaluation)
+            )
+            .as_bytes(),
+        );
+        let expected_user = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!("{}/implied0", r.element_id(variant)).as_bytes(),
+        );
+        let mut before = Vec::new();
+        for (owner, expected) in [(marker, expected_library), (variant, expected_user)] {
+            let ids: Vec<_> = r
+                .implied_relationships(owner)
+                .into_iter()
+                .map(|rel| r.element_id(rel))
+                .collect();
+            assert_eq!(ids, vec![expected]);
+            before.push((owner, ids));
+        }
+        let e = value(&mut r, "i");
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert!(result(&mut r, e).is_some());
+        for (owner, expected) in before {
+            let ids: Vec<_> = r
+                .implied_relationships(owner)
+                .into_iter()
+                .map(|rel| r.element_id(rel))
+                .collect();
+            assert_eq!(ids, expected);
+        }
+    }
+}
+
+#[test]
+fn loaded_literal_identity_collisions_never_choose_a_library_namesake() {
+    use std::collections::HashMap;
+    const LIB: &str = r#"
+standard library package Values {datatype Integer; datatype String;}
+standard library package Performances {
+ function IntegerEvaluation {return integerResult:Values::Integer;}
+ function OtherEvaluation {return otherResult:Values::String;}
+ expr literalIntegerEvaluations:IntegerEvaluation;
+ expr impostor:OtherEvaluation;
+}"#;
+    for collision in ["role", "return", "owner", "type", "membership", "typing"] {
+        for materialize_first in [false, true] {
+            for (mode, (_, mut r)) in models(LIB, "feature i=1;").into_iter().enumerate() {
+                let literal = value(&mut r, "i");
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let good = r
+                    .resolve_qualified("Performances::IntegerEvaluation::integerResult")
+                    .unwrap();
+                let bad = r
+                    .resolve_qualified("Performances::OtherEvaluation::otherResult")
+                    .unwrap();
+                assert_eq!(result(&mut r, literal), Some(good));
+                assert!(!r.inheritance_incomplete(literal, true));
+                let role = r
+                    .resolve_qualified("Performances::literalIntegerEvaluations")
+                    .unwrap();
+                let impostor = r.resolve_qualified("Performances::impostor").unwrap();
+                let owner = r
+                    .resolve_qualified("Performances::IntegerEvaluation")
+                    .unwrap();
+                let other_owner = r
+                    .resolve_qualified("Performances::OtherEvaluation")
+                    .unwrap();
+                let find = |r: &mut ResolvedModel, e, kind| {
+                    r.owned_relationships(e)
+                        .into_iter()
+                        .find(|&rel| r.element_type(rel) == kind)
+                        .unwrap()
+                };
+                let (source, target) = match collision {
+                    "role" => (role, impostor),
+                    "return" => (good, bad),
+                    "owner" => (owner, other_owner),
+                    "type" => (
+                        r.resolve_qualified("Values::Integer").unwrap(),
+                        r.resolve_qualified("Values::String").unwrap(),
+                    ),
+                    "membership" => (
+                        find(&mut r, owner, "ReturnParameterMembership"),
+                        find(&mut r, other_owner, "ReturnParameterMembership"),
+                    ),
+                    "typing" => (
+                        find(&mut r, role, "FeatureTyping"),
+                        find(&mut r, impostor, "FeatureTyping"),
+                    ),
+                    _ => unreachable!(),
+                };
+                if materialize_first {
+                    r.implied_relationships(literal);
+                }
+                r.override_ids(&HashMap::from([(
+                    r.element_id(source),
+                    r.element_id(target),
+                )]));
+                for _ in 0..2 {
+                    assert_eq!(
+                        result(&mut r, literal),
+                        None,
+                        "{collision} mode={mode} materialized={materialize_first}"
+                    );
+                    assert!(
+                        r.inheritance_incomplete(literal, true),
+                        "{collision} mode={mode} materialized={materialize_first}"
+                    );
+                }
+                assert!(r.element_scope(literal).is_none());
+                assert!(r.owned_relationships(literal).is_empty());
+            }
+        }
+    }
+}
+
+#[test]
+fn materializing_an_implied_edge_invalidates_unique_literal_endpoint_evidence() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    for (_, mut r) in models(LIBRARY, "feature i=1;") {
+        let literal = value(&mut r, "i");
+        let role = r
+            .resolve_qualified("Performances::literalIntegerEvaluations")
+            .unwrap();
+        let ret = r
+            .resolve_qualified("Performances::IntegerEvaluation::result")
+            .unwrap();
+        let generated_id = Uuid::new_v5(
+            &Uuid::NAMESPACE_OID,
+            format!(
+                "{}/implied/Subsetting/{}",
+                r.element_id(literal),
+                r.element_id(role)
+            )
+            .as_bytes(),
+        );
+        r.override_ids(&HashMap::from([(r.element_id(ret), generated_id)]));
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(result(&mut r, literal), Some(ret));
+        assert!(!r.inheritance_incomplete(literal, true));
+        let edges = r.implied_relationships(literal);
+        assert!(
+            edges
+                .into_iter()
+                .any(|edge| r.element_id(edge) == generated_id)
+        );
+        assert_eq!(result(&mut r, literal), None);
+        assert!(r.inheritance_incomplete(literal, true));
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/metadata_about.rs b/crates/sysmlv2-parser/tests/metadata_about.rs
new file mode 100644
index 0000000..2b0ba46
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/metadata_about.rs
@@ -0,0 +1,192 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+const LIBRARY: &str = "standard library package Base {classifier Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;} standard library package Metaobjects {metaclass SemanticMetadata {feature baseType;}}";
+fn models(user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_with(LIBRARY, user)
+}
+fn models_with(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("bases.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("bases.kerml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let p = m.add_source("about.kerml", user);
+            assert!(p.diagnostics.is_empty(), "{:?}", p.diagnostics);
+            let r = ResolvedModel::build(&m);
+            (m, r)
+        })
+        .collect()
+}
+fn check_canonical(m: &Model, r: &mut ResolvedModel) {
+    let meta = r
+        .resolve_qualified("Metaobjects::SemanticMetadata")
+        .unwrap();
+    assert_eq!(
+        sysmlv2_parser::json::library_element_name_map(m).get(&r.element_id(meta).to_string()),
+        Some(&vec![
+            "Metaobjects".to_owned(),
+            "SemanticMetadata".to_owned()
+        ])
+    );
+}
+const BASE: &str = "metaclass U; class A {feature inherited;} metaclass Tagged :> Metaobjects::SemanticMetadata {:>> baseType=A meta U;}";
+fn target(r: &mut ResolvedModel, e: ElementRef, key: &str) -> Option<String> {
+    r.element_properties(e)
+        .get(key)?
+        .get("@id")?
+        .as_str()
+        .map(str::to_owned)
+}
+#[test]
+fn explicit_about_matches_prefix_and_resolves_earlier_inherited_reference() {
+    for about in [false, true] {
+        let class = "class C {feature child subsets inherited;}";
+        let suffix = if about {
+            format!("{class} @Tagged about C;")
+        } else {
+            format!("#Tagged {class}")
+        };
+        for (m, mut r) in models(&format!("{BASE} {suffix}")) {
+            check_canonical(&m, &mut r);
+            let a = r.resolve_qualified("A").unwrap();
+            let c = r.resolve_qualified("C").unwrap();
+            let inherited = r.resolve_qualified("A::inherited").unwrap();
+            assert_eq!(r.metadata_of(c).len(), 1);
+            assert!(r.conforms_with_implied(c, a));
+            let child = r.resolve_qualified("C::child").unwrap();
+            let sub = r
+                .owned_relationships(child)
+                .into_iter()
+                .find(|&e| r.element_type(e) == "Subsetting")
+                .unwrap();
+            assert_eq!(
+                target(&mut r, sub, "subsettedFeature"),
+                Some(r.element_id(inherited).to_string())
+            );
+        }
+    }
+}
+#[test]
+fn alias_target_and_repeated_explicit_targets_preserve_one_metadata_identity() {
+    for (m, mut r) in models(&format!(
+        "{BASE} class C; alias Alias for C; @Tagged about Alias,C;"
+    )) {
+        check_canonical(&m, &mut r);
+        let c = r.resolve_qualified("C").unwrap();
+        let a = r.resolve_qualified("A").unwrap();
+        assert_eq!(r.metadata_of(c).len(), 1);
+        assert!(r.conforms_with_implied(c, a));
+    }
+}
+
+#[test]
+fn explicit_about_drives_metadata_filters_and_evaluation() {
+    let library = format!("{LIBRARY} standard library package KerML {{metaclass Class;}}");
+    let user = "metaclass Mark; package Items {class C; class D;} package Selected {public import Items::*[@Mark];} @Mark about Items::C;";
+    for (_, mut r) in models_with(&library, user) {
+        let c = r.resolve_qualified("Items::C").unwrap();
+        assert!(r.resolve_qualified("Selected::C").is_some());
+        assert!(r.resolve_qualified("Selected::D").is_none());
+        let expected = r.metadata_of(c);
+        assert_eq!(expected.len(), 1);
+        let parsed = sysmlv2_parser::parser::parse_expression("Items::C.metadata");
+        assert!(parsed.diagnostics.is_empty());
+        let scope = r.root_scope();
+        let value = r.query(scope, &parsed.expr.unwrap()).unwrap();
+        let sysmlv2_parser::eval::Value::Sequence(items) = value else {
+            panic!("{value:?}")
+        };
+        assert_eq!(items.len(), 2);
+        assert!(matches!(&items[0],sysmlv2_parser::eval::Value::Element(e) if *e==expected[0]));
+    }
+}
+#[test]
+fn prepared_library_associations_and_user_annotations_on_library_types_are_preserved() {
+    let library =
+        format!("{LIBRARY} {BASE} class Existing; @Tagged about Existing; class NewTarget;");
+    for (model, mut r) in models_with(&library, "@Tagged about NewTarget;") {
+        let loaded = model.loaded_library_unit_count();
+        let a = r.resolve_qualified("A").unwrap();
+        for name in ["Existing", "NewTarget"] {
+            let target = r.resolve_qualified(name).unwrap();
+            assert_eq!(r.metadata_of(target).len(), 1, "{name}");
+            assert!(r.conforms_with_implied(target, a), "{name}");
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+#[test]
+fn warmed_source_id_binding_moves_about_association_and_preserves_prefix_metadata() {
+    use std::collections::HashMap;
+    const ID: &str = "88888888-8888-4888-8888-888888888888";
+    let user = format!("metaclass Mark; #Mark class Actual; class '{ID}'; @Mark about '{ID}';");
+    for (_, mut r) in models(&user) {
+        let actual = r.resolve_qualified("Actual").unwrap();
+        let lexical = r.resolve_qualified(ID).unwrap();
+        let original = r.metadata_of(actual);
+        let moved = r.metadata_of(lexical);
+        assert_eq!(original.len(), 1);
+        assert_eq!(moved.len(), 1);
+        let ann = r.elements_of_metaclass("Annotation")[0];
+        r.override_ids(&HashMap::from([(
+            r.element_id(actual),
+            ID.parse().unwrap(),
+        )]));
+        let mut hints = HashMap::from([(
+            (r.element_id(ann), "annotatedElement".into()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        assert!(r.metadata_of(lexical).is_empty());
+        assert_eq!(r.metadata_of(actual), [original, moved].concat());
+        r.bind_id_spelled_references_with(&mut hints);
+        assert_eq!(r.metadata_of(actual).len(), 2);
+    }
+}
+#[test]
+fn annotated_library_target_findings_belong_to_user_metadata_source() {
+    let library = "standard library package KerML {metaclass Element; metaclass Type :> Element; metaclass Class :> Type; metaclass Feature :> Type;} standard library package Metaobjects {metaclass Metaobject {feature annotatedElement:KerML::Element;}} metaclass Tag :> Metaobjects::Metaobject {feature :>> annotatedElement:KerML::Feature;} class C;";
+    for (model, mut r) in models_with(library, "@Tag about C;") {
+        let findings = sysmlv2_parser::check::validate_semantics_with(&mut r, &model);
+        let relevant = findings
+            .iter()
+            .filter(|(_, d)| {
+                d.message
+                    .contains("validateMetadataFeatureAnnotatedElement")
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(relevant.len(), 1, "{findings:?}");
+        assert!(!model.is_library_unit(relevant[0].0));
+        assert_eq!(model.unit(relevant[0].0).name, "about.kerml");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/metadata_results.rs b/crates/sysmlv2-parser/tests/metadata_results.rs
new file mode 100644
index 0000000..dc92f09
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/metadata_results.rs
@@ -0,0 +1,299 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source("calls.kerml", user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let feature = r.resolve_qualified(name).unwrap();
+    let relation = r
+        .owned_relationships(feature)
+        .into_iter()
+        .find(|&x| r.element_type(x) == "FeatureValue")
+        .unwrap();
+    match r.derived(relation, "value") {
+        Derived::Value(v) => v.element().unwrap(),
+        x => panic!("{x:?}"),
+    }
+}
+fn result(r: &mut ResolvedModel, e: ElementRef) -> Option<ElementRef> {
+    match r.derived(e, "result") {
+        Derived::Value(v) => v.element(),
+        x => panic!("{x:?}"),
+    }
+}
+fn assert_canonical_role(model: &Model, r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let role = r
+        .resolve_qualified(name)
+        .expect("required role is declared");
+    let names = sysmlv2_parser::json::library_element_name_map(model);
+    assert_eq!(
+        names.get(&r.element_id(role).to_string()),
+        Some(&name.split("::").map(str::to_owned).collect::<Vec<_>>())
+    );
+    role
+}
+
+const LIBRARY: &str = r#"standard library package Metaobjects {metaclass Metaobject;}
+standard library package Performances {
+function MetadataAccessEvaluation {return result: Metaobjects::Metaobject[1..*];}
+expr metadataAccessEvaluations: MetadataAccessEvaluation;
+}"#;
+const USER: &str =
+    "class Subject; alias Other for Subject; feature a=Subject.metadata; feature b=Other.metadata;";
+
+#[test]
+fn metadata_access_inherits_typed_return_without_replacing_referenced_identity() {
+    for materialize_first in [false, true] {
+        for (mode, (model, mut r)) in models(LIBRARY, USER).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            assert_canonical_role(&model, &mut r, "Performances::metadataAccessEvaluations");
+            let subject = r.resolve_qualified("Subject").unwrap();
+            let expected = r
+                .resolve_qualified("Performances::MetadataAccessEvaluation::result")
+                .unwrap();
+            let scalar = r.resolve_qualified("Metaobjects::Metaobject").unwrap();
+            for name in ["a", "b"] {
+                let e = value(&mut r, name);
+                assert_eq!(r.element_type(e), "MetadataAccessExpression");
+                assert!(r.element_scope(e).is_none());
+                let owned = r.owned_relationships(e);
+                assert_eq!(owned.len(), 1);
+                assert_eq!(r.element_type(owned[0]), "Membership");
+                assert_eq!(r.membership_member(owned[0]), Some(subject));
+                if materialize_first {
+                    r.implied_relationships(e);
+                }
+                for policy in [
+                    ClosurePolicy::Passthrough,
+                    ClosurePolicy::Closure {
+                        include_implied: false,
+                    },
+                ] {
+                    r.set_closure_policy(policy);
+                    assert_eq!(result(&mut r, e), None);
+                }
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                for _ in 0..2 {
+                    assert_eq!(result(&mut r, e), Some(expected), "mode {mode}");
+                    let memberships: Vec<_> = r
+                        .inherited_memberships(e, true)
+                        .into_iter()
+                        .filter(|&m| r.element_type(m) == "ReturnParameterMembership")
+                        .collect();
+                    assert_eq!(memberships.len(), 1);
+                    assert_eq!(r.membership_member(memberships[0]), Some(expected));
+                    assert!(!r.inheritance_incomplete(e, true));
+                    assert!(!r.inheritance_walk_truncated(e, true));
+                    assert_eq!(r.effective_cardinality(expected), Some((1, None)));
+                    let typing = r
+                        .owned_relationships(expected)
+                        .into_iter()
+                        .find(|&x| r.element_type(x) == "FeatureTyping")
+                        .unwrap();
+                    assert_eq!(
+                        r.element_properties(typing)["type"]["@id"],
+                        r.element_id(scalar).to_string()
+                    );
+                    assert_eq!(r.owned_relationships(e), owned);
+                    assert_eq!(r.membership_member(owned[0]), Some(subject));
+                    assert!(r.element_scope(e).is_none());
+                }
+            }
+            assert_eq!(model.loaded_library_unit_count(), loaded);
+        }
+    }
+}
+
+#[test]
+fn metadata_result_requires_a_unique_loaded_canonical_typed_base() {
+    for library in [
+        "standard library package Performances;",
+        "standard library package Performances {class metadataAccessEvaluations;}",
+        "standard library package Performances {expr metadataAccessEvaluations;}",
+        "standard library package Performances {function F; expr metadataAccessEvaluations:F;}",
+        "standard library package Performances {function F {return result:Missing;} expr metadataAccessEvaluations:F;}",
+        "standard library package Values {datatype A;datatype B;} standard library package Performances {function F {return a:Values::A;} function G{return b:Values::B;} expr metadataAccessEvaluations:F,G;}",
+    ] {
+        for (model, mut r) in models(library, USER) {
+            let role = (library != "standard library package Performances;").then(|| {
+                assert_canonical_role(&model, &mut r, "Performances::metadataAccessEvaluations")
+            });
+            let e = value(&mut r, "a");
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            assert_eq!(result(&mut r, e), None, "{library}");
+            assert!(r.inheritance_incomplete(e, true), "{library}");
+            if let Some(role) = role {
+                let edges = r.implied_relationships(e);
+                if r.element_type(role) == "Expression" {
+                    assert_eq!(
+                        edges.len(),
+                        1,
+                        "the partial hierarchy must reach the canonical base"
+                    );
+                    assert_eq!(
+                        r.element_properties(edges[0])["subsettedFeature"]["@id"],
+                        r.element_id(role).to_string()
+                    );
+                } else {
+                    assert!(edges.is_empty());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn supplied_metadata_names_cannot_promote_loaded_user_returns() {
+    use std::collections::HashMap;
+    let user = format!("{USER} function F {{return wrong:Subject;}} expr fake:F;");
+    for (_, mut r) in models("standard library package Performances;", &user) {
+        let fake = r.resolve_qualified("fake").unwrap();
+        r.set_library_names(&HashMap::from([(
+            r.element_id(fake).to_string(),
+            vec!["Performances".into(), "metadataAccessEvaluations".into()],
+        )]));
+        let e = value(&mut r, "a");
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        assert_eq!(result(&mut r, e), None);
+        assert!(r.inheritance_incomplete(e, true));
+        assert!(r.implied_relationships(e).is_empty());
+    }
+}
+
+#[test]
+fn standard_metadata_access_return_is_the_library_metaobject_parameter() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.exists() {
+        eprintln!("skipping: library not present");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).expect("library loads");
+    assert!(
+        model
+            .add_source("metadata-use.kerml", USER)
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&model);
+    let function = r
+        .resolve_qualified("Performances::MetadataAccessEvaluation")
+        .unwrap();
+    let scalar = r.resolve_qualified("Metaobjects::Metaobject").unwrap();
+    let memberships: Vec<_> = r
+        .owned_relationships(function)
+        .into_iter()
+        .filter(|&m| r.element_type(m) == "ReturnParameterMembership")
+        .collect();
+    assert_eq!(memberships.len(), 1);
+    let expected = r.membership_member(memberships[0]).unwrap();
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let e = value(&mut r, "a");
+    assert_eq!(result(&mut r, e), Some(expected));
+    assert!(!r.inheritance_incomplete(e, true));
+    assert_eq!(r.effective_cardinality(expected), Some((1, None)));
+    let typing = r
+        .owned_relationships(expected)
+        .into_iter()
+        .find(|&rel| r.element_type(rel) == "FeatureTyping")
+        .unwrap();
+    assert_eq!(
+        r.element_properties(typing)["type"]["@id"],
+        r.element_id(scalar).to_string()
+    );
+    assert!(r.element_scope(e).is_none());
+    assert_eq!(r.owned_relationships(e).len(), 1);
+}
+
+#[test]
+fn warmed_metadata_results_follow_role_and_referent_identity_updates() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    for external in [false, true] {
+        for (_, mut r) in models(LIBRARY, USER) {
+            let e = value(&mut r, "a");
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+            let ret = result(&mut r, e).unwrap();
+            let role = r
+                .resolve_qualified("Performances::metadataAccessEvaluations")
+                .unwrap();
+            let subject = r.resolve_qualified("Subject").unwrap();
+            let role_id = Uuid::parse_str("b0300000-0000-4000-8000-000000000001").unwrap();
+            let subject_id = Uuid::parse_str("b0300000-0000-4000-8000-000000000002").unwrap();
+            let ret_id = Uuid::parse_str("b0300000-0000-4000-8000-000000000003").unwrap();
+            r.override_ids(&HashMap::from([
+                (r.element_id(subject), subject_id),
+                (r.element_id(ret), ret_id),
+            ]));
+            if external {
+                r.set_library_names(&HashMap::from([(
+                    role_id.to_string(),
+                    vec!["Performances".into(), "metadataAccessEvaluations".into()],
+                )]));
+                assert_eq!(result(&mut r, e), None);
+                assert!(r.inheritance_incomplete(e, true));
+            } else {
+                r.override_ids(&HashMap::from([(r.element_id(role), role_id)]));
+                let actual = result(&mut r, e).unwrap();
+                assert_eq!(r.element_id(actual), ret_id);
+                assert!(!r.inheritance_incomplete(e, true));
+            }
+            let membership = r.owned_relationships(e)[0];
+            let referent = r.membership_member(membership).unwrap();
+            assert_eq!(r.element_id(referent), subject_id);
+            let rels = r.implied_relationships(e);
+            assert_eq!(rels.len(), 1);
+            assert_eq!(
+                r.element_properties(rels[0])["subsettedFeature"]["@id"],
+                role_id.to_string()
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/model.rs b/crates/sysmlv2-parser/tests/model.rs
index e072e83..696c23c 100644
--- a/crates/sysmlv2-parser/tests/model.rs
+++ b/crates/sysmlv2-parser/tests/model.rs
@@ -108,6 +108,10 @@ fn protected_members_are_visible_to_specializers_but_private_members_are_not() {
                 feature redefines inherited;
                 feature redefines secret;
             }
+            class Ordinary specializes Base {
+                feature protectedReference references inherited;
+                feature privateReference references secret;
+            }
             feature outsideProtected : Base::inherited;
             feature outsidePrivate : Base::secret;
         }",
@@ -123,12 +127,26 @@ fn protected_members_are_visible_to_specializers_but_private_members_are_not() {
     assert_eq!(
         unresolved,
         ["Base::inherited", "Base::secret", "secret"],
-        "a specializer inherits protected, never private; external qualified access sees neither"
+        "ordinary inheritance exposes protected, not private; external qualified access sees neither"
     );
     let mut resolved = sysmlv2_parser::json::ResolvedModel::build(&model);
+    let secret = resolved.resolve_qualified("P::Base::secret").unwrap();
+    let inherited = resolved.resolve_qualified("P::Base::inherited").unwrap();
+    // Redefinition headers resolve with the general as their local namespace,
+    // so they can address its private owned member without inheriting it.
+    let targets: Vec<_> = resolved
+        .reference_sites()
+        .iter()
+        .filter(|site| site.kind == "redefinedFeature")
+        .map(|site| site.target)
+        .collect();
+    assert_eq!(targets, [inherited, secret]);
+    let ordinary = resolved.resolve_qualified("P::Ordinary").unwrap();
     assert!(
-        resolved.resolve_qualified("P::Base::secret").is_some(),
-        "absolute tooling paths can still address private model elements"
+        resolved
+            .inherited_memberships(ordinary, false)
+            .into_iter()
+            .all(|membership| resolved.membership_member(membership) != Some(secret))
     );
 }
 
@@ -682,8 +700,8 @@ fn recursive_membership_import_visible_from_outside() {
 /// instead of the package's. The serialized `importedNamespace` must stay
 /// the package, while a plain *reference* to the imported name prefers the
 /// imported member (imported memberships shadow outer namespaces).
-/// Found via GfSE/SysML-v2-Models (`package Domain`
-/// owning `part def Domain`, EveOnlineMiningFrigate).
+/// Found in a community model (`package Domain`
+/// owning `part def Domain`).
 #[cfg(feature = "json")]
 #[test]
 fn namespace_import_does_not_capture_its_own_target() {
@@ -735,9 +753,9 @@ fn namespace_import_does_not_capture_its_own_target() {
 
 /// The first segment of a qualified reference commits to the nearest
 /// binding without backtracking: with `import Domain::*;` making the inner
-/// `part def Domain` visible, `Domain::PilotPod` resolves `Domain` to the
-/// part def and fails on `PilotPod` — even though the root package `Domain`
-/// has that member (KerML resolution commits per segment; the GfSE Eve
+/// `part def Domain` visible, `Domain::Cabin` resolves `Domain` to the
+/// part def and fails on `Cabin` — even though the root package `Domain`
+/// has that member (KerML resolution commits per segment; a community
 /// corpus exercises exactly this shape).
 #[cfg(feature = "json")]
 #[test]
@@ -747,11 +765,11 @@ fn imported_member_shadows_package_for_qualified_refs() {
         "shadow.sysml",
         "package Domain {
             part def Domain;
-            part def PilotPod;
+            part def Cabin;
         }
         package User {
             private import Domain::*;
-            part p : Domain::PilotPod;
+            part p : Domain::Cabin;
         }",
     );
     assert!(!model.has_errors());
@@ -759,7 +777,7 @@ fn imported_member_shadows_package_for_qualified_refs() {
     let (_, unresolved) = count_refs(&elements);
     assert_eq!(
         unresolved, 1,
-        "Domain::PilotPod stays unresolved — the imported part def shadows the package"
+        "Domain::Cabin stays unresolved — the imported part def shadows the package"
     );
 }
 
@@ -769,7 +787,7 @@ fn imported_member_shadows_package_for_qualified_refs() {
 /// intermediate scopes' import caches at that exhausted depth, permanently
 /// poisoning them with empty import sets — so whether a *shallow* reference
 /// through the same scopes resolved depended on pending-resolution order
-/// (on the GfSE Eve corpus, on CLI file order). The deep probe stays
+/// (on that community corpus, on CLI file order). The deep probe stays
 /// unresolved; the shallow one must resolve regardless of coming second.
 #[cfg(feature = "json")]
 #[test]
@@ -970,6 +988,87 @@ fn view_exposure_honors_filters() {
     );
 }
 
+/// A view's rendering is its own `render` member's — a declared
+/// rendering as well as a referenced one, through a feature chain too —
+/// else the one it inherits through a typing or a specialization, at any
+/// depth; of several inherited renderings the first in heritage order
+/// wins, and a definition's own rendering precedes the one it inherits in
+/// turn. The answer matches the specification's `viewRendering`
+/// derivation, which the derived-property API computes under the closure
+/// policy.
+#[test]
+fn view_rendering_follows_inheritance() {
+    use sysmlv2_parser::json::{ClosurePolicy, Derived, DerivedValue, Reference, ResolvedModel};
+    let mut model = Model::new();
+    model.add_source(
+        "vr.sysml",
+        "package VR {
+            rendering def Layout;
+            rendering asTable : Layout;
+            rendering asTree : Layout;
+            rendering asGrid : Layout;
+            part layouts { rendering asNested : Layout; }
+            view def TableView { render asTable; }
+            view def TreeView { render asTree; }
+            view def GridView :> TreeView { render asGrid; }
+            view def LeftTable :> TableView;
+            view def RightTable :> TableView;
+            view def Unrendered;
+            view def NestedView { render layouts.asNested; }
+            view inherits : TableView;
+            view exposing : TableView { expose VR::*; }
+            view overrides : TableView { render asTree; }
+            view declares : TableView { render rendering outline : Layout; }
+            view refined :> inherits;
+            view deepest : GridView;
+            view tableFirst : TableView, TreeView;
+            view treeFirst : TreeView, TableView;
+            view diamond : LeftTable, RightTable;
+            view unrendered : Unrendered;
+            view chained { render layouts.asNested; }
+            view nested : NestedView;
+            view bare;
+         }",
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    let expected = [
+        ("VR::inherits", Some("asTable")),
+        ("VR::exposing", Some("asTable")),
+        ("VR::overrides", Some("asTree")),
+        ("VR::declares", Some("outline")),
+        ("VR::refined", Some("asTable")),
+        ("VR::deepest", Some("asGrid")),
+        ("VR::tableFirst", Some("asTable")),
+        ("VR::treeFirst", Some("asTree")),
+        ("VR::diamond", Some("asTable")),
+        ("VR::unrendered", None),
+        ("VR::chained", Some("asNested")),
+        ("VR::nested", Some("asNested")),
+        ("VR::bare", None),
+        ("VR::GridView", Some("asGrid")),
+        ("VR::LeftTable", Some("asTable")),
+    ];
+    for (view, rendering) in expected {
+        let v = r.resolve_qualified(view).expect(view);
+        assert_eq!(r.view_rendering(v).as_deref(), rendering, "{view}");
+    }
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    for (view, rendering) in expected {
+        let v = r.resolve_qualified(view).expect(view);
+        let derived = match r.derived(v, "viewRendering") {
+            Derived::Value(DerivedValue::Reference(Reference::Element(e))) => {
+                r.element_name(e).map(str::to_string)
+            }
+            Derived::Value(DerivedValue::Null) => None,
+            other => panic!("{view}: {other:?}"),
+        };
+        assert_eq!(derived.as_deref(), rendering, "{view} (derived)");
+    }
+}
+
 #[cfg(feature = "json")]
 #[test]
 fn anonymous_redefinition_fanout_targets_the_inherited_feature() {
@@ -1071,32 +1170,36 @@ fn redefinition_fanout_preserves_inherited_overrides_and_named_members() {
         }
         assert!(check::validate_model(&model).is_empty());
     }
-    // Declared local targets remain visible: the fix is not an
-    // inherited-only lookup, nor a blanket removal of local members.
+    // A redefinition starts in each direct general Type; the declaring
+    // Type's local feature is not a target when no general Type exists.
     let mut model = Model::new();
     model.add_source(
         "local.kerml",
         "class C { feature x; feature y redefines x; }",
     );
-    let mut r = ResolvedModel::build(&model);
-    let x = r.resolve_qualified("C::x").unwrap();
     let rows = emit(&model);
     let edge = rows.iter().find(|e| e["@type"] == "Redefinition").unwrap();
-    assert_eq!(edge["redefinedFeature"]["@id"], r.element_id(x).to_string());
+    assert_eq!(edge["redefinedFeature"]["@ref"], "x");
+    assert!(
+        check::validate_model(&model)
+            .iter()
+            .any(|(_, d)| d.message.contains("unresolved reference `x`"))
+    );
 }
 
 #[cfg(feature = "json")]
 #[test]
 fn redefinition_fanout_does_not_hide_missing_or_ambiguous_targets() {
     use sysmlv2_parser::check;
+    let generals = "part def L { ref part items : Item[*]; }
+          part def R { ref part items : Item[*]; }";
+    // A redefinition header tries the written generals in order: with
+    // `L, R` both redefinitions take `L::items`. An ambiguity inside the
+    // one general `LR` still surfaces.
+    let joined = format!("{generals} part def LR :> L, R;");
     for (definitions, typing, diagnostic) in [
         ("part def C;", "C", "unresolved reference `items`"),
-        (
-            "part def L { ref part items : Item[*]; }
-          part def R { ref part items : Item[*]; }",
-            "L, R",
-            "ambiguous reference `items`",
-        ),
+        (joined.as_str(), "LR", "ambiguous reference `items`"),
     ] {
         let mut model = Model::new();
         model.add_source(
@@ -1116,6 +1219,26 @@ fn redefinition_fanout_does_not_hide_missing_or_ambiguous_targets() {
             "{findings:?}"
         );
     }
+    let mut model = Model::new();
+    model.add_source(
+        "ordered.sysml",
+        &format!(
+            "package P {{
+            part def Item; {generals} part a : Item;
+            part c : L, R {{ ref :>> items = a; ref :>> items = a; }}
+        }}"
+        ),
+    );
+    assert!(check::validate_model(&model).is_empty());
+    let mut resolved = sysmlv2_parser::json::ResolvedModel::build(&model);
+    let items = resolved.resolve_qualified("P::L::items").unwrap();
+    let targets: Vec<_> = resolved
+        .reference_sites()
+        .iter()
+        .filter(|site| site.kind == "redefinedFeature")
+        .map(|site| site.target)
+        .collect();
+    assert_eq!(targets, [items, items]);
     // Ordinary references to indistinguishable siblings remain ambiguous.
     let mut model = Model::new();
     model.add_source(
@@ -1344,33 +1467,37 @@ fn inherited_members_imports_and_redefinition_siblings() {
         "y and x both removed by the intersection condition, got {leftover:?}"
     );
 
-    // (4) Alias memberships inherit as memberships: `alias m for mass`
-    // in the base arrives on the subtype, navigable to its target.
-    let mut model = Model::new();
-    model.add_source(
-        "a.sysml",
-        "package P {
-            part def Base { attribute mass; alias m for mass; }
-            part def Sub :> Base;
-         }",
-    );
-    let mut r = ResolvedModel::build(&model);
-    let sub = r.resolve_qualified("P::Sub").unwrap();
-    let memberships = r.inherited_memberships(sub, false);
-    let alias = memberships
-        .iter()
-        .copied()
-        .find(|&m| r.membership_is_alias(m))
-        .expect("inherited alias membership");
-    assert_eq!(r.membership_member_name(alias).as_deref(), Some("m"));
-    let mass = r.resolve_qualified("P::Base::mass").unwrap();
-    assert_eq!(r.membership_member(alias), Some(mass));
-    // The ordinary membership for `mass` is present too.
-    assert!(
-        memberships
-            .iter()
-            .any(|&m| !r.membership_is_alias(m) && r.membership_member(m) == Some(mass))
-    );
+    // (4) A Feature's owning membership and alias suppress each other.
+    // If the original membership is private, the public alias alone inherits
+    // and remains navigable to that same Feature.
+    for visibility in ["", "private"] {
+        let mut model = Model::new();
+        model.add_source(
+            "a.sysml",
+            &format!(
+                "package P {{
+                part def Base {{ {visibility} attribute mass; alias m for mass; }}
+                part def Sub :> Base;
+             }}"
+            ),
+        );
+        let mut r = ResolvedModel::build(&model);
+        let sub = r.resolve_qualified("P::Sub").unwrap();
+        let memberships = r.inherited_memberships(sub, false);
+        if visibility.is_empty() {
+            assert!(
+                memberships.is_empty(),
+                "distinct memberships mutually suppress"
+            );
+        } else {
+            assert_eq!(memberships.len(), 1);
+            let alias = memberships[0];
+            assert!(r.membership_is_alias(alias));
+            assert_eq!(r.membership_member_name(alias).as_deref(), Some("m"));
+            let mass = r.resolve_qualified("P::Base::mass").unwrap();
+            assert_eq!(r.membership_member(alias), Some(mass));
+        }
+    }
 }
 
 /// Composition corner cases: nested re-export filter policy,
@@ -1410,30 +1537,37 @@ fn inherited_members_import_policy_composition() {
         "nested [@Safety] filter must hold through the re-export: {names:?}"
     );
 
-    // (2) Aliases reached through a public import are enumerated.
-    let mut model = Model::new();
-    model.add_source(
-        "a.sysml",
-        "package P {
-            package Lib {
-                part x;
-                alias a for x;
-            }
-            part def Base { public import Lib::*; }
-            part def Sub :> Base;
-         }",
-    );
-    let mut r = ResolvedModel::build(&model);
-    let sub = r.resolve_qualified("P::Sub").unwrap();
-    let memberships = r.inherited_memberships(sub, false);
-    let alias = memberships
-        .iter()
-        .copied()
-        .find(|&m| r.membership_is_alias(m))
-        .expect("imported alias membership");
-    assert_eq!(r.membership_member_name(alias).as_deref(), Some("a"));
-    let x = r.resolve_qualified("P::Lib::x").unwrap();
-    assert_eq!(r.membership_member(alias), Some(x));
+    // (2) Imported alias and owning memberships of one Feature suppress
+    // each other; a public alias of an excluded private member inherits alone.
+    for visibility in ["", "private"] {
+        let mut model = Model::new();
+        model.add_source(
+            "a.sysml",
+            &format!(
+                "package P {{
+                package Lib {{ {visibility} part x; alias a for x; }}
+                part def Base {{ public import Lib::*; }}
+                part def Sub :> Base;
+             }}"
+            ),
+        );
+        let mut r = ResolvedModel::build(&model);
+        let sub = r.resolve_qualified("P::Sub").unwrap();
+        let memberships = r.inherited_memberships(sub, false);
+        if visibility.is_empty() {
+            assert!(
+                memberships.is_empty(),
+                "distinct memberships mutually suppress"
+            );
+        } else {
+            assert_eq!(memberships.len(), 1);
+            let alias = memberships[0];
+            assert!(r.membership_is_alias(alias));
+            assert_eq!(r.membership_member_name(alias).as_deref(), Some("a"));
+            let x = r.resolve_qualified("P::Lib::x").unwrap();
+            assert_eq!(r.membership_member(alias), Some(x));
+        }
+    }
 
     // (3) Redefiners of unrelated heritage branches never suppress one
     // another; an owned redefiner still suppresses both.
diff --git a/crates/sysmlv2-parser/tests/model_level_evaluability.rs b/crates/sysmlv2-parser/tests/model_level_evaluability.rs
new file mode 100644
index 0000000..db1d3ab
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/model_level_evaluability.rs
@@ -0,0 +1,180 @@
+//! Additive checked model-level eligibility remains distinct from execution.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{
+        ClosurePolicy, Derived, DerivedValue, ElementRef, ModelLevelEvaluability as Eligibility,
+        PropertyError, ResolvedModel,
+    },
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+use uuid::Uuid;
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            let unit = model.add_source(user_name, user);
+            assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let feature = r.resolve_qualified(name).unwrap();
+    let relation = r
+        .owned_relationships(feature)
+        .into_iter()
+        .find(|&r0| r.element_type(r0) == "FeatureValue")
+        .unwrap();
+    match r.derived(relation, "value") {
+        Derived::Value(v) => v.element().unwrap(),
+        value => panic!("{value:?}"),
+    }
+}
+const LIBRARY: &str = "standard library package Base {classifier Anything {feature self;}} standard library package DataFunctions {function '+' {in a; in b; return r;}}";
+#[test]
+fn eligibility_leaf_reference_and_unknown_cases_survive_all_replay_modes() {
+    let source = r#"class T; feature raw; feature plain=raw; feature lit=1; feature via=lit;
+        feature n=null; feature text="s"; feature metaRead=T.metadata;
+        feature bad featured by Missing; feature badRef=bad;
+        feature missingCtor=new Missing(); feature missingMetadata=Missing.metadata;
+        feature selfRef=Base::Anything::self;
+        function User {return result;} feature call=User();
+        feature sum=DataFunctions::'+'(1,2);"#;
+    for (mode, (model, mut r)) in models(LIBRARY, source).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            for _ in 0..2 {
+                for name in ["plain", "lit", "via", "n", "text", "metaRead", "selfRef"] {
+                    let e = value(&mut r, name);
+                    assert_eq!(
+                        r.model_level_evaluability(e).classification,
+                        Eligibility::Evaluable,
+                        "mode {mode}: {name}"
+                    );
+                    assert_eq!(
+                        r.property(e, "isModelLevelEvaluable"),
+                        Err(PropertyError::Approximate)
+                    );
+                }
+                for name in ["badRef", "missingCtor", "missingMetadata", "sum", "call"] {
+                    let e = value(&mut r, name);
+                    assert!(
+                        matches!(
+                            r.model_level_evaluability(e).classification,
+                            Eligibility::Unknown(_)
+                        ),
+                        "mode {mode}: {name}"
+                    );
+                }
+                let bad = value(&mut r, "badRef");
+                assert!(
+                    matches!(
+                        r.derived(bad, "isModelLevelEvaluable"),
+                        Derived::Value(DerivedValue::Bool(true))
+                    ),
+                    "legacy compatibility value is deliberately unchanged"
+                );
+            }
+        }
+        let self_element = r.resolve_qualified("Base::Anything::self").unwrap();
+        r.override_ids(&HashMap::from([(
+            r.element_id(self_element),
+            Uuid::new_v4(),
+        )]));
+        let e = value(&mut r, "selfRef");
+        assert_eq!(
+            r.model_level_evaluability(e).classification,
+            Eligibility::Evaluable
+        );
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+#[test]
+fn definite_sysml_override_and_explicit_general_specialization_are_negative() {
+    for (_, mut r) in models_named(LIBRARY, "calc def F {return r;} calc c:F;", "uses.sysml") {
+        let c = r.resolve_qualified("c").unwrap();
+        assert_eq!(
+            r.model_level_evaluability(c).classification,
+            Eligibility::NotEvaluable
+        );
+    }
+    for (_, mut r) in models(LIBRARY, "expr explicit : Missing;") {
+        let explicit = r.resolve_qualified("explicit").unwrap();
+        assert_eq!(
+            r.model_level_evaluability(explicit).classification,
+            Eligibility::NotEvaluable
+        );
+    }
+}
+
+#[test]
+fn checked_metadata_and_references_survive_materialization_and_id_remap() {
+    let library = format!(
+        "{LIBRARY} standard library package Occurrences {{class Occurrence specializes Base::Anything;}}"
+    );
+    for (mode, (model, mut r)) in models(&library,
+        "class T; feature lit=1; feature via=lit; feature metaRead=T.metadata; feature selfRef=Base::Anything::self;").into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        for name in ["via", "metaRead", "selfRef"] {
+            let expression = value(&mut r, name);
+            assert_eq!(r.model_level_evaluability(expression).classification, Eligibility::Evaluable);
+        }
+        let t = r.resolve_qualified("T").unwrap();
+        assert!(!r.implied_relationships(t).is_empty(), "fixture must materialize a real suffix");
+        for remapped in [false, true] {
+            if remapped {
+                let self_feature = r.resolve_qualified("Base::Anything::self").unwrap();
+                r.override_ids(&HashMap::from([
+                    (r.element_id(t), Uuid::new_v4()),
+                    (r.element_id(self_feature), Uuid::new_v4()),
+                ]));
+            }
+            for name in ["via", "metaRead", "selfRef"] {
+                let expression = value(&mut r, name);
+                assert_eq!(r.model_level_evaluability(expression).classification, Eligibility::Evaluable,
+                    "mode {mode}, remapped {remapped}: {name}");
+            }
+        }
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/model_level_function_identity.rs b/crates/sysmlv2-parser/tests/model_level_function_identity.rs
new file mode 100644
index 0000000..2690b8e
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/model_level_function_identity.rs
@@ -0,0 +1,293 @@
+//! Designated model-level function identities from KerML Tables 5 and 7.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{Derived, DerivedValue, ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+use uuid::Uuid;
+
+// Normative table rows, independent of the implementation's dispatch.
+const ELIGIBLE: &[(&str, &[&str])] = &[
+    (
+        "BaseFunctions",
+        &[
+            "istype", "hastype", "@", "@@", "as", "meta", "==", "!=", "===", "!==", "#", ",",
+        ],
+    ),
+    (
+        "DataFunctions",
+        &[
+            "xor", "not", "|", "&", "<", ">", "<=", ">=", "+", "-", "*", "/", "%", "^", "..",
+        ],
+    ),
+    (
+        "ControlFunctions",
+        &["??", "if", "or", "and", "implies", ".", "collect", "select"],
+    ),
+];
+
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source("calls.kerml", user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+fn evaluable(r: &mut ResolvedModel, e: ElementRef) -> bool {
+    match r.derived(e, "isModelLevelEvaluable") {
+        Derived::Value(DerivedValue::Bool(value)) => value,
+        other => panic!("unexpected evaluability result: {other:?}"),
+    }
+}
+fn value(r: &mut ResolvedModel, owner: &str) -> ElementRef {
+    let e = r.resolve_qualified(owner).unwrap();
+    let fv = r
+        .owned_relationships(e)
+        .into_iter()
+        .find(|&rel| r.element_type(rel) == "FeatureValue")
+        .unwrap();
+    match r.derived(fv, "value") {
+        Derived::Value(value) => value.element().unwrap(),
+        other => panic!("unexpected feature value: {other:?}"),
+    }
+}
+
+#[test]
+fn designated_function_table_and_exclusions_survive_all_library_representations() {
+    let mut library = String::new();
+    for &(package, names) in ELIGIBLE {
+        library.push_str(&format!("package {package} {{"));
+        for name in names {
+            library.push_str(&format!(" function '{name}' {{ in x; return r; }}"));
+        }
+        library.push_str(" function custom { in x; return r; } package Nested { function '+' { in x; return r; } }");
+        for name in match package {
+            "BaseFunctions" => &["all", "["][..],
+            "DataFunctions" => &["~"][..],
+            _ => &[][..],
+        } {
+            library.push_str(&format!(" function '{name}' {{ in x; return r; }}"));
+        }
+        library.push('}');
+    }
+    let user = "package U { alias plus for DataFunctions::'+'; feature p=plus(1); feature arbitrary=DataFunctions::custom(1); feature n=~1; feature bracket=1[2]; class T; feature extent=all T; }";
+    for (model, mut r) in models(&library, user) {
+        let loaded = model.loaded_library_unit_count();
+        for _ in 0..2 {
+            for &(package, names) in ELIGIBLE {
+                for name in names {
+                    let qn = format!("{package}::'{name}'");
+                    let e = r.resolve_qualified(&qn).unwrap();
+                    assert!(evaluable(&mut r, e), "{qn}");
+                }
+                for tail in ["custom", "Nested::'+'"] {
+                    let qn = format!("{package}::{tail}");
+                    let e = r.resolve_qualified(&qn).unwrap();
+                    assert!(!evaluable(&mut r, e), "{qn}");
+                }
+            }
+            for qn in [
+                "BaseFunctions::'all'",
+                "BaseFunctions::'['",
+                "DataFunctions::'~'",
+            ] {
+                let e = r.resolve_qualified(qn).unwrap();
+                assert!(!evaluable(&mut r, e), "{qn}");
+            }
+            for (qn, expected) in [
+                ("U::p", true),
+                ("U::arbitrary", false),
+                ("U::n", false),
+                ("U::bracket", false),
+                ("U::extent", false),
+            ] {
+                let expr = value(&mut r, qn);
+                assert_eq!(evaluable(&mut r, expr), expected, "{qn}");
+            }
+        }
+        let plus = r.resolve_qualified("DataFunctions::'+'").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(plus), Uuid::new_v4())]));
+        let expr = value(&mut r, "U::p");
+        assert!(evaluable(&mut r, expr));
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn external_operator_identities_use_exact_designated_names() {
+    let mut model = Model::new();
+    assert!(
+        model
+            .add_source(
+                "external.kerml",
+                "class T; feature p=1+2; feature n=~1; feature bracket=1[2]; feature extent=all T;"
+            )
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&model);
+    let plus = value(&mut r, "p");
+    assert!(!evaluable(&mut r, plus));
+    let names = [
+        ("DataFunctions", "+"),
+        ("DataFunctions", "~"),
+        ("BaseFunctions", "["),
+        ("BaseFunctions", "all"),
+    ]
+    .into_iter()
+    .map(|(package, name)| {
+        (
+            Uuid::new_v4().to_string(),
+            vec![package.to_string(), name.to_string()],
+        )
+    })
+    .collect();
+    r.set_library_names(&names);
+    for (name, expected) in [
+        ("p", true),
+        ("n", false),
+        ("bracket", false),
+        ("extent", false),
+    ] {
+        let expr = value(&mut r, name);
+        assert_eq!(evaluable(&mut r, expr), expected, "{name}");
+    }
+    r.set_library_names(&HashMap::from([(
+        Uuid::new_v4().to_string(),
+        vec!["DataFunctions".into(), "Nested".into(), "+".into()],
+    )]));
+    assert!(!evaluable(&mut r, plus));
+}
+
+#[test]
+fn spelling_does_not_designate_user_functions_or_wrong_library_metaclasses() {
+    let mut model = Model::new();
+    assert!(model.add_source("user.kerml", "package DataFunctions { function '+' { in x; return r; } } feature p=DataFunctions::'+'(1);").diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&model);
+    let plus = r.resolve_qualified("DataFunctions::'+'").unwrap();
+    assert!(!evaluable(&mut r, plus));
+    let expr = value(&mut r, "p");
+    assert!(!evaluable(&mut r, expr));
+    for (_, mut r) in models("package DataFunctions { class '+'; }", "feature p=1+2;") {
+        let expr = value(&mut r, "p");
+        assert!(!evaluable(&mut r, expr));
+    }
+}
+
+#[test]
+fn exponentiation_spellings_resolve_to_the_same_designated_function() {
+    for (_, mut r) in models(
+        "package DataFunctions { function '^' { in x; in y; return r; } }",
+        "feature caret=2^3; feature stars=2**3;",
+    ) {
+        let function = r.resolve_qualified("DataFunctions::'^'").unwrap();
+        for name in ["caret", "stars"] {
+            let expression = value(&mut r, name);
+            assert!(evaluable(&mut r, expression));
+            assert_eq!(
+                r.derived(expression, "instantiatedType"),
+                Derived::Value(DerivedValue::Reference(
+                    sysmlv2_parser::json::Reference::Element(function)
+                ))
+            );
+        }
+    }
+}
+
+#[test]
+fn conflicting_external_names_cannot_prove_operator_evaluability() {
+    let mut model = Model::new();
+    model.add_source("external.kerml", "feature p=1+2;");
+    let mut r = ResolvedModel::build(&model);
+    let expression = value(&mut r, "p");
+    let first = Uuid::from_u128(0xabcdef00123456781234567812345678);
+    let second = Uuid::from_u128(0xabcdef00123456781234567812345679);
+    for _ in 0..4 {
+        r.set_library_names(&HashMap::from([
+            (first.to_string(), vec!["DataFunctions".into(), "+".into()]),
+            (second.to_string(), vec!["DataFunctions".into(), "+".into()]),
+        ]));
+        assert!(!evaluable(&mut r, expression));
+        r.set_library_names(&HashMap::from([(
+            first.to_string(),
+            vec!["DataFunctions".into(), "+".into()],
+        )]));
+        assert!(evaluable(&mut r, expression));
+        // Distinct source keys can normalize to the same UUID. Conflicting
+        // provenance must not depend on which spelling is visited last.
+        r.set_library_names(&HashMap::from([
+            (first.to_string(), vec!["DataFunctions".into(), "+".into()]),
+            (
+                first.to_string().to_uppercase(),
+                vec!["Other".into(), "+".into()],
+            ),
+        ]));
+        assert!(!evaluable(&mut r, expression));
+    }
+}
+
+#[test]
+fn ambiguous_loaded_function_does_not_fall_back_to_external_identity() {
+    for (_, mut r) in models(
+        "package DataFunctions { function '+' { in x; return r; } function '+' { in x; return r; } }",
+        "feature p=1+2;",
+    ) {
+        assert!(r.resolve_qualified("DataFunctions::'+'").is_none());
+        r.set_library_names(&HashMap::from([(
+            Uuid::new_v4().to_string(),
+            vec!["DataFunctions".into(), "+".into()],
+        )]));
+        let expression = value(&mut r, "p");
+        assert!(!evaluable(&mut r, expression));
+    }
+}
+
+#[test]
+fn external_name_table_cannot_relabel_an_in_model_declaration() {
+    for (_, mut r) in models(
+        "package Other { class C; function F { in x; return r; } }",
+        "feature p=1+2;",
+    ) {
+        for qn in ["Other::C", "Other::F"] {
+            let target = r.resolve_qualified(qn).unwrap();
+            r.set_library_names(&HashMap::from([(
+                r.element_id(target).to_string(),
+                vec!["DataFunctions".into(), "+".into()],
+            )]));
+            let expression = value(&mut r, "p");
+            assert!(!evaluable(&mut r, expression));
+            let replacement = Uuid::new_v4();
+            r.override_ids(&HashMap::from([(r.element_id(target), replacement)]));
+            assert!(!evaluable(&mut r, expression));
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/multiplicity_validation.rs b/crates/sysmlv2-parser/tests/multiplicity_validation.rs
new file mode 100644
index 0000000..62e5443
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/multiplicity_validation.rs
@@ -0,0 +1,931 @@
+//! Authored header, body and named ranges share exact validation semantics.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    check, json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, users: &[(&str, &str)]) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("library.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(41).unwrap(), 41).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("library.kerml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for &(name, source) in users {
+                let unit = m.add_source(name, source);
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+            }
+            m
+        })
+        .collect()
+}
+
+fn messages(source: &str) -> Vec<String> {
+    let mut m = Model::new();
+    m.add_source("test.kerml", source);
+    assert!(!m.has_errors(), "{source}");
+    check::validate_semantics(&m)
+        .into_iter()
+        .map(|(_, d)| d.message)
+        .collect()
+}
+
+#[test]
+fn authored_ranges_share_numeric_validation_without_duplicate_diagnostics() {
+    for (range, error) in [
+        ("3..2", "lower bound 3 exceeds upper bound 2"),
+        (
+            "9007199254740993..9007199254740992",
+            "lower bound 9007199254740993 exceeds upper bound 9007199254740992",
+        ),
+        (
+            "170141183460469231731687303715884105729..170141183460469231731687303715884105728",
+            "lower bound 170141183460469231731687303715884105729 exceeds upper bound 170141183460469231731687303715884105728",
+        ),
+        ("1.5", "Natural number"),
+        ("true", "Natural number"),
+        ("\"two\"", "Natural number"),
+        ("*..*", "Natural number"),
+        ("negative", "upper bound is negative"),
+    ] {
+        for declaration in [
+            format!("feature p[{range}];"),
+            format!("feature p {{ multiplicity [{range}]; }}"),
+            format!(
+                "multiplicity named[{range}]; feature p {{ multiplicity subsets named; }} feature q {{ multiplicity subsets named; }}"
+            ),
+        ] {
+            let findings = messages(&format!("feature negative = -1; {declaration}"));
+            assert_eq!(findings.len(), 1, "{declaration}: {findings:?}");
+            assert!(findings[0].contains(error), "{declaration}: {findings:?}");
+        }
+    }
+    for range in [
+        "0..*",
+        "4",
+        "unknown",
+        "absent",
+        "170141183460469231731687303715884105728",
+    ] {
+        let findings = messages(&format!(
+            "feature unknown; multiplicity named[{range}]; feature p {{ multiplicity [{range}]; }}"
+        ));
+        assert!(findings.is_empty(), "{range}: {findings:?}");
+    }
+    assert!(messages("multiplicity a subsets b; multiplicity b subsets a; feature p { multiplicity subsets a; }").is_empty());
+}
+
+#[test]
+fn range_diagnostics_keep_lexical_scope_and_source_locations_across_replay() {
+    let library = "package L { feature n = 2; multiplicity good[4]; multiplicity invalid[8..3]; }";
+    let a = "package A { feature n = 5; multiplicity wrong[n..L::n]; feature p { multiplicity subsets wrong; } }";
+    let b = "package B { feature n = 1; feature bad { multiplicity [4..n]; } }";
+    let mut expected = None;
+    for model in models(library, &[("a.kerml", a), ("b.kerml", b)]) {
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+                .into_iter()
+                .map(|(unit, d)| {
+                    assert!(!model.is_library_unit(unit));
+                    (
+                        model.unit(unit).name.clone(),
+                        d.span.start,
+                        d.span.end,
+                        d.message,
+                    )
+                })
+                .collect();
+            assert_eq!(findings.len(), 2, "{findings:?}");
+            assert_eq!(
+                &a[findings[0].1 as usize..findings[0].2 as usize],
+                "[n..L::n]"
+            );
+            assert_eq!(&b[findings[1].1 as usize..findings[1].2 as usize], "[4..n]");
+            assert!(findings[0].3.contains("5 exceeds upper bound 2"));
+            assert!(findings[1].3.contains("4 exceeds upper bound 1"));
+            if let Some(expected) = &expected {
+                assert_eq!(&findings, expected);
+            } else {
+                expected = Some(findings);
+            }
+        }
+    }
+}
+
+#[test]
+fn validation_rows_do_not_turn_named_domains_into_feature_cardinalities() {
+    for (mode, model) in models(
+        "package L { multiplicity four[4]; alias named for four; }",
+        &[(
+            "user.kerml",
+            "feature p { multiplicity subsets L::named; } multiplicity local[7]; feature q { multiplicity subsets local; } feature header[3];",
+        )],
+    ).into_iter().enumerate() {
+        if mode == 3 { assert_eq!(model.loaded_library_unit_count(), 0); }
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            assert!(check::validate_semantics_with(&mut r, &model).is_empty());
+            for name in ["L::four", "local"] {
+                let e = r.resolve_qualified(name).unwrap();
+                assert_eq!(r.declared_multiplicity(e), None, "{name}");
+                assert_eq!(r.effective_cardinality(e), Some((0, None)), "{name}");
+            }
+            for (name, n) in [("p", 4), ("q", 7), ("header", 3)] {
+                let e = r.resolve_qualified(name).unwrap();
+                assert_eq!(r.effective_cardinality(e), Some((n, Some(n))), "{name}");
+                assert_eq!(
+                    r.declared_multiplicity(e),
+                    (name == "header").then_some((3.0, 3.0))
+                );
+            }
+        }
+        if mode == 3 { assert_eq!(model.loaded_library_unit_count(), 0); }
+    }
+}
+
+#[test]
+fn body_and_named_bounds_reach_the_existing_result_type_check() {
+    for declaration in [
+        "feature p[bound];",
+        "feature p { multiplicity [bound]; }",
+        "multiplicity named[bound];",
+    ] {
+        let findings = messages(&format!("class C; feature bound : C; {declaration}"));
+        assert_eq!(findings.len(), 1, "{declaration}: {findings:?}");
+        assert!(
+            findings[0].contains("validateMultiplicityRangeResultTypes"),
+            "{findings:?}"
+        );
+    }
+}
+
+#[test]
+fn body_bounds_resolve_inside_the_constrained_feature() {
+    let findings = messages("feature n = 9; feature p { feature n = 2; multiplicity [4..n]; }");
+    assert_eq!(
+        findings,
+        ["multiplicity lower bound 4 exceeds upper bound 2"]
+    );
+}
+
+#[test]
+fn bound_validation_uses_the_reference_source_unit_identity() {
+    use std::collections::HashMap;
+    let id = "99999999-9999-4999-8999-999999999999";
+    for (actual, spelled, expected_unit) in [(2, 9, "A.kerml"), (9, 2, "B.kerml")] {
+        let mut model = Model::new();
+        for package in ["A", "B"] {
+            model.add_source(
+                format!("{package}.kerml"),
+                &format!(
+                    "package {package} {{ feature n = {actual}; feature '{id}' = {spelled};
+                feature header[5..'{id}']; feature body {{ multiplicity [5..'{id}']; }}
+                multiplicity named[5..'{id}'];
+                class Base {{ feature x[0..'{id}']; }}
+                class Child specializes Base {{ feature y[0..5] subsets x; }}
+            }}"
+                ),
+            );
+        }
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("A::n").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), id.parse().unwrap())]));
+        let mut hints = HashMap::new();
+        for name in ["A::header", "A::body", "A::named", "A::Base::x"] {
+            let element = r.resolve_qualified(name).unwrap();
+            let range = if name == "A::named" {
+                element
+            } else {
+                r.owned_members(element)[0]
+            };
+            let upper = r.owned_members(range)[1];
+            let membership = r.owned_relationships(upper)[0];
+            hints.insert(
+                (r.element_id(membership), "memberElement".into()),
+                id.parse().unwrap(),
+            );
+        }
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&id.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 4, "{findings:?}");
+            assert!(
+                findings
+                    .iter()
+                    .all(|(unit, _)| model.unit(*unit).name == expected_unit)
+            );
+            assert_eq!(
+            findings
+                .iter()
+                .filter(|(_, d)| d.message == "multiplicity lower bound 5 exceeds upper bound 2")
+                .count(),
+            3
+        );
+            assert!(findings.iter().any(|(_,d)| d.message == "subsetting multiplicity upper bound 5 exceeds the subsetted feature's upper bound 2"));
+        }
+    }
+}
+
+#[test]
+fn bound_result_type_validation_preserves_reference_identity() {
+    use std::collections::HashMap;
+    let id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+    let mut model = Model::new();
+    for package in ["A", "B"] {
+        model.add_source(
+            format!("{package}.kerml"),
+            &format!(
+                "package {package} {{ class C; feature bound : C; feature '{id}' = 2;
+                feature header['{id}']; feature body {{ multiplicity ['{id}']; }}
+                multiplicity named['{id}']; }}"
+            ),
+        );
+    }
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    let bound = r.resolve_qualified("A::bound").unwrap();
+    r.override_ids(&HashMap::from([(r.element_id(bound), id.parse().unwrap())]));
+    let mut hints = HashMap::new();
+    for name in ["A::header", "A::body", "A::named"] {
+        let e = r.resolve_qualified(name).unwrap();
+        let range = if name == "A::named" {
+            e
+        } else {
+            r.owned_members(e)[0]
+        };
+        let expression = r.owned_members(range)[0];
+        let membership = r.owned_relationships(expression)[0];
+        hints.insert(
+            (r.element_id(membership), "memberElement".into()),
+            id.parse().unwrap(),
+        );
+    }
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&id.parse().unwrap())
+    );
+    for _ in 0..2 {
+        let findings = check::validate_semantics_with(&mut r, &model);
+        assert_eq!(findings.len(), 3, "{findings:?}");
+        assert!(
+            findings
+                .iter()
+                .all(|(unit, d)| model.unit(*unit).name == "A.kerml"
+                    && d.message.contains("validateMultiplicityRangeResultTypes"))
+        );
+    }
+}
+
+#[test]
+fn specialization_bound_reads_use_each_declarations_origin() {
+    use std::collections::HashMap;
+    let id = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
+    for form in 0..3 {
+        let mut model = Model::new();
+        model.add_source(
+            "a.kerml",
+            &format!(
+                "package A {{ feature n = 2; feature '{id}' = 9; class Base {{ {} }} }}",
+                constrained("x", "", &format!("0..'{id}'"), form)
+            ),
+        );
+        model.add_source(
+            "b.kerml",
+            &format!(
+                "package B {{ feature '{id}' = 5; class Child specializes A::Base {{ {} }} }}",
+                constrained("y", "subsets x", &format!("0..'{id}'"), form)
+            ),
+        );
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("A::n").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), id.parse().unwrap())]));
+        let x = r.resolve_qualified("A::Base::x").unwrap();
+        let range = if form == 2 {
+            r.resolve_qualified("A::Base::xDomain").unwrap()
+        } else {
+            r.owned_members(x)[0]
+        };
+        let expression = r.owned_members(range)[1];
+        let membership = r.owned_relationships(expression)[0];
+        let mut hints = HashMap::from([(
+            (r.element_id(membership), "memberElement".into()),
+            id.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&id.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 1, "{findings:?}");
+            assert_eq!(model.unit(findings[0].0).name, "b.kerml");
+            assert_eq!(
+                findings[0].1.message,
+                "subsetting multiplicity upper bound 5 exceeds the subsetted feature's upper bound 2"
+            );
+        }
+    }
+}
+
+#[test]
+fn bound_result_types_follow_cross_unit_value_dependency_identity() {
+    use std::collections::HashMap;
+    let id = "dddddddd-dddd-4ddd-8ddd-dddddddddddd";
+    let mut model = Model::new();
+    model.add_source("a.kerml", &format!("package A {{ class C; feature bound : C; feature '{id}' = 2; feature carrier = '{id}'; }}"));
+    model.add_source("b.kerml", "package B { feature header[A::carrier]; feature body { multiplicity [A::carrier]; } multiplicity named[A::carrier]; }");
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    let bound = r.resolve_qualified("A::bound").unwrap();
+    r.override_ids(&HashMap::from([(r.element_id(bound), id.parse().unwrap())]));
+    let carrier = r.resolve_qualified("A::carrier").unwrap();
+    let expression = r.members_via(carrier, "FeatureValue")[0];
+    let membership = r.owned_relationships(expression)[0];
+    let mut hints = HashMap::from([(
+        (r.element_id(membership), "memberElement".into()),
+        id.parse().unwrap(),
+    )]);
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&id.parse().unwrap())
+    );
+    for _ in 0..2 {
+        let findings = check::validate_semantics_with(&mut r, &model);
+        assert_eq!(findings.len(), 3, "{findings:?}");
+        assert!(
+            findings
+                .iter()
+                .all(|(unit, d)| model.unit(*unit).name == "b.kerml"
+                    && d.message.contains("validateMultiplicityRangeResultTypes"))
+        );
+    }
+}
+
+fn containment(source: &str) -> Vec<String> {
+    messages(source)
+        .into_iter()
+        .filter(|m| {
+            m.starts_with("redefining multiplicity") || m.starts_with("subsetting multiplicity")
+        })
+        .collect()
+}
+
+fn constrained(name: &str, specialization: &str, range: &str, form: usize) -> String {
+    match form {
+        0 => format!("feature {name}[{range}] {specialization};"),
+        1 => format!("feature {name} {specialization} {{ multiplicity [{range}]; }}"),
+        _ => format!(
+            "multiplicity {name}Domain[{range}]; feature {name} {specialization} {{ multiplicity subsets {name}Domain; }}"
+        ),
+    }
+}
+
+#[test]
+fn containment_covers_every_header_body_named_pair() {
+    for base in 0..3 {
+        for child in 0..3 {
+            for (kind, range, count) in [
+                ("redefines", "1..4", 1),
+                ("redefines", "3..6", 1),
+                ("redefines", "3..4", 0),
+                ("subsets", "0..4", 0),
+                ("subsets", "0..6", 1),
+            ] {
+                let source = format!(
+                    "class Base {{ {} }} class Child specializes Base {{ {} }}",
+                    constrained("x", "", "2..5", base),
+                    constrained("y", &format!("{kind} x"), range, child)
+                );
+                assert_eq!(
+                    containment(&source).len(),
+                    count,
+                    "{source}: {:?}",
+                    messages(&source)
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn containment_evaluates_both_domains_in_the_specializing_receiver() {
+    for base in 0..3 {
+        for child in 0..3 {
+            for (original, actual, count) in [(3, 6, 0), (6, 3, 1)] {
+                let source = format!(
+                    "class Base {{ feature n default = {original}; {} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; {} }}",
+                    constrained("x", "", "0..n", base),
+                    constrained("y", "redefines x", "0..6", child)
+                );
+                assert_eq!(
+                    containment(&source).len(),
+                    count,
+                    "{source}: {:?}",
+                    messages(&source)
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn named_domain_chains_preserve_exact_endpoints() {
+    for upper in [
+        "9007199254740993".to_string(),
+        "170141183460469231731687303715884105729".to_string(),
+        format!("1{}1", "0".repeat(399)),
+    ] {
+        let lower = format!("{}0", &upper[..upper.len() - 1]);
+        let source = format!(
+            "multiplicity limit[0..{lower}]; multiplicity linked subsets limit; alias named for linked; feature x {{ multiplicity subsets named; }} feature y subsets x {{ multiplicity [0..{upper}]; }}"
+        );
+        let found = containment(&source);
+        assert_eq!(found.len(), 1, "{source}: {:?}", messages(&source));
+        assert!(
+            found[0].contains(&upper) && found[0].contains(&lower),
+            "{found:?}"
+        );
+    }
+}
+
+#[test]
+fn incomplete_or_invalid_domains_do_not_fabricate_containment() {
+    for domain in [
+        "multiplicity subsets missing;",
+        "multiplicity subsets cycle;",
+        "multiplicity subsets wrong;",
+        "multiplicity [3..2];",
+        "multiplicity [0..unknown];",
+        "multiplicity [0..1]; multiplicity [0..2];",
+    ] {
+        for side in [false, true] {
+            let (x, y) = if side {
+                (domain, "multiplicity [0..9];")
+            } else {
+                ("multiplicity [0..1];", domain)
+            };
+            let source = format!(
+                "multiplicity cycle subsets cycle; feature wrong; feature unknown; feature x {{ {x} }} feature y subsets x {{ {y} }}"
+            );
+            assert!(
+                containment(&source).is_empty(),
+                "{source}: {:?}",
+                messages(&source)
+            );
+        }
+    }
+    assert!(
+        containment("feature x[0..1] { multiplicity [0..2]; } feature y[0..9] subsets x;")
+            .is_empty()
+    );
+    assert!(containment("feature x; feature y[0..9] subsets x;").is_empty());
+}
+
+#[test]
+fn named_containment_replays_without_hydration_and_keeps_user_spans() {
+    let source = "feature y subsets L::x { multiplicity subsets L::wide; }";
+    for (mode, model) in models("package L { multiplicity narrow[0..2]; multiplicity wide[0..4]; feature x { multiplicity subsets narrow; } }", &[("user.kerml", source)]).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 1, "{mode}: {findings:?}");
+            let (unit, d) = &findings[0];
+            assert_eq!(model.unit(*unit).name, "user.kerml");
+            assert_eq!(&source[d.span.start as usize..d.span.end as usize], "L::x");
+            assert!(d.message.starts_with("subsetting multiplicity"), "{}", d.message);
+        }
+        if mode == 3 { assert_eq!(model.loaded_library_unit_count(), 0); }
+    }
+}
+
+#[test]
+fn containment_tracks_root_and_package_formula_dependencies_in_the_receiver() {
+    for (original, actual, expected) in [(3, 6, 0), (6, 3, 1)] {
+        for package in [false, true] {
+            let source = format!(
+                "feature bound = Base::n; class Base {{ feature n default = {original}; feature x {{ multiplicity [0..bound]; }} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; feature y[0..6] redefines x; feature z redefines x; }}"
+            );
+            let source = if package {
+                format!("package P {{ {source} }}")
+            } else {
+                source
+            };
+            assert_eq!(
+                containment(&source).len(),
+                expected,
+                "{source}: {:?}",
+                messages(&source)
+            );
+            let mut model = Model::new();
+            model.add_source("test.kerml", &source);
+            let mut r = ResolvedModel::build(&model);
+            let y = r
+                .resolve_qualified(if package { "P::Child::y" } else { "Child::y" })
+                .unwrap();
+            assert_eq!(r.effective_cardinality(y), Some((0, Some(6))));
+            let z = r
+                .resolve_qualified(if package { "P::Child::z" } else { "Child::z" })
+                .unwrap();
+            assert_eq!(r.effective_cardinality(z), Some((0, Some(actual))));
+        }
+    }
+    // The containing receiver cannot select a value nested in the constrained
+    // feature; do not silently replace that unknown with a lexical value.
+    assert!(containment("feature x { feature n = 2; multiplicity [0..n]; } feature y subsets x { multiplicity [0..9]; }").is_empty());
+}
+
+#[test]
+fn root_bound_values_keep_identity_and_effective_cardinality() {
+    for (value, expected) in [
+        ("2", Some(2)),
+        ("other", Some(2)),
+        ("other + 1", Some(3)),
+        ("missing", None),
+    ] {
+        let source = format!(
+            "feature missing; feature other = 2; feature n = {value}; class Base {{ feature x[0..n]; }} class Child specializes Base {{ feature n = 99; feature y[0..4] subsets x; }} feature root[0..n];"
+        );
+        assert_eq!(
+            containment(&source).len(),
+            usize::from(expected.is_some()),
+            "{source}"
+        );
+        let mut model = Model::new();
+        model.add_source("test.kerml", &source);
+        let mut r = ResolvedModel::build(&model);
+        let root = r.resolve_qualified("root").unwrap();
+        assert_eq!(
+            r.effective_cardinality(root),
+            expected.map(|n| (0, Some(n)))
+        );
+    }
+}
+
+fn contextual(source: &str) -> Vec<String> {
+    messages(source)
+        .into_iter()
+        .filter(|m| m.contains("invalid in this specializing context"))
+        .collect()
+}
+
+#[test]
+fn specialization_reports_ranges_made_invalid_by_receiver_values() {
+    for form in 0..3 {
+        for kind in ["subsets", "redefines"] {
+            for own in ["", "[0..4]"] {
+                for (range, original, actual, reason) in [
+                    ("0..n", "3", "-1", "upper bound -1"),
+                    ("0..n", "3", "2.5", "upper bound 2.5"),
+                    ("0..n", "3", "true", "upper bound must be a Natural"),
+                    ("0..n", "3", "\"bad\"", "upper bound must be a Natural"),
+                    ("n..5", "3", "-1", "lower bound -1"),
+                    ("n..5", "3", "*", "lower bound inf"),
+                    ("2..n", "3", "1", "lower bound 2 exceeds upper bound 1"),
+                    ("n", "3", "-1", "upper bound -1"),
+                    (
+                        "9007199254740993..n",
+                        "9007199254740994",
+                        "9007199254740992",
+                        "lower bound 9007199254740993 exceeds upper bound 9007199254740992",
+                    ),
+                ] {
+                    let source = format!(
+                        "class Base {{ feature n default = {original}; {} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; feature y{own} {kind} x; }}",
+                        constrained("x", "", range, form)
+                    );
+                    let errors = contextual(&source);
+                    assert_eq!(errors.len(), 1, "{source}: {:?}", messages(&source));
+                    assert!(errors[0].contains(reason), "{errors:?}");
+                    assert!(containment(&source).is_empty(), "{source}");
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn contextual_validity_checks_own_named_domains_and_deduplicates_shared_ranges() {
+    for (base, shared) in [
+        ("feature x;", false),
+        ("feature x[0..*];", false),
+        ("feature x { multiplicity subsets interval; }", true),
+    ] {
+        let source = format!(
+            "class Base {{ feature n default = 3; multiplicity interval[0..n]; {base} }} class Child specializes Base {{ feature n redefines Base::n = -1; feature y redefines x {{ multiplicity subsets Base::interval; }} }}"
+        );
+        let errors = contextual(&source);
+        assert_eq!(errors.len(), 1, "{source}: {:?}", messages(&source));
+        assert!(
+            errors[0].starts_with(if shared {
+                "multiplicity constraint from"
+            } else {
+                "specializing multiplicity"
+            }),
+            "{errors:?}"
+        );
+    }
+}
+
+#[test]
+fn contextual_validity_does_not_duplicate_authored_errors_or_guess_unknowns() {
+    for (original, actual) in [
+        ("-1", "-2"),
+        ("missing", "-1"),
+        ("3", "missing"),
+        ("3", "3"),
+        ("3", "*"),
+    ] {
+        for form in 0..3 {
+            let source = format!(
+                "feature missing; class Base {{ feature n default = {original}; {} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; feature y redefines x; }}",
+                constrained("x", "", "0..n", form)
+            );
+            assert!(
+                contextual(&source).is_empty(),
+                "{source}: {:?}",
+                messages(&source)
+            );
+        }
+    }
+    let incomplete = "class Base { feature n default = 3; feature x[0..n]; } class Child specializes Base, Missing { feature n redefines Base::n = -1; feature y redefines x; }";
+    assert!(contextual(incomplete).is_empty());
+    let partial = "class Base { feature n default = 3; feature lo default = 0; feature x[lo..n]; } class Child specializes Base { feature missing; feature lo redefines Base::lo = missing; feature n redefines Base::n = -1; feature y redefines x; }";
+    assert!(contextual(partial).is_empty());
+}
+
+#[test]
+fn contextual_validity_preserves_replay_and_specialization_source_spans() {
+    let source = "class Child specializes L::Base { feature n redefines L::Base::n = -1; feature y redefines x; }";
+    for form in 0..3 {
+        let library = format!(
+            "package L {{ class Base {{ feature n default = 3; {} }} }}",
+            constrained("x", "", "0..n", form)
+        );
+        for (mode, model) in models(&library, &[("child.kerml", source)])
+            .into_iter()
+            .enumerate()
+        {
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                let findings = check::validate_semantics_with(&mut r, &model);
+                assert_eq!(findings.len(), 1, "{mode}: {findings:?}");
+                let (unit, d) = &findings[0];
+                assert_eq!(model.unit(*unit).name, "child.kerml");
+                assert_eq!(&source[d.span.start as usize..d.span.end as usize], "x");
+                assert!(
+                    d.message.contains("invalid in this specializing context"),
+                    "{}",
+                    d.message
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn contextual_validity_uses_bound_reference_identity_across_units() {
+    use std::collections::HashMap;
+    let id = "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee";
+    for form in 0..3 {
+        let mut model = Model::new();
+        model.add_source(
+            "base.kerml",
+            &format!(
+                "package A {{ class Base {{ feature n default = 3; feature '{id}' = 9; {} }} }}",
+                constrained("x", "", &format!("0..'{id}'"), form)
+            ),
+        );
+        model.add_source("child.kerml", &format!("package B {{ feature '{id}' = 8; class Child specializes A::Base {{ feature n redefines A::Base::n = -1; feature y redefines x; }} }}"));
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let n = r.resolve_qualified("A::Base::n").unwrap();
+        r.override_ids(&HashMap::from([(r.element_id(n), id.parse().unwrap())]));
+        let range = if form == 2 {
+            r.resolve_qualified("A::Base::xDomain").unwrap()
+        } else {
+            let x = r.resolve_qualified("A::Base::x").unwrap();
+            r.owned_members(x)[0]
+        };
+        let upper = r.owned_members(range)[1];
+        let membership = r.owned_relationships(upper)[0];
+        let mut hints = HashMap::from([(
+            (r.element_id(membership), "memberElement".into()),
+            id.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&id.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let findings = check::validate_semantics_with(&mut r, &model);
+            assert_eq!(findings.len(), 1, "{findings:?}");
+            assert_eq!(model.unit(findings[0].0).name, "child.kerml");
+            assert!(
+                findings[0].1.message.contains("upper bound -1"),
+                "{findings:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn nested_bound_members_do_not_invent_a_different_evaluation_receiver() {
+    for kind in ["subsets", "redefines"] {
+        for bound in ["inner", "Base::x::inner", "total"] {
+            let source = format!(
+                "class Base {{ feature outer default = 2; feature x {{ feature inner default = 3; feature total = inner + outer; multiplicity [0..{bound}]; }} }} class Child specializes Base {{ feature outer redefines Base::outer = 9; feature y {kind} x {{ feature renamed redefines Base::x::inner = 5; }} feature z[0..8] subsets y; }}"
+            );
+            let mut model = Model::new();
+            model.add_source("test.kerml", &source);
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            for name in ["Base::x", "Child::y"] {
+                let e = r.resolve_qualified(name).unwrap();
+                assert_eq!(r.effective_cardinality(e), None, "{source}: {name}");
+            }
+            assert!(containment(&source).is_empty(), "{source}");
+            assert!(contextual(&source).is_empty(), "{source}");
+        }
+    }
+}
+
+#[test]
+fn inherited_only_ranges_are_validated_in_the_specializing_receiver() {
+    for form in 0..3 {
+        for (range, original, actual, reason) in [
+            ("0..n", "3", "-1", "upper bound -1"),
+            ("0..n", "3", "2.5", "upper bound 2.5"),
+            ("0..n", "3", "true", "upper bound must be a Natural"),
+            ("n..5", "3", "*", "lower bound inf"),
+            ("2..n", "3", "1", "lower bound 2 exceeds upper bound 1"),
+            (
+                "9007199254740993..n",
+                "9007199254740994",
+                "9007199254740992",
+                "lower bound 9007199254740993 exceeds upper bound 9007199254740992",
+            ),
+        ] {
+            let source = format!(
+                "class Base {{ feature n default = {original}; {} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; }}",
+                constrained("x", "", range, form)
+            );
+            let errors = contextual(&source);
+            assert_eq!(errors.len(), 1, "{source}: {:?}", messages(&source));
+            assert!(errors[0].starts_with("inherited multiplicity of `x`"));
+            assert!(errors[0].contains(reason), "{errors:?}");
+        }
+    }
+}
+
+#[test]
+fn inherited_only_ranges_preserve_unknowns_and_valid_lexical_baselines() {
+    for (original, actual) in [
+        ("-1", "-2"),
+        ("missing", "-1"),
+        ("3", "missing"),
+        ("3", "3"),
+        ("3", "*"),
+    ] {
+        for form in 0..3 {
+            let source = format!(
+                "feature missing; class Base {{ feature n default = {original}; {} }} class Child specializes Base {{ feature n redefines Base::n = {actual}; }}",
+                constrained("x", "", "0..n", form)
+            );
+            assert!(
+                contextual(&source).is_empty(),
+                "{source}: {:?}",
+                messages(&source)
+            );
+        }
+    }
+    for source in [
+        "class Base { feature n default = 3; feature x[0..n]; } class Child specializes Base, Missing { feature n redefines Base::n = -1; }",
+        "class Base specializes Child { feature n default = 3; feature x[0..n]; } class Child specializes Base { feature n redefines Base::n = -1; }",
+        "class Base { feature n default = 3; feature lo default = 0; feature x[lo..n]; } class Child specializes Base { feature missing; feature lo redefines Base::lo = missing; feature n redefines Base::n = -1; }",
+        "class Base { feature n default = 3; multiplicity a subsets b; multiplicity b subsets a; feature x { multiplicity subsets a; } } class Child specializes Base { feature n redefines Base::n = -1; }",
+    ] {
+        assert!(
+            contextual(source).is_empty(),
+            "{source}: {:?}",
+            messages(source)
+        );
+    }
+}
+
+#[test]
+fn inherited_only_ranges_deduplicate_diamonds_and_preserve_receiver_isolation() {
+    for form in 0..3 {
+        let source = format!(
+            "class Base {{ feature n default = 3; {} }} class Left specializes Base; class Right specializes Base; class Bad specializes Left, Right {{ feature n redefines Base::n = -1; }} class Good specializes Left, Right {{ feature n redefines Base::n = 4; }} class AlsoBad specializes Left, Right {{ feature n redefines Base::n = -2; }}",
+            constrained("x", "", "0..n", form)
+        );
+        let errors = contextual(&source);
+        assert_eq!(errors.len(), 2, "{source}: {:?}", messages(&source));
+        assert!(errors[0].contains("upper bound -1"), "{errors:?}");
+        assert!(errors[1].contains("upper bound -2"), "{errors:?}");
+    }
+}
+
+#[test]
+fn inherited_only_ranges_preserve_prepared_replay_and_receiver_spans() {
+    let source = "class Child specializes L::Base { feature n redefines L::Base::n = -1; }";
+    for form in 0..3 {
+        let library = format!(
+            "package L {{ class Base {{ feature n default = 3; {} }} }}",
+            constrained("x", "", "0..n", form)
+        );
+        for (mode, model) in models(&library, &[("child.kerml", source)])
+            .into_iter()
+            .enumerate()
+        {
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                let findings = check::validate_semantics_with(&mut r, &model);
+                assert_eq!(findings.len(), 1, "{mode}: {findings:?}");
+                let (unit, d) = &findings[0];
+                assert_eq!(model.unit(*unit).name, "child.kerml");
+                assert_eq!(
+                    &source[d.span.start as usize..d.span.end as usize],
+                    "L::Base"
+                );
+                assert!(d.message.starts_with("inherited multiplicity of `x`"));
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn inherited_only_ranges_use_bound_identity_across_units_in_both_formats() {
+    use std::collections::HashMap;
+    use sysmlv2_parser::model::GraphFormat;
+    let id = "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee";
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for form in 0..3 {
+            let mut model = Model::with_graph_format(format);
+            model.add_source("base.kerml", &format!(
+                "package A {{ class Base {{ feature n default = 3; feature '{id}' = 9; {} }} }}",
+                constrained("x", "", &format!("0..'{id}'"), form)
+            ));
+            model.add_source("child.kerml", &format!("package B {{ feature '{id}' = 8; class Child specializes A::Base {{ feature n redefines A::Base::n = -1; }} }}"));
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let n = r.resolve_qualified("A::Base::n").unwrap();
+            r.override_ids(&HashMap::from([(r.element_id(n), id.parse().unwrap())]));
+            let range = if form == 2 {
+                r.resolve_qualified("A::Base::xDomain").unwrap()
+            } else {
+                let x = r.resolve_qualified("A::Base::x").unwrap();
+                r.owned_members(x)[0]
+            };
+            let upper = r.owned_members(range)[1];
+            let membership = r.owned_relationships(upper)[0];
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".into()),
+                id.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&id.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let findings = check::validate_semantics_with(&mut r, &model);
+                assert_eq!(findings.len(), 1, "{findings:?}");
+                assert_eq!(model.unit(findings[0].0).name, "child.kerml");
+                assert!(
+                    findings[0].1.message.contains("upper bound -1"),
+                    "{findings:?}"
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/negative/cstyle_operators.sysml b/crates/sysmlv2-parser/tests/negative/cstyle_operators.sysml
index 5acca08..b2a078a 100644
--- a/crates/sysmlv2-parser/tests/negative/cstyle_operators.sysml
+++ b/crates/sysmlv2-parser/tests/negative/cstyle_operators.sysml
@@ -1,6 +1,6 @@
 // Hazard: C-style logical operators — KerML spells them `&`/`and` and
-// `|`/`or`; `&&`/`||` are not tokens of the expression grammar (the
-// GfSE HVAC model uses them).
+// `|`/`or`; `&&`/`||` are not tokens of the expression grammar (some
+// community models use them).
 package P {
     part def R {
         attribute a : Positive;
diff --git a/crates/sysmlv2-parser/tests/negative/expressions.sysml b/crates/sysmlv2-parser/tests/negative/expressions.sysml
index 41dd082..c070db4 100644
--- a/crates/sysmlv2-parser/tests/negative/expressions.sysml
+++ b/crates/sysmlv2-parser/tests/negative/expressions.sysml
@@ -1,7 +1,7 @@
 // Hazard: expression forms — dangling operators, unclosed groups,
 // negative multiplicity bounds (grammatically literal/reference only).
 package P {
-    attribute a = 1 + ; //~ ERROR missing `;` at end of declaration
+    attribute a = 1 + ; //~ ERROR expected an expression, found `;`
     part def Fine1;
     attribute b = (1, 2; //~ ERROR expected `)`
     part def Fine2;
diff --git a/crates/sysmlv2-parser/tests/negative/imports.sysml b/crates/sysmlv2-parser/tests/negative/imports.sysml
index 6579dee..f7cda96 100644
--- a/crates/sysmlv2-parser/tests/negative/imports.sysml
+++ b/crates/sysmlv2-parser/tests/negative/imports.sysml
@@ -1,5 +1,5 @@
 // Hazard: imports require an explicit visibility in the 2025 grammar
-// (ImportPrefix), and the GfSE community corpus writes them bare.
+// (ImportPrefix), and older community models write them bare.
 package P {
     import ScalarValues::*; //~ ERROR an import must declare an explicit visibility
     private import Other::*;
diff --git a/crates/sysmlv2-parser/tests/negative/missing_expressions.kerml b/crates/sysmlv2-parser/tests/negative/missing_expressions.kerml
new file mode 100644
index 0000000..7ae526d
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/negative/missing_expressions.kerml
@@ -0,0 +1,18 @@
+// Hazard: a `;` where a feature value's expression belongs. The error is
+// the missing expression, reported at the `;`, which still ends the
+// declaration; a second `;` is a stray terminator of its own.
+package K {
+    feature a = ; //~ ERROR expected an expression, found `;`
+    feature b := ; //~ ERROR expected an expression, found `;`
+    feature c default ; //~ ERROR expected an expression, found `;`
+    feature d default = ; //~ ERROR expected an expression, found `;`
+    feature e default := ; //~ ERROR expected an expression, found `;`
+    feature f = ;; //~ ERROR expected an expression, found `;`
+    //~^ ERROR unsupported or unexpected construct at `;`
+    feature g = 1 + ; //~ ERROR expected an expression, found `;`
+    function F {
+        in x;
+        return r = ; //~ ERROR expected an expression, found `;`
+    }
+    classifier Fine;
+}
diff --git a/crates/sysmlv2-parser/tests/negative/missing_expressions.sysml b/crates/sysmlv2-parser/tests/negative/missing_expressions.sysml
new file mode 100644
index 0000000..cd276d2
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/negative/missing_expressions.sysml
@@ -0,0 +1,45 @@
+// Hazard: a `;` where an expression belongs — a value begun but not yet
+// written (`attribute x = ;`). The bare `;` alternative a calculation
+// body gives SysML's expression body is not read as an expression: the
+// error is the missing expression, reported at the `;`, and the `;` still
+// ends the declaration, so the members after it parse normally. A second
+// `;` is a stray terminator of its own.
+package P {
+    attribute a = ; //~ ERROR expected an expression, found `;`
+    attribute b := ; //~ ERROR expected an expression, found `;`
+    attribute c default ; //~ ERROR expected an expression, found `;`
+    attribute d default = ; //~ ERROR expected an expression, found `;`
+    attribute e default := ; //~ ERROR expected an expression, found `;`
+    attribute f = ;; //~ ERROR expected an expression, found `;`
+    //~^ ERROR unsupported or unexpected construct at `;`
+    attribute g = xs.; //~ ERROR expected a name, found `;`
+    attribute h = xs.?; //~ ERROR expected `{`, found `;`
+    attribute i = xs->F ; //~ ERROR expected a name, found `;`
+    part def V {
+        attribute m : Real = ; //~ ERROR expected an expression, found `;`
+        attribute n : Real;
+        assert constraint { m > ; } //~ ERROR expected an expression, found `;`
+    }
+    part v : V {
+        attribute :>> n = ; //~ ERROR expected an expression, found `;`
+    }
+    enum def E {
+        enum red = ; //~ ERROR expected an expression, found `;`
+        enum green;
+    }
+    metadata def M { attribute level; }
+    part w { @M { level = ; } } //~ ERROR expected an expression, found `;`
+    calc def F {
+        in x : Real;
+        return r : Real = ; //~ ERROR expected an expression, found `;`
+    }
+    calc def G {
+        in x : Real;
+        ; //~ ERROR unsupported or unexpected construct at `;`
+    }
+    action def A {
+        assign x := ; //~ ERROR expected an expression, found `;`
+        action next;
+    }
+    part def Fine;
+}
diff --git a/crates/sysmlv2-parser/tests/negative/pilot_era.sysml b/crates/sysmlv2-parser/tests/negative/pilot_era.sysml
index 38faab4..4d3e607 100644
--- a/crates/sysmlv2-parser/tests/negative/pilot_era.sysml
+++ b/crates/sysmlv2-parser/tests/negative/pilot_era.sysml
@@ -1,5 +1,5 @@
 // Hazard: pilot-era (pre-formal-spec) spellings that circulate in older
-// models (GfSE VehicleModel): `alias X as Y`, `id '1'`, `stream`,
+// community models: `alias X as Y`, `id '1'`, `stream`,
 // `@[unit]` quantities, `{…}` sequence literals, `do ref(args)`.
 package P {
     part def D;
diff --git a/crates/sysmlv2-parser/tests/negative/result_terminators.kerml b/crates/sysmlv2-parser/tests/negative/result_terminators.kerml
new file mode 100644
index 0000000..498f2ac
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/negative/result_terminators.kerml
@@ -0,0 +1,10 @@
+// Hazard: a function body's result expression terminated like a
+// statement — the `;` is the error, and the function keeps its result.
+package K {
+    function F {
+        in x : Real;
+        x * 2; //~ ERROR a result expression takes no terminating `;`
+    }
+    feature y = {in x; x + 1;}; //~ ERROR a result expression takes no terminating `;`
+    classifier Fine;
+}
diff --git a/crates/sysmlv2-parser/tests/negative/result_terminators.sysml b/crates/sysmlv2-parser/tests/negative/result_terminators.sysml
new file mode 100644
index 0000000..31fe6a1
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/negative/result_terminators.sysml
@@ -0,0 +1,37 @@
+// Hazard: a body's result expression terminated like a statement. In a
+// body that takes a result (calculation, constraint, case), the error is
+// the `;` itself — not the operator the member parse trips over — and the
+// expression stays the body's result, so the body closes and the members
+// after it parse normally. A `;` after an expression that does not end its
+// body, or in a body that takes no result, keeps the point-of-discovery
+// message.
+package P {
+    part def V {
+        attribute mass : Real;
+        attribute limit : Real;
+        assert constraint {
+            mass <= limit; //~ ERROR a result expression takes no terminating `;`
+        }
+        assert constraint { mass > 0; } //~ ERROR a result expression takes no terminating `;`
+        attribute fine : Real;
+    }
+    calc def F {
+        in x : Real;
+        x * 2;; //~ ERROR a result expression takes no terminating `;`
+        //~^ ERROR a result expression takes no terminating `;`
+    }
+    constraint def C {
+        in a : Real;
+        if a > 0 ? true else false; //~ ERROR a result expression takes no terminating `;`
+    }
+    constraint def D {
+        in a : Real;
+        a > 0; //~ ERROR expected `;` or `{`, found `>`
+        in b : Real;
+    }
+    part def W {
+        attribute m : Real;
+        m > 0; //~ ERROR expected `;` or `{`, found `>`
+    }
+    part def Fine;
+}
diff --git a/crates/sysmlv2-parser/tests/operations.rs b/crates/sysmlv2-parser/tests/operations.rs
new file mode 100644
index 0000000..a59aee1
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/operations.rs
@@ -0,0 +1,337 @@
+//! Declaration-identity operation invocation is distinct from scalar evaluation.
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{
+        ClosurePolicy, Derived, DerivedValue, ElementRef, OperationArgumentIssue, OperationError,
+        Reference, ResolvedModel, operation_execution_signature,
+    },
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+use uuid::Uuid;
+const EVALUATE: &str = "Kernel-Functions-Expression-evaluate_Element";
+const ELIGIBLE: &str = "Kernel-Functions-Expression-modelLevelEvaluable_Feature";
+const DIRECTION: &str = "Kernel-Behaviors-ParameterMembership-parameterDirection_";
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let feature = r.resolve_qualified(name).unwrap();
+    let relation = r
+        .owned_relationships(feature)
+        .into_iter()
+        .find(|&r0| r.element_type(r0) == "FeatureValue")
+        .unwrap();
+    match r.derived(relation, "value") {
+        Derived::Value(v) => v.element().unwrap(),
+        value => panic!("{value:?}"),
+    }
+}
+
+#[test]
+fn constant_families_preserve_identity_order_and_empty_results_across_replay_modes() {
+    let user = r#"class T; feature target; feature i=1; feature b=true; feature real=1.5; feature text="s"; feature inf=*; feature n=null; feature m=T.metadata; function F {in x; return r;} feature call=F(1);"#;
+    for (model, mut r) in models("package L {classifier T;}", user) {
+        let loaded = model.loaded_library_unit_count();
+        let target = r.resolve_qualified("target").unwrap();
+        let function = r.resolve_qualified("F").unwrap();
+        let parameters = r.owned_relationships(function);
+        let call = value(&mut r, "call");
+        let parameter = r
+            .owned_relationships(call)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "ParameterMembership")
+            .unwrap();
+        let return_ = *parameters
+            .iter()
+            .find(|&&e| r.element_type(e) == "ReturnParameterMembership")
+            .unwrap();
+        let expressions: Vec<_> = ["i", "b", "real", "text", "inf", "n", "m"]
+            .into_iter()
+            .map(|name| (name, value(&mut r, name)))
+            .collect();
+        let before: Vec<_> = r
+            .user_elements()
+            .map(|e| {
+                (
+                    r.element_id(e),
+                    r.element_properties(e),
+                    r.owned_relationships(e),
+                )
+            })
+            .collect();
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            for _ in 0..2 {
+                assert_eq!(
+                    r.invoke_operation(parameter, DIRECTION, &[]).unwrap().value,
+                    DerivedValue::Str("in".into())
+                );
+                let output = r.invoke_operation(return_, DIRECTION, &[]).unwrap();
+                assert_eq!(
+                    output.effective,
+                    "Kernel-Functions-ReturnParameterMembership-parameterDirection_"
+                );
+                assert_eq!(output.value, DerivedValue::Str("out".into()));
+                for &(name, expression) in &expressions {
+                    let eligible = r
+                        .invoke_operation(
+                            expression,
+                            ELIGIBLE,
+                            &[DerivedValue::Elements(vec![target])],
+                        )
+                        .unwrap();
+                    assert_eq!(eligible.value, DerivedValue::Bool(true), "{name}");
+                    if name == "m" {
+                        assert!(matches!(
+                            r.invoke_operation(
+                                expression,
+                                EVALUATE,
+                                &[DerivedValue::Element(target)]
+                            ),
+                            Err(OperationError::Unsupported {
+                                effective: "Kernel-Expressions-MetadataAccessExpression-evaluate_Element"
+                            })
+                        ));
+                    } else {
+                        let output = r
+                            .invoke_operation(
+                                expression,
+                                EVALUATE,
+                                &[DerivedValue::Element(target)],
+                            )
+                            .unwrap();
+                        assert_eq!(output.requested, EVALUATE);
+                        assert_eq!(
+                            output.value,
+                            DerivedValue::References(if name == "n" {
+                                vec![]
+                            } else {
+                                vec![Reference::Element(expression)]
+                            })
+                        );
+                    }
+                }
+            }
+        }
+        let after: Vec<_> = r
+            .user_elements()
+            .map(|e| {
+                (
+                    r.element_id(e),
+                    r.element_properties(e),
+                    r.owned_relationships(e),
+                )
+            })
+            .collect();
+        assert_eq!(after, before);
+        let integer = expressions[0].1;
+        let id = Uuid::new_v4();
+        r.override_ids(&HashMap::from([(r.element_id(integer), id)]));
+        let result = r
+            .invoke_operation(
+                integer,
+                EVALUATE,
+                &[DerivedValue::Reference(Reference::Element(target))],
+            )
+            .unwrap();
+        assert_eq!(
+            result.value,
+            DerivedValue::References(vec![Reference::Element(integer)])
+        );
+        assert_eq!(r.element_id(integer), id);
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
+#[test]
+fn overridden_sysml_constants_are_negative_and_do_not_fall_back() {
+    for (_, mut r) in models_named(
+        "package L;",
+        "calc def F {return r;} calc c:F; constraint def R; constraint r:R;",
+        "ops.sysml",
+    ) {
+        for name in ["c", "r"] {
+            let e = r.resolve_qualified(name).unwrap();
+            assert_eq!(
+                r.invoke_operation(e, ELIGIBLE, &[DerivedValue::Elements(vec![])])
+                    .unwrap()
+                    .value,
+                DerivedValue::Bool(false)
+            );
+        }
+    }
+}
+#[test]
+fn checked_arguments_are_validated_even_for_constant_bodies() {
+    for (_, mut r) in models(
+        "package L;",
+        "class T; feature f; feature i=1; feature n=null;",
+    ) {
+        let i = value(&mut r, "i");
+        let n = value(&mut r, "n");
+        let t = r.resolve_qualified("T").unwrap();
+        let f = r.resolve_qualified("f").unwrap();
+        assert_eq!(
+            r.invoke_operation(i, "evaluate", &[]),
+            Err(OperationError::UnknownOperation)
+        );
+        assert!(matches!(
+            r.invoke_operation(t, EVALUATE, &[]),
+            Err(OperationError::WrongReceiver { .. })
+        ));
+        assert!(matches!(
+            r.invoke_operation(i, EVALUATE, &[]),
+            Err(OperationError::ArgumentCount {
+                expected: 1,
+                actual: 0
+            })
+        ));
+        assert!(matches!(
+            r.invoke_operation(n, EVALUATE, &[DerivedValue::Null]),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::NullNotAllowed,
+                ..
+            })
+        ));
+        assert!(matches!(
+            r.invoke_operation(i, ELIGIBLE, &[DerivedValue::Element(f)]),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::WrongShape,
+                ..
+            })
+        ));
+        assert!(matches!(
+            r.invoke_operation(i, ELIGIBLE, &[DerivedValue::Elements(vec![t])]),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::WrongMetaclass {
+                    expected: "Feature",
+                    ..
+                },
+                ..
+            })
+        ));
+        assert!(matches!(
+            r.invoke_operation(i, ELIGIBLE, &[DerivedValue::Elements(vec![f, f])]),
+            Err(OperationError::InvalidArgument {
+                issue: OperationArgumentIssue::DuplicateIdentity,
+                ..
+            })
+        ));
+        for reference in [
+            Reference::External(Uuid::new_v4()),
+            Reference::Unresolved("Missing".into()),
+        ] {
+            assert!(matches!(
+                r.invoke_operation(i, EVALUATE, &[DerivedValue::Reference(reference)]),
+                Err(OperationError::InvalidArgument {
+                    issue: OperationArgumentIssue::UnverifiedReference,
+                    ..
+                })
+            ));
+        }
+        assert!(matches!(
+            r.invoke_operation(
+                i,
+                "Kernel-Expressions-NullExpression-evaluate_Element",
+                &[DerivedValue::Element(f)]
+            ),
+            Err(OperationError::WrongReceiver { .. })
+        ));
+        let signature = operation_execution_signature(
+            "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature",
+        )
+        .unwrap();
+        assert_eq!(
+            signature.inputs,
+            ["Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-visited"]
+        );
+        assert_eq!(
+            signature.result,
+            "Kernel-Expressions-LiteralExpression-modelLevelEvaluable_Feature-"
+        );
+    }
+}
+
+#[test]
+fn unique_operation_arguments_reject_distinct_handles_with_the_same_uuid() {
+    for (_, mut r) in models("package L;", "feature f; feature g; feature i=1;") {
+        let i = value(&mut r, "i");
+        let f = r.resolve_qualified("f").unwrap();
+        let g = r.resolve_qualified("g").unwrap();
+        assert_ne!(f, g);
+        assert_ne!(r.element_id(f), r.element_id(g));
+        assert_eq!(
+            r.invoke_operation(i, ELIGIBLE, &[DerivedValue::Elements(vec![f, g])])
+                .unwrap()
+                .value,
+            DerivedValue::Bool(true),
+        );
+        r.override_ids(&HashMap::from([(r.element_id(g), r.element_id(f))]));
+        assert_eq!(r.element_id(f), r.element_id(g));
+        for argument in [
+            DerivedValue::Elements(vec![f, g]),
+            DerivedValue::References(vec![Reference::Element(f), Reference::Element(g)]),
+        ] {
+            assert!(matches!(
+                r.invoke_operation(i, ELIGIBLE, &[argument]),
+                Err(OperationError::InvalidArgument {
+                    index: 0,
+                    issue: OperationArgumentIssue::DuplicateIdentity,
+                    ..
+                })
+            ));
+        }
+        // This is per-argument identity validation, not a newly introduced
+        // global model-validity prerequisite for constant operations.
+        assert_eq!(
+            r.invoke_operation(i, ELIGIBLE, &[DerivedValue::Elements(vec![f])])
+                .unwrap()
+                .value,
+            DerivedValue::Bool(true),
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/owned_result_featuring.rs b/crates/sysmlv2-parser/tests/owned_result_featuring.rs
new file mode 100644
index 0000000..007cf25
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/owned_result_featuring.rs
@@ -0,0 +1,98 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+fn one(r: &mut ResolvedModel, e: ElementRef, name: &str) -> ElementRef {
+    match r.derived(e, name) {
+        Derived::Value(v) => v.element().unwrap(),
+        other => panic!("{other:?}"),
+    }
+}
+fn many(r: &mut ResolvedModel, e: ElementRef, name: &str) -> Vec<ElementRef> {
+    match r.derived(e, name) {
+        Derived::Value(v) => v.elements(),
+        other => panic!("{other:?}"),
+    }
+}
+#[test]
+fn result_and_binding_end_featuring_are_real_local_relationships_with_stable_source() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "owned-featuring.kerml",
+            "feature n;feature x=n;function F {return result;}feature call=F();"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let compact = model_to_compact_json(&m);
+    let mut r = ResolvedModel::build(&m);
+    let source: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let expr = r
+        .user_elements()
+        .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+        .unwrap();
+    let mut expected = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let result = one(&mut r, expr, "result");
+        let binding = many(&mut r, expr, "ownedMember")
+            .into_iter()
+            .find(|&e| r.element_type(e) == "BindingConnector")
+            .unwrap();
+        let ends = many(&mut r, binding, "connectorEnd");
+        assert_eq!(ends.len(), 2);
+        let mut owners = vec![(result, expr)];
+        owners.extend(ends.into_iter().map(|end| (end, binding)));
+        let mut ids = Vec::new();
+        for (owner, target) in owners {
+            let rows: Vec<_> = r
+                .implied_relationships(owner)
+                .into_iter()
+                .filter(|&e| r.element_type(e) == "TypeFeaturing")
+                .collect();
+            assert_eq!(rows.len(), 1);
+            let properties = r.element_properties(rows[0]);
+            assert_eq!(
+                properties["featureOfType"]["@id"],
+                r.element_id(owner).to_string()
+            );
+            assert_eq!(
+                properties["featuringType"]["@id"],
+                r.element_id(target).to_string()
+            );
+            assert_eq!(
+                properties["owningRelatedElement"]["@id"],
+                r.element_id(owner).to_string()
+            );
+            ids.push(r.element_id(rows[0]));
+        }
+        assert!(
+            !r.implied_relationships(binding)
+                .into_iter()
+                .any(|e| r.element_type(e) == "TypeFeaturing")
+        );
+        assert!(r.property(expr, "ownedFeature").is_err());
+        if let Some(old) = &expected {
+            assert_eq!(&ids, old);
+        } else {
+            expected = Some(ids);
+        }
+    }
+    assert_eq!(
+        source,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(compact, model_to_compact_json(&m));
+}
diff --git a/crates/sysmlv2-parser/tests/owned_result_redefinition.rs b/crates/sysmlv2-parser/tests/owned_result_redefinition.rs
new file mode 100644
index 0000000..fb4fe6e
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/owned_result_redefinition.rs
@@ -0,0 +1,71 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ResolvedModel, model_to_compact_json},
+    model::Model,
+};
+#[test]
+fn generated_result_redefines_the_actual_canonical_return_without_promoting_the_family() {
+    let mut m = Model::new();
+    m.add_library_source("result-library.kerml","standard library package Base {classifier Anything;feature things:Anything;} standard library package Occurrences {class Occurrence specializes Base::Anything;feature occurrences:Occurrence subsets Base::things;} standard library package Performances {behavior Performance specializes Occurrences::Occurrence;function Evaluation specializes Performance {return result;} step performances:Performance subsets Occurrences::occurrences;expr evaluations:Evaluation subsets performances;}");
+    m.add_source("result-user.kerml", "feature n;feature x=n;");
+    assert!(!m.has_errors());
+    let compact = model_to_compact_json(&m);
+    let mut r = ResolvedModel::build(&m);
+    let source: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+    let expression = r
+        .user_elements()
+        .find(|&e| r.element_type(e) == "FeatureReferenceExpression")
+        .unwrap();
+    let target = r
+        .resolve_qualified("Performances::Evaluation::result")
+        .unwrap();
+    let mut previous = None;
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let result = match r.derived(expression, "result") {
+            Derived::Value(v) => v.element().unwrap(),
+            other => panic!("{other:?}"),
+        };
+        let edges: Vec<_> = r
+            .implied_relationships(result)
+            .into_iter()
+            .filter(|&e| r.element_type(e) == "Redefinition")
+            .collect();
+        assert_eq!(edges.len(), 1);
+        let edge = edges[0];
+        let properties = r.element_properties(edge);
+        assert_eq!(
+            properties["redefiningFeature"]["@id"],
+            r.element_id(result).to_string()
+        );
+        assert_eq!(
+            properties["redefinedFeature"]["@id"],
+            r.element_id(target).to_string()
+        );
+        assert_eq!(
+            properties["owningRelatedElement"]["@id"],
+            r.element_id(result).to_string()
+        );
+        assert!(r.property(expression, "ownedFeature").is_err());
+        let identity = (result, edge, r.element_id(result), r.element_id(edge));
+        if let Some(previous) = previous {
+            assert_eq!(identity, previous);
+        }
+        previous = Some(identity);
+    }
+    assert_eq!(
+        source,
+        r.user_elements()
+            .map(|e| r.element_id(e))
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(compact, model_to_compact_json(&m));
+}
diff --git a/crates/sysmlv2-parser/tests/owned_results.rs b/crates/sysmlv2-parser/tests/owned_results.rs
new file mode 100644
index 0000000..41fb1af
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/owned_results.rs
@@ -0,0 +1,509 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+const LIBRARY: &str = "standard library package Values { datatype Integer; feature n:Integer[2]; alias a for n; feature libraryReference=n; }";
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(name).unwrap();
+    let rel = r
+        .owned_relationships(owner)
+        .into_iter()
+        .find(|&e| r.element_type(e) == "FeatureValue")
+        .unwrap();
+    one(r, rel, "value").unwrap()
+}
+fn one(r: &mut ResolvedModel, e: ElementRef, p: &str) -> Option<ElementRef> {
+    match r.derived(e, p) {
+        Derived::Value(v) => v.element(),
+        v => panic!("{p}: {v:?}"),
+    }
+}
+fn many(r: &mut ResolvedModel, e: ElementRef, p: &str) -> Vec<ElementRef> {
+    match r.derived(e, p) {
+        Derived::Value(sysmlv2_parser::json::DerivedValue::Elements(v)) => v,
+        v => panic!("{p}: {v:?}"),
+    }
+}
+
+#[test]
+fn reference_owned_results_share_identity_projections_under_every_closure_policy() {
+    for materialize_first in [false, true] {
+        for (model, mut r) in models(LIBRARY, "feature x=Values::n; feature y=Values::a;") {
+            let loaded = model.loaded_library_unit_count();
+            let before: Vec<_> = r
+                .elements()
+                .map(|e| {
+                    (
+                        r.element_id(e),
+                        r.element_properties(e),
+                        r.owned_relationships(e),
+                    )
+                })
+                .collect();
+            let n = r.resolve_qualified("Values::n").unwrap();
+            let integer = r.resolve_qualified("Values::Integer").unwrap();
+            let mut identities = std::collections::HashMap::new();
+            for policy in [
+                ClosurePolicy::Passthrough,
+                ClosurePolicy::Closure {
+                    include_implied: false,
+                },
+                ClosurePolicy::Closure {
+                    include_implied: true,
+                },
+            ] {
+                r.set_closure_policy(policy);
+                for name in ["x", "y", "Values::libraryReference"] {
+                    let expression = value(&mut r, name);
+                    assert_eq!(r.element_type(expression), "FeatureReferenceExpression");
+                    let source_members = r.owned_relationships(expression);
+                    assert_eq!(source_members.len(), 1);
+                    if materialize_first {
+                        r.implied_relationships(expression);
+                    }
+                    let result = one(&mut r, expression, "result")
+                        .expect("admitted reference owns its result");
+                    if let Some(previous) = identities.insert(expression, r.element_id(result)) {
+                        assert_eq!(previous, r.element_id(result));
+                    }
+                    let member = one(&mut r, result, "owningMembership").unwrap();
+                    assert_eq!(r.element_type(member), "ReturnParameterMembership");
+                    assert!(r.is_implied(member));
+                    assert!(!r.is_implied(result));
+                    assert!(r.element_scope(result).is_none());
+                    assert_eq!(
+                        r.is_library_element(result),
+                        r.is_library_element(expression)
+                    );
+                    assert_eq!(r.owner(result), Some(expression));
+                    assert_eq!(r.owner(member), Some(expression));
+                    assert_eq!(one(&mut r, member, "owningType"), Some(expression));
+                    assert_eq!(one(&mut r, result, "owningType"), Some(expression));
+                    assert_eq!(one(&mut r, expression, "referent"), Some(n));
+                    assert_eq!(
+                        many(&mut r, expression, "ownedFeatureMembership"),
+                        vec![member]
+                    );
+                    assert_eq!(many(&mut r, expression, "ownedFeature"), vec![result]);
+                    let owned_members = many(&mut r, expression, "ownedMember");
+                    assert_eq!(owned_members.len(), 2);
+                    assert_eq!(owned_members[0], result);
+                    assert_eq!(r.element_type(owned_members[1]), "BindingConnector");
+                    assert_eq!(many(&mut r, expression, "ownedElement"), owned_members);
+                    for property in [
+                        "ownedElement",
+                        "ownedMember",
+                        "ownedFeature",
+                        "ownedFeatureMembership",
+                        "ownedMembership",
+                    ] {
+                        assert_eq!(
+                            r.derived_exact(expression, property),
+                            Err(sysmlv2_parser::json::PropertyError::Approximate),
+                            "required library ancestry and the remaining expression rules stay qualified"
+                        );
+                    }
+
+                    let implied = r.implied_relationships(expression);
+                    let relationships: Vec<_> = source_members
+                        .iter()
+                        .copied()
+                        .chain(implied)
+                        .map(|e| serde_json::json!({"@id": r.element_id(e).to_string()}))
+                        .collect();
+                    assert_eq!(
+                        r.property(expression, "ownedRelationship"),
+                        Ok(serde_json::json!(relationships)),
+                        "structural inventory includes authored and published relationships"
+                    );
+                    assert_eq!(
+                        r.property(expression, "isImpliedIncluded"),
+                        Err(sysmlv2_parser::json::PropertyError::Approximate),
+                        "listing published relationships does not certify every implied family"
+                    );
+
+                    assert!(
+                        r.owned_members(expression).is_empty(),
+                        "source navigation stays explicit"
+                    );
+                    assert_eq!(r.owned_relationships(expression), source_members);
+                    let subsets = many(&mut r, result, "ownedSubsetting");
+                    assert_eq!(subsets.len(), 1);
+                    assert_eq!(
+                        r.relationship_ends(subsets[0]),
+                        (
+                            vec![sysmlv2_parser::json::Reference::Element(result)],
+                            vec![sysmlv2_parser::json::Reference::Element(n)]
+                        )
+                    );
+                    assert!(r.conforms_with_implied(result, n));
+                    match r.derived(result, "type") {
+                        Derived::Value(sysmlv2_parser::json::DerivedValue::References(v)) => {
+                            assert!(v.contains(&sysmlv2_parser::json::Reference::Element(integer)))
+                        }
+                        v => panic!("{v:?}"),
+                    };
+                }
+            }
+            assert_eq!(
+                before,
+                r.elements()
+                    .map(|e| (
+                        r.element_id(e),
+                        r.element_properties(e),
+                        r.owned_relationships(e)
+                    ))
+                    .collect::<Vec<_>>()
+            );
+            assert_eq!(loaded, model.loaded_library_unit_count());
+        }
+    }
+}
+
+#[test]
+fn full_reference_subtrees_are_reciprocal_and_lift_to_the_original_source_graph() {
+    use sysmlv2_parser::{
+        full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json},
+        json::model_to_compact_json,
+        lift::{from_compact_json, from_compact_json_with_names},
+        print::print_source,
+    };
+    for (model, mut r) in models(LIBRARY, "feature x=Values::a;") {
+        let compact = model_to_compact_json(&model);
+        let names = sysmlv2_parser::json::library_element_name_map(&model);
+        let compact_lifted = from_compact_json_with_names(&compact, &names).unwrap();
+        assert!(
+            compact_lifted.errors.is_empty(),
+            "{:?}",
+            compact_lifted.errors
+        );
+        let expected = print_source(&compact_lifted.unit);
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            let expression = value(&mut r, "x");
+            let result = one(&mut r, expression, "result").unwrap();
+            let membership = one(&mut r, result, "owningMembership").unwrap();
+            let subset = many(&mut r, result, "ownedSubsetting")[0];
+            let full = resolved_to_full_json(
+                &mut r,
+                &model,
+                EmissionPolicy {
+                    unresolved: UnresolvedReferencePolicy::Reject,
+                    closures: policy,
+                },
+            )
+            .unwrap();
+            let rows = full.as_array().unwrap();
+            for element in [membership, result, subset] {
+                assert_eq!(
+                    rows.iter()
+                        .filter(|row| row["@id"] == r.element_id(element).to_string())
+                        .count(),
+                    1
+                );
+            }
+            let result_row = rows
+                .iter()
+                .find(|row| row["@id"] == r.element_id(result).to_string())
+                .unwrap();
+            assert_eq!(result_row["@type"], "Feature");
+            assert!(result_row.get("isImplied").is_none());
+            assert_eq!(
+                result_row["owningRelationship"]["@id"],
+                r.element_id(membership).to_string()
+            );
+            let member_row = rows
+                .iter()
+                .find(|row| row["@id"] == r.element_id(membership).to_string())
+                .unwrap();
+            assert_eq!(
+                member_row["ownedRelatedElement"],
+                serde_json::json!([{"@id":r.element_id(result).to_string()}])
+            );
+            assert_eq!(
+                member_row["owningRelatedElement"]["@id"],
+                r.element_id(expression).to_string()
+            );
+            let lifted = from_compact_json_with_names(&full, &names).unwrap();
+            assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+            assert_eq!(print_source(&lifted.unit), expected);
+            assert_eq!(model_to_compact_json(&model), compact);
+        }
+        assert!(from_compact_json(&compact).is_ok());
+    }
+}
+
+#[test]
+fn missing_or_non_feature_referents_do_not_get_fabricated_owned_results() {
+    for (_, mut r) in models("class A;", "feature missing=Absent; feature classRef=A;") {
+        for name in ["missing", "classRef"] {
+            let expression = value(&mut r, name);
+            assert_eq!(one(&mut r, expression, "result"), None);
+            assert!(many(&mut r, expression, "ownedFeatureMembership").is_empty());
+        }
+    }
+}
+
+#[test]
+fn predicted_generated_identity_collision_refuses_the_whole_subtree() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    for collision in 0..3 {
+        for (_, mut r) in models("feature n; feature occupant;", "feature x=n;") {
+            let expression = value(&mut r, "x");
+            let referent = r.resolve_qualified("n").unwrap();
+            let occupant = r.resolve_qualified("occupant").unwrap();
+            let expression_id = r.element_id(expression);
+            let result_id = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{expression_id}/implied/ownedResult").as_bytes(),
+            );
+            let membership_id = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{expression_id}/implied/returnMembership").as_bytes(),
+            );
+            let subset_id = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{result_id}/implied/Subsetting/{}", r.element_id(referent)).as_bytes(),
+            );
+            let collision_id = [membership_id, result_id, subset_id][collision];
+            assert!(r.element_by_id(&collision_id.to_string()).is_none());
+            r.override_ids(&HashMap::from([(r.element_id(occupant), collision_id)]));
+            let before: Vec<_> = r.elements().map(|e| r.element_id(e)).collect();
+            assert_eq!(
+                before
+                    .iter()
+                    .collect::<std::collections::HashSet<_>>()
+                    .len(),
+                before.len()
+            );
+            assert_eq!(one(&mut r, expression, "result"), None);
+            assert!(r.implied_relationships(expression).is_empty());
+            assert_eq!(r.element_by_id(&collision_id.to_string()), Some(occupant));
+            for (index, id) in [membership_id, result_id, subset_id]
+                .into_iter()
+                .enumerate()
+            {
+                if index != collision {
+                    assert!(
+                        r.element_by_id(&id.to_string()).is_none(),
+                        "no orphan generated rows"
+                    );
+                }
+            }
+            assert_eq!(
+                before,
+                r.elements().map(|e| r.element_id(e)).collect::<Vec<_>>()
+            );
+        }
+    }
+}
+
+#[test]
+fn source_identity_binding_rebuilds_reference_results_including_an_empty_plan() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    let target_id = Uuid::parse_str("a280c39c-62f7-4c26-9793-fcdd9d5ad340").unwrap();
+    for lexical_exists in [false, true] {
+        let source = format!(
+            "{} feature actual; feature x='{}';",
+            if lexical_exists {
+                format!("feature '{}';", target_id)
+            } else {
+                String::new()
+            },
+            target_id
+        );
+        for (_, mut r) in models("", &source) {
+            let expression = value(&mut r, "x");
+            let actual = r.resolve_qualified("actual").unwrap();
+            let membership = r.owned_relationships(expression)[0];
+            let old_referent = one(&mut r, expression, "referent");
+            let old_result = one(&mut r, expression, "result");
+            assert_eq!(old_result.is_some(), lexical_exists);
+            // Capture IDs only: generated handles must be reacquired after the
+            // following source-identity binding mutation.
+            let old_subset_id = old_result.map(|result| {
+                let subset = many(&mut r, result, "ownedSubsetting")[0];
+                r.element_id(subset)
+            });
+            r.override_ids(&HashMap::from([(r.element_id(actual), target_id)]));
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".to_owned()),
+                target_id,
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&target_id)
+            );
+            assert_eq!(one(&mut r, expression, "referent"), Some(actual));
+            let result = one(&mut r, expression, "result").unwrap();
+            let subset = many(&mut r, result, "ownedSubsetting")[0];
+            let ends = r.relationship_ends(subset);
+            assert_eq!(
+                ends.1,
+                vec![sysmlv2_parser::json::Reference::Element(actual)]
+            );
+            if let Some(old) = old_subset_id {
+                assert!(r.element_by_id(&old.to_string()).is_none());
+            }
+            if let Some(old) = old_referent {
+                assert!(!r.conforms_with_implied(result, old));
+            }
+            let result_id = r.element_id(result);
+            let subset_id = r.element_id(subset);
+            r.bind_id_spelled_references_with(&mut hints);
+            let reacquired = one(&mut r, expression, "result").unwrap();
+            let reacquired_subset = many(&mut r, reacquired, "ownedSubsetting")[0];
+            assert_eq!(r.element_id(reacquired), result_id);
+            assert_eq!(r.element_id(reacquired_subset), subset_id);
+        }
+    }
+}
+
+#[test]
+fn rebinding_loss_keeps_source_and_generic_implied_handles_stable() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    let target_id = Uuid::parse_str("6893e10d-a292-4725-8295-a4656f0f5b23").unwrap();
+    let library = "standard library package Performances {function Evaluation; function Marker;}";
+    for target_in_model in [false, true] {
+        let source = format!(
+            "feature '{}'; class wrongKind; feature x='{}';",
+            target_id, target_id
+        );
+        for (_, mut r) in models(library, &source) {
+            let expression = value(&mut r, "x");
+            let expression_id = r.element_id(expression);
+            let membership = r.owned_relationships(expression)[0];
+            let old_result = one(&mut r, expression, "result").unwrap();
+            let old_result_id = r.element_id(old_result);
+            let marker = r.resolve_qualified("Performances::Marker").unwrap();
+            let generic = r.implied_relationships(marker);
+            assert_eq!(generic.len(), 1);
+            let generic_ids: Vec<_> = generic.iter().map(|&e| r.element_id(e)).collect();
+            if target_in_model {
+                let wrong = r.resolve_qualified("wrongKind").unwrap();
+                r.override_ids(&HashMap::from([(r.element_id(wrong), target_id)]));
+            }
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".to_owned()),
+                target_id,
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&target_id)
+            );
+            assert_eq!(r.element_id(expression), expression_id);
+            assert_eq!(r.implied_relationships(marker), generic);
+            assert_eq!(
+                generic.iter().map(|&e| r.element_id(e)).collect::<Vec<_>>(),
+                generic_ids
+            );
+            assert_eq!(one(&mut r, expression, "result"), None);
+            assert!(r.element_by_id(&old_result_id.to_string()).is_none());
+            assert_eq!(
+                r.derived_exact(expression, "ownedFeature"),
+                Err(sysmlv2_parser::json::PropertyError::Approximate)
+            );
+            assert!(r.implied_relationships(expression).is_empty());
+        }
+    }
+}
+
+#[test]
+fn standard_library_referent_keeps_result_identity_type_and_qualified_family_status() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.exists() {
+        eprintln!("skipping: library not present");
+        return;
+    }
+    let mut model = Model::new();
+    model.load_library_dir(&library).expect("library loads");
+    assert!(
+        model
+            .add_source("reference-use.kerml", "feature x=Base::naturals;")
+            .diagnostics
+            .is_empty()
+    );
+    let mut r = ResolvedModel::build(&model);
+    let expression = value(&mut r, "x");
+    let referent = r.resolve_qualified("Base::naturals").unwrap();
+    let natural = r.resolve_qualified("ScalarValues::Natural").unwrap();
+    let original_id = r.element_id(expression);
+    for policy in [
+        ClosurePolicy::Passthrough,
+        ClosurePolicy::Closure {
+            include_implied: false,
+        },
+        ClosurePolicy::Closure {
+            include_implied: true,
+        },
+    ] {
+        r.set_closure_policy(policy);
+        let result =
+            one(&mut r, expression, "result").expect("stored canonical referent admits a result");
+        assert_eq!(r.element_id(expression), original_id);
+        assert_eq!(r.owner(result), Some(expression));
+        assert!(r.element_scope(result).is_none());
+        assert!(r.conforms_with_implied(result, referent));
+        match r.derived(result, "type") {
+            Derived::Value(sysmlv2_parser::json::DerivedValue::References(types)) => {
+                assert!(types.contains(&sysmlv2_parser::json::Reference::Element(natural)))
+            }
+            other => panic!("{other:?}"),
+        }
+        assert_eq!(
+            r.derived_exact(expression, "ownedFeature"),
+            Err(sysmlv2_parser::json::PropertyError::Approximate)
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/parser.rs b/crates/sysmlv2-parser/tests/parser.rs
index f15f5ff..3b7bd34 100644
--- a/crates/sysmlv2-parser/tests/parser.rs
+++ b/crates/sysmlv2-parser/tests/parser.rs
@@ -1640,6 +1640,61 @@ fn qualified_name_member_only_in_metadata_bodies() {
     ));
 }
 
+#[test]
+fn terminated_result_expression_stays_the_result() {
+    // `x * 2;` ending a calc body: one error, spanning the `;` alone,
+    // and the expression is still the body's result member.
+    let src = "package P { calc def F { in x; x * 2; } }";
+    let Parse { unit, diagnostics } = parse_source(src);
+    let semi = src.find("2;").unwrap() + 1;
+    assert_eq!(diagnostics.len(), 1, "{diagnostics:#?}");
+    assert_eq!(
+        (
+            diagnostics[0].span.start as usize,
+            diagnostics[0].span.end as usize
+        ),
+        (semi, semi + 1)
+    );
+    assert_eq!(
+        diagnostics[0].message,
+        sysmlv2_parser::parser::RESULT_EXPRESSION_TERMINATOR
+    );
+    let MemberKind::Package(p) = &unit.members[0].kind else {
+        panic!()
+    };
+    let MemberKind::Definition(d) = &p.body.as_ref().unwrap()[0].kind else {
+        panic!()
+    };
+    let body = d.body.as_ref().unwrap();
+    assert_eq!(body.len(), 2, "{body:#?}");
+    let MemberKind::Result(e) = &body[1].kind else {
+        panic!("{body:#?}")
+    };
+    assert!(matches!(e.kind, ExprKind::Binary { .. }), "{e:#?}");
+    assert_eq!(
+        &src[body[1].span.start as usize..body[1].span.end as usize],
+        "x * 2"
+    );
+
+    // A body that takes no result parses as it always has: the member
+    // parse's error at the operator, and no result member.
+    let src = "package P { part def V { attribute m; m > 0; } }";
+    let Parse { unit, diagnostics } = parse_source(src);
+    assert_eq!(diagnostics.len(), 1, "{diagnostics:#?}");
+    assert_eq!(diagnostics[0].message, "expected `;` or `{`, found `>`");
+    let MemberKind::Package(p) = &unit.members[0].kind else {
+        panic!()
+    };
+    let MemberKind::Definition(d) = &p.body.as_ref().unwrap()[0].kind else {
+        panic!()
+    };
+    let body = d.body.as_ref().unwrap();
+    assert!(
+        !body.iter().any(|m| matches!(m.kind, MemberKind::Result(_))),
+        "{body:#?}"
+    );
+}
+
 #[test]
 fn extended_definition_and_usage() {
     let body = package_body(
@@ -1812,6 +1867,93 @@ fn missing_semicolon_before_brace_defers_to_result_expression() {
     assert_eq!(d.body.as_ref().unwrap().len(), 1, "repaired member kept");
 }
 
+/// Parse `src`, which must report exactly one error per `;` at the byte
+/// offsets `semis`, in order, each spanning its `;`: the errors'
+/// messages, and the package body.
+fn errors_at_semis(src: &str, semis: &[usize]) -> (Vec<String>, Vec<Member>) {
+    let Parse { unit, diagnostics } = parse_source(src);
+    let spans: Vec<_> = diagnostics
+        .iter()
+        .map(|d| (d.span.start as usize, d.span.end as usize))
+        .collect();
+    let expected: Vec<_> = semis.iter().map(|&at| (at, at + 1)).collect();
+    assert_eq!(spans, expected, "{src:?}: {diagnostics:#?}");
+    let MemberKind::Package(p) = unit.members.into_iter().next().unwrap().kind else {
+        panic!("{src:?}")
+    };
+    let messages = diagnostics.into_iter().map(|d| d.message).collect();
+    (messages, p.body.expect("package body"))
+}
+
+#[test]
+fn a_missing_value_is_reported_at_its_terminator() {
+    const MISSING: &str = "expected an expression, found `;`";
+    const STRAY: &str = "unsupported or unexpected construct at `;`";
+
+    // `=`, `:=`, and `default` take an expression. A `;` in its place is
+    // the declaration's terminator with the expression missing — not the
+    // bare-`;` body a calculation body lends SysML's expression body. One
+    // error, at the `;`; the declaration stays in the tree without a
+    // value, and the member after it parses clean, on the same line or
+    // the next.
+    for value in ["=", ":=", "default", "default =", "default :="] {
+        for gap in [" ", "\n    "] {
+            let src = format!("package P {{{gap}attribute x {value} ;{gap}part def Y;\n}}");
+            let semi = src.find(" ;").unwrap() + 1;
+            let (messages, body) = errors_at_semis(&src, &[semi]);
+            assert_eq!(messages, [MISSING], "{src:?}");
+            let [x, y] = body.as_slice() else {
+                panic!("{src:?}: {body:#?}")
+            };
+            let MemberKind::Usage(x) = &x.kind else {
+                panic!("{src:?}: {x:#?}")
+            };
+            assert_eq!(x.declaration.id.name.as_ref().unwrap().value, "x");
+            assert!(x.value.is_none(), "{src:?}: {x:#?}");
+            assert!(matches!(y.kind, MemberKind::Definition(_)), "{src:?}");
+        }
+    }
+
+    // A doubled terminator: the first `;` ends the declaration, the
+    // second is a stray `;` of its own.
+    let src = "package P { attribute x = ;; part def Y; }";
+    let semi = src.find(";;").unwrap();
+    let (messages, body) = errors_at_semis(src, &[semi, semi + 1]);
+    assert_eq!(messages, [MISSING, STRAY]);
+    assert_eq!(body.len(), 2, "{body:#?}");
+
+    // Nor is a `;` an operand, a collect or select body, or the body of
+    // an arrow invocation: each is reported at the `;`, which still ends
+    // the declaration.
+    for src in [
+        "package P { attribute x = 1 + ; part def Y; }",
+        "package P { attribute x = xs.; part def Y; }",
+        "package P { attribute x = xs.?; part def Y; }",
+        "package P { attribute x = xs->F ; part def Y; }",
+    ] {
+        let semi = src.find(';').unwrap();
+        let (_, body) = errors_at_semis(src, &[semi]);
+        assert_eq!(body.len(), 2, "{src:?}: {body:#?}");
+    }
+
+    // A lone `;` ending a calculation body is a stray terminator, not the
+    // body's result expression.
+    let src = "package P { calc def F { in x; ; } }";
+    let semi = src.rfind(';').unwrap();
+    let (messages, body) = errors_at_semis(src, &[semi]);
+    assert_eq!(messages, [STRAY]);
+    let MemberKind::Definition(f) = &body[0].kind else {
+        panic!("{body:#?}")
+    };
+    let members = f.body.as_ref().unwrap();
+    assert!(
+        !members
+            .iter()
+            .any(|m| matches!(m.kind, MemberKind::Result(_))),
+        "{members:#?}"
+    );
+}
+
 #[test]
 fn spans_are_meaningful() {
     let src = "package P { part x : T; }";
diff --git a/crates/sysmlv2-parser/tests/positional_alias_memberships.rs b/crates/sysmlv2-parser/tests/positional_alias_memberships.rs
new file mode 100644
index 0000000..f9ab67e
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/positional_alias_memberships.rs
@@ -0,0 +1,194 @@
+#![cfg(feature = "json")]
+
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, DerivedValue, ResolvedModel},
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+fn check(library: &str, source: &str, expected: Option<&str>, incomplete: bool) {
+    let mut base = Model::new();
+    base.add_library_source("aliases.kerml", library);
+    let prepared = base.prepare_library().unwrap();
+    let serialized =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(17).unwrap(), 17).unwrap());
+    for mode in 0..3 {
+        for warm in [false, true] {
+            let mut model = Model::new();
+            match mode {
+                0 => {
+                    model.add_library_source("aliases.kerml", library);
+                }
+                1 => {
+                    Arc::clone(&prepared).install(&mut model).unwrap();
+                }
+                _ => {
+                    Arc::clone(&serialized).install(&mut model).unwrap();
+                }
+            }
+            model.add_source("user.kerml", source);
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let owner = r.resolve_qualified("U::Leaf").unwrap();
+            let slot = r.resolve_qualified("U::Leaf::slot").unwrap();
+            let expected = expected.map(|name| {
+                let e = r.resolve_qualified(name).unwrap();
+                r.element_id(e).to_string()
+            });
+            if warm {
+                r.inherited_memberships(owner, true);
+            }
+            let targets: Vec<_> = r
+                .implied_relationships(slot)
+                .into_iter()
+                .filter(|&edge| r.element_type(edge) == "Redefinition")
+                .map(|edge| {
+                    r.element_properties(edge)["redefinedFeature"]["@id"]
+                        .as_str()
+                        .unwrap()
+                        .to_owned()
+                })
+                .collect();
+            assert_eq!(
+                targets,
+                expected.iter().cloned().collect::<Vec<_>>(),
+                "mode={mode}, warm={warm}"
+            );
+            assert_eq!(r.inheritance_incomplete(owner, true), incomplete);
+            if !incomplete {
+                r.set_closure_policy(ClosurePolicy::Closure {
+                    include_implied: true,
+                });
+                let mid = r.resolve_qualified("P::Mid").unwrap();
+                let Derived::Value(DerivedValue::Elements(ends)) = r.derived(mid, "endFeature")
+                else {
+                    panic!("endFeature must be an element collection");
+                };
+                let end_ids: Vec<_> = ends.iter().map(|&e| r.element_id(e).to_string()).collect();
+                assert_eq!(
+                    end_ids, targets,
+                    "shared read and positional target disagree"
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn owning_membership_and_alias_of_same_feature_remove_each_other_before_pairing() {
+    check(
+        "package P { assoc Base { end feature x; alias ax for x; } assoc Mid specializes Base; }",
+        "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+        None,
+        false,
+    );
+}
+
+#[test]
+fn inherited_alias_redefinition_blocks_an_owning_membership() {
+    check(
+        "package P { assoc Values { end feature x; } assoc Redefiners specializes Values { end feature y redefines x; } assoc Base { public import Values::x; alias ay for Redefiners::y; } assoc Mid specializes Base; }",
+        "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+        None,
+        false,
+    );
+}
+
+#[test]
+fn same_membership_reached_through_a_diamond_preserves_its_slot() {
+    check(
+        "package P { assoc Base { end feature x; } assoc Left specializes Base; assoc Right specializes Base; assoc Mid specializes Left, Right; }",
+        "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+        Some("P::Base::x"),
+        false,
+    );
+}
+
+#[test]
+fn owned_alias_does_not_seed_owned_feature_redefinition_targets() {
+    check(
+        "package P { assoc Base { end feature x; } assoc Values specializes Base { end feature y redefines Base::x; } assoc Mid specializes Base { alias ay for Values::y; } }",
+        "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+        Some("P::Base::x"),
+        false,
+    );
+}
+
+#[test]
+fn imported_aliases_participate_in_filtering_before_slot_projection() {
+    for import in [
+        "public import Values::*;",
+        "public import Values::x; public import Values::ax;",
+        "public import all Values::*;",
+    ] {
+        check(
+            &format!(
+                "package P {{ assoc Values {{ end feature x; alias ax for x; }} assoc Base {{ {import} }} assoc Mid specializes Base; }}"
+            ),
+            "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+            None,
+            false,
+        );
+    }
+}
+
+#[test]
+fn private_aliases_do_not_block_but_protected_aliases_do() {
+    for (visibility, expected) in [("private", Some("P::Base::x")), ("protected", None)] {
+        check(
+            &format!(
+                "package P {{ assoc Base {{ end feature x; {visibility} alias ax for x; }} assoc Mid specializes Base; }}"
+            ),
+            "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+            expected,
+            false,
+        );
+    }
+}
+
+#[test]
+fn unresolved_visible_alias_qualifies_the_plan_without_inventing_positions() {
+    for (visibility, expected, incomplete) in [
+        ("public", None, true),
+        ("private", Some("P::Base::x"), false),
+    ] {
+        check(
+            &format!(
+                "package P {{ assoc Base {{ end feature x; {visibility} alias ax for Missing; }} assoc Mid specializes Base; }}"
+            ),
+            "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+            expected,
+            incomplete,
+        );
+    }
+}
+
+#[test]
+fn mutual_redefinition_cycle_removes_both_memberships() {
+    // Deliberately malformed semantic graph: prove both edges exist before
+    // checking cycle robustness, rather than testing unresolved spellings.
+    let library = "package P { assoc Root; assoc Base specializes Root { end feature x redefines Base::y; end feature y redefines Base::x; } assoc Mid specializes Base; }";
+    let mut model = Model::new();
+    model.add_library_source("aliases.kerml", library);
+    let mut r = ResolvedModel::build(&model);
+    let x = r.resolve_qualified("P::Base::x").unwrap();
+    let y = r.resolve_qualified("P::Base::y").unwrap();
+    for (source, target) in [(x, y), (y, x)] {
+        let edge = r
+            .owned_relationships(source)
+            .into_iter()
+            .find(|&edge| r.element_type(edge) == "Redefinition")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(edge)["redefinedFeature"]["@id"],
+            r.element_id(target).to_string()
+        );
+    }
+    check(
+        library,
+        "package U { assoc Leaf specializes P::Mid { end feature slot; } }",
+        None,
+        false,
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/positional_members.rs b/crates/sysmlv2-parser/tests/positional_members.rs
new file mode 100644
index 0000000..7c24c2f
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/positional_members.rs
@@ -0,0 +1,190 @@
+//! The pairing a redefining feature's body inherits members through
+//! (`positional_redefinition_targets`, read off one feature's heritage)
+//! agrees with the implied `Redefinition` relationships the model
+//! materializes, for every declared parameter and end of the library and
+//! the corpus: each side's targets are the other's, or redefined through
+//! them (the planner drops an edge another path already reaches — an
+//! explicit `:>>` of the same feature, a result inherited through a
+//! redefined one). An expression's parameters, which pair with the
+//! function it invokes rather than with a written general, stay out; so
+//! do the library features the planner alone pairs, through bases the
+//! heritage does not read: an accept's payload and receiver, some
+//! connection usages' binary-link ends, and succession ends. Binary
+//! Connection/Interface definitions' owned ends now agree with lookup.
+//! The planner also counts a membership a general imports as one of its
+//! slots, which the heritage reading does not; no corpus model exercises
+//! that, so a user-model disagreement there would be the expected one.
+use std::collections::{BTreeSet, HashSet};
+
+use sysmlv2_parser::json::{ElementRef, Reference, ResolvedModel};
+use sysmlv2_parser::model::Model;
+
+/// Implied targets only the planner pairs — library features reached
+/// through bases the heritage does not read — measured over the library
+/// and the corpus.
+// 81 accept payloads + 29 accept receivers + 4 connection-usage ends.
+// Binary definition ancestry removes 70 former exceptions: 68 implied
+// targets now agree directly, and two Causation targets now resolve
+// explicitly, making their former implied edges redundant.
+const TOLERATED_LIBRARY_ONLY: usize = 114;
+// Corrected succession specialization adds these end pairings. Keep them
+// separate so their addition cannot hide a change in the older families.
+const SUCCESSION_LIBRARY_ONLY: usize = 782;
+
+fn redefinition_targets(
+    r: &mut ResolvedModel,
+    feature: ElementRef,
+    implied: bool,
+) -> Vec<ElementRef> {
+    let mut out = r.positional_redefinition_targets(feature);
+    let relationships: Vec<ElementRef> = if implied {
+        r.implied_relationships(feature)
+    } else {
+        r.owned_relationships(feature)
+    };
+    for relationship in relationships {
+        if r.element_type(relationship) != "Redefinition" {
+            continue;
+        }
+        for target in r.relationship_ends(relationship).1 {
+            if let Reference::Element(target) = target {
+                out.push(target);
+            }
+        }
+    }
+    out
+}
+
+/// Everything `start` reaches through written, positional and implied
+/// redefinitions.
+fn closure(r: &mut ResolvedModel, start: &BTreeSet<ElementRef>) -> HashSet<ElementRef> {
+    let mut seen: HashSet<ElementRef> = start.iter().copied().collect();
+    let mut stack: Vec<ElementRef> = start.iter().copied().collect();
+    while let Some(feature) = stack.pop() {
+        for implied in [false, true] {
+            for target in redefinition_targets(r, feature, implied) {
+                if seen.insert(target) {
+                    stack.push(target);
+                }
+            }
+        }
+    }
+    seen
+}
+
+#[test]
+fn corpus_positional_targets_agree_with_the_implied_redefinitions() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .expect("library");
+    for f in sysmlv2_testkit::user_files() {
+        let src = std::fs::read_to_string(&f).unwrap();
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
+    }
+    let mut r = ResolvedModel::build(&model);
+    let mut checked = 0;
+    let mut tolerated = 0;
+    let mut succession_only = 0;
+    let mut differ = Vec::new();
+    for feature in r.elements().collect::<Vec<_>>() {
+        let properties = r.element_properties(feature);
+        let is_end = properties.get("isEnd").and_then(|v| v.as_bool()) == Some(true);
+        if !(is_end || r.is_parameter(feature)) {
+            continue;
+        }
+        let Some(owner) = r.owner(feature) else {
+            continue;
+        };
+        if r.inheritance_incomplete(owner, true) || r.element_type(owner).ends_with("Expression") {
+            continue;
+        }
+        let heritage: BTreeSet<_> = r
+            .positional_redefinition_targets(feature)
+            .into_iter()
+            .collect();
+        let mut implied = BTreeSet::new();
+        for relationship in r.implied_relationships(feature) {
+            if r.element_type(relationship) != "Redefinition" {
+                continue;
+            }
+            for target in r.relationship_ends(relationship).1 {
+                if let Reference::Element(target) = target {
+                    implied.insert(target);
+                }
+            }
+        }
+        if heritage.is_empty() && implied.is_empty() {
+            continue;
+        }
+        checked += 1;
+        let explicit: BTreeSet<_> = redefinition_targets(&mut r, feature, false)
+            .into_iter()
+            .collect();
+        let from_heritage = closure(&mut r, &heritage.union(&explicit).copied().collect());
+        let from_implied = closure(&mut r, &implied.union(&explicit).copied().collect());
+        let heritage_only: Vec<_> = heritage
+            .iter()
+            .filter(|t| !from_implied.contains(t))
+            .copied()
+            .collect();
+        let (library_only, implied_only): (Vec<_>, Vec<_>) = implied
+            .iter()
+            .filter(|t| !from_heritage.contains(t))
+            .copied()
+            .partition(|&t| r.is_library_element(t));
+        tolerated += library_only.len();
+        if matches!(r.element_type(owner), "Succession" | "SuccessionAsUsage") {
+            succession_only += library_only
+                .iter()
+                .filter(|&&target| {
+                    matches!(
+                        r.element_qualified_name(target).as_deref(),
+                        Some(
+                            "Occurrences::happensBeforeLinks::earlierOccurrence"
+                                | "Occurrences::happensBeforeLinks::laterOccurrence"
+                        )
+                    )
+                })
+                .count();
+        }
+        if !heritage_only.is_empty() || !implied_only.is_empty() {
+            let name = r.element_qualified_name(feature).unwrap_or_default();
+            let spell = |r: &mut ResolvedModel, set: &[ElementRef]| {
+                set.iter()
+                    .map(|&t| r.element_qualified_name(t).unwrap_or_default())
+                    .collect::<Vec<_>>()
+            };
+            let (h, i) = (spell(&mut r, &heritage_only), spell(&mut r, &implied_only));
+            differ.push(format!(
+                "{} {name}: heritage only {h:?}, implied only {i:?}",
+                r.element_type(feature)
+            ));
+        }
+    }
+    eprintln!(
+        "checked {checked} positional features, tolerated {tolerated} library-only implied targets"
+    );
+    assert!(checked > 1500, "only {checked} positional features");
+    assert!(
+        differ.is_empty(),
+        "{} differ:\n{}",
+        differ.len(),
+        differ.join("\n")
+    );
+    // The library pairings the planner alone makes, pinned so that a
+    // heritage reading that stops making ones it does make is seen, and a
+    // planner that stops making one of these is too.
+    assert_eq!(
+        tolerated - succession_only,
+        TOLERATED_LIBRARY_ONLY,
+        "library-only implied targets"
+    );
+    assert_eq!(
+        succession_only, SUCCESSION_LIBRARY_ONLY,
+        "succession library-only implied targets"
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/positional_redefinitions.rs b/crates/sysmlv2-parser/tests/positional_redefinitions.rs
new file mode 100644
index 0000000..f6879a6
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/positional_redefinitions.rs
@@ -0,0 +1,654 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::json::{ClosurePolicy, Derived, DerivedValue, ElementRef, ResolvedModel};
+use sysmlv2_parser::model::Model;
+
+fn build(source: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    model.add_source("positions.kerml", source);
+    assert!(
+        !model.has_errors(),
+        "{:?}",
+        model
+            .units()
+            .iter()
+            .flat_map(|u| &u.diagnostics)
+            .collect::<Vec<_>>()
+    );
+    ResolvedModel::build(&model)
+}
+
+fn elements(r: &mut ResolvedModel, e: ElementRef, property: &str) -> Vec<ElementRef> {
+    match r.derived(e, property) {
+        Derived::Value(DerivedValue::Elements(values)) => values,
+        other => panic!("{property}: {other:?}"),
+    }
+}
+
+fn implied_targets(r: &mut ResolvedModel, name: &str) -> Vec<String> {
+    let e = r.resolve_qualified(name).unwrap();
+    r.implied_relationships(e)
+        .into_iter()
+        .filter(|&edge| r.element_type(edge) == "Redefinition")
+        .collect::<Vec<_>>()
+        .into_iter()
+        .map(|edge| {
+            r.property(edge, "redefinedFeature").unwrap()["@id"]
+                .as_str()
+                .unwrap()
+                .to_owned()
+        })
+        .collect()
+}
+
+fn id(r: &mut ResolvedModel, name: &str) -> String {
+    let e = r.resolve_qualified(name).unwrap();
+    r.element_id(e).to_string()
+}
+
+#[test]
+fn ends_match_positions_not_names_and_preserve_compact_storage() {
+    let mut r = build(
+        "package P {
+        assoc Base { end feature a; end feature b; }
+        assoc Sub specializes Base { end feature b; end feature a; }
+    }",
+    );
+    let base_a = id(&mut r, "P::Base::a");
+    let base_b = id(&mut r, "P::Base::b");
+    let sub = r.resolve_qualified("P::Sub").unwrap();
+    let owned_before = r.owned_relationships(sub);
+    assert_eq!(implied_targets(&mut r, "P::Sub::b"), [base_a]);
+    assert_eq!(implied_targets(&mut r, "P::Sub::a"), [base_b]);
+    assert_eq!(r.owned_relationships(sub), owned_before);
+    assert_eq!(r.inherited_memberships(sub, false).len(), 2);
+    assert_eq!(r.inherited_memberships(sub, true).len(), 0);
+    assert_eq!(r.inherited_memberships(sub, false).len(), 2);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    assert_eq!(elements(&mut r, sub, "endFeature").len(), 2);
+    let mut model = Model::new();
+    model.add_source(
+        "positions.kerml",
+        "package P { assoc A { end feature a; } assoc B specializes A { end feature b; } }",
+    );
+    let mut exported = ResolvedModel::build(&model);
+    let full =
+        sysmlv2_parser::full::resolved_to_full_json(&mut exported, &model, Default::default())
+            .unwrap();
+    assert!(
+        full.as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Redefinition" && e["isImplied"] == true)
+    );
+    for e in full.as_array().unwrap() {
+        if e["isImplied"] == true {
+            assert_eq!(e["isImpliedIncluded"], true);
+        }
+    }
+}
+
+#[test]
+fn parameters_and_results_use_effective_slots() {
+    let mut r = build(
+        "package P {
+        function Base { in x; return result; }
+        function Mid specializes Base;
+        function Sub specializes Mid { in y; return answer; }
+        function Direct specializes Base { in z; return value; }
+    }",
+    );
+    let result = id(&mut r, "P::Base::result");
+    let x = id(&mut r, "P::Base::x");
+    // `Mid` inherits `x` after its (absent) own parameters, so `Sub`'s
+    // first parameter pairs with it, as `Sub`'s result pairs with the
+    // result `Mid` inherits.
+    assert_eq!(
+        implied_targets(&mut r, "P::Sub::y").as_slice(),
+        std::slice::from_ref(&x)
+    );
+    assert_eq!(
+        implied_targets(&mut r, "P::Sub::answer").as_slice(),
+        std::slice::from_ref(&result)
+    );
+    assert_eq!(
+        implied_targets(&mut r, "P::Direct::z").as_slice(),
+        std::slice::from_ref(&x)
+    );
+    assert_eq!(implied_targets(&mut r, "P::Direct::value"), [result]);
+}
+
+#[test]
+fn inherited_anonymous_return_is_redefined_by_identity() {
+    let mut r = build(
+        "package P {
+        class Value; function Base { return : Value; }
+        function Mid specializes Base;
+        function Sub specializes Mid { return answer; }
+    }",
+    );
+    let base = r.resolve_qualified("P::Base").unwrap();
+    let owned = elements(&mut r, base, "ownedFeature");
+    assert_eq!(owned.len(), 1);
+    let expected = r.element_id(owned[0]).to_string();
+    let mid = r.resolve_qualified("P::Mid").unwrap();
+    assert_eq!(r.inherited_memberships(mid, true).len(), 1);
+    assert_eq!(implied_targets(&mut r, "P::Sub::answer"), [expected]);
+}
+
+#[test]
+fn effective_end_order_follows_direct_supertype_order() {
+    let mut r = build(
+        "package P {
+        assoc First { end feature a; }
+        assoc Second { end feature b; }
+        assoc Mid specializes Second, First;
+        assoc Sub specializes Mid { end feature x; end feature y; }
+    }",
+    );
+    let a = id(&mut r, "P::First::a");
+    let b = id(&mut r, "P::Second::b");
+    assert_eq!(implied_targets(&mut r, "P::Sub::x"), [b]);
+    assert_eq!(implied_targets(&mut r, "P::Sub::y"), [a]);
+}
+
+#[test]
+fn cycles_do_not_invent_positional_targets() {
+    let mut r = build(
+        "package P {
+        assoc A specializes B { end feature a; }
+        assoc B specializes A { end feature b; }
+    }",
+    );
+    assert!(implied_targets(&mut r, "P::A::a").is_empty());
+    assert!(implied_targets(&mut r, "P::B::b").is_empty());
+    let a = r.resolve_qualified("P::A").unwrap();
+    assert!(r.inheritance_incomplete(a, true));
+    assert!(!r.inheritance_walk_truncated(a, true));
+}
+
+#[test]
+fn standard_library_subjects_results_and_binary_ends_are_not_duplicated() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    model.add_source(
+        "roles.sysml",
+        "package P {
+        requirement def R { subject selected; }
+        requirement r : R;
+        part a; part b; connection c connect a to b;
+    }",
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let req = r.resolve_qualified("P::R").unwrap();
+    let params = elements(&mut r, req, "parameter");
+    assert_eq!(params.len(), 2);
+    let usage = r.resolve_qualified("P::r").unwrap();
+    assert_eq!(elements(&mut r, usage, "parameter").len(), 2);
+    let connection = r.resolve_qualified("P::c").unwrap();
+    assert_eq!(elements(&mut r, connection, "connectorEnd").len(), 2);
+    let expected = id(&mut r, "Requirements::RequirementCheck::subj");
+    assert_eq!(implied_targets(&mut r, "P::R::selected"), [expected]);
+    assert_eq!(
+        implied_targets(&mut r, "Requirements::RequirementConstraintCheck::result").len(),
+        1
+    );
+}
+
+#[test]
+fn effective_inherited_slots_group_public_before_protected() {
+    let mut r = build(
+        "package P {
+        assoc Base { protected end feature p; public end feature q; }
+        assoc Mid specializes Base;
+        assoc Sub specializes Mid { end feature x; end feature y; }
+    }",
+    );
+    let p = id(&mut r, "P::Base::p");
+    let q = id(&mut r, "P::Base::q");
+    assert_eq!(implied_targets(&mut r, "P::Sub::x"), [q]);
+    assert_eq!(implied_targets(&mut r, "P::Sub::y"), [p]);
+}
+
+#[test]
+fn private_base_end_has_a_position_but_is_not_inherited() {
+    let mut r = build(
+        "package P {
+        assoc Base { private end feature p; end feature q; }
+        assoc Sub specializes Base { end feature x; end feature y; }
+        assoc Mid specializes Base;
+        assoc Leaf specializes Mid { end feature z; }
+    }",
+    );
+    let q = id(&mut r, "P::Base::q");
+    assert_eq!(implied_targets(&mut r, "P::Sub::x").len(), 1);
+    assert_eq!(
+        implied_targets(&mut r, "P::Sub::y").as_slice(),
+        std::slice::from_ref(&q)
+    );
+    assert_eq!(implied_targets(&mut r, "P::Leaf::z"), [q]);
+}
+
+#[test]
+fn prepared_library_and_query_order_preserve_positional_relationships() {
+    let library = "library package L { assoc Base { end feature a; end feature b; } }";
+    let source = "package P { assoc Sub specializes L::Base { end feature x; end feature y; } }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", library);
+    let prepared = base.prepare_library().unwrap();
+    let mut snapshots = Vec::new();
+    for use_prepared in [false, true] {
+        for materialize_first in [false, true] {
+            let mut model = Model::new();
+            if use_prepared {
+                prepared.clone().install(&mut model).unwrap();
+            } else {
+                model.add_library_source("lib.kerml", library);
+            }
+            model.add_source("p.kerml", source);
+            let mut r = ResolvedModel::build(&model);
+            let sub = r.resolve_qualified("P::Sub").unwrap();
+            if materialize_first {
+                r.implied_relationships(sub);
+            }
+            assert_eq!(r.inherited_memberships(sub, false).len(), 2);
+            assert!(r.inherited_memberships(sub, true).is_empty());
+            let x = r.resolve_qualified("P::Sub::x").unwrap();
+            let rels = r.implied_relationships(x);
+            let snapshot: Vec<_> = rels
+                .into_iter()
+                .map(|e| (r.element_id(e), r.element_properties(e)))
+                .collect();
+            snapshots.push(snapshot);
+        }
+    }
+    assert!(snapshots.windows(2).all(|w| w[0] == w[1]));
+}
+
+#[test]
+fn unresolved_or_imported_slot_sequences_are_reported_incomplete() {
+    let mut r = build(
+        "package P {
+        assoc Unknown specializes Missing { end feature a; }
+        assoc Base { end feature x; }
+        assoc Nested { public import Base::x; }
+        assoc Imported { public import Nested::*; }
+        assoc Sub specializes Imported { end feature b; }
+    }",
+    );
+    for (owner, feature) in [("P::Unknown", "P::Unknown::a"), ("P::Sub", "P::Sub::b")] {
+        assert!(implied_targets(&mut r, feature).is_empty());
+        let owner = r.resolve_qualified(owner).unwrap();
+        assert!(r.inheritance_incomplete(owner, true));
+        assert!(!r.inheritance_walk_truncated(owner, true));
+    }
+}
+
+#[test]
+fn mixed_depth_inheritance_and_positional_targets_share_order() {
+    let mut r = build(
+        "package P {
+        assoc A { end feature a; }
+        assoc B specializes A;
+        assoc C { end feature c; }
+        assoc D specializes B, C;
+        assoc E specializes D { end feature x; end feature y; }
+    }",
+    );
+    let a = r.resolve_qualified("P::A::a").unwrap();
+    let c = r.resolve_qualified("P::C::c").unwrap();
+    let d = r.resolve_qualified("P::D").unwrap();
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    assert_eq!(elements(&mut r, d, "endFeature"), [a, c]);
+    let ai = r.element_id(a).to_string();
+    let ci = r.element_id(c).to_string();
+    assert_eq!(implied_targets(&mut r, "P::E::x"), [ai]);
+    assert_eq!(implied_targets(&mut r, "P::E::y"), [ci]);
+}
+
+#[test]
+fn intermediate_owned_redefinition_removal_survives_further_inheritance() {
+    let mut r = build(
+        "package P {
+        class A { feature x; }
+        class B specializes A { feature y redefines A::x; }
+        class C specializes B { feature z redefines A::x; }
+        class D specializes C;
+    }",
+    );
+    let z = r.resolve_qualified("P::C::z").unwrap();
+    let d = r.resolve_qualified("P::D").unwrap();
+    for implied in [false, true] {
+        let members = r.inherited_memberships(d, implied);
+        let features: Vec<_> = members
+            .into_iter()
+            .filter_map(|m| r.membership_member(m))
+            .collect();
+        assert_eq!(features, [z]);
+    }
+}
+
+#[test]
+fn every_direct_base_contributes_and_unrelated_explicit_redefinition_does_not_exempt_ends() {
+    let mut r = build(
+        "package P {
+        assoc A { end feature a; end feature extra; }
+        assoc B { end feature b; }
+        assoc C specializes A, B { end feature x redefines A::extra; }
+    }",
+    );
+    let a = id(&mut r, "P::A::a");
+    let b = id(&mut r, "P::B::b");
+    assert_eq!(implied_targets(&mut r, "P::C::x"), [a, b]);
+}
+
+#[test]
+fn identity_overrides_preserve_positional_edges_before_and_after_materialization() {
+    for materialize_first in [false, true] {
+        let mut r = build(
+            "package P { assoc A { end feature a; } assoc B specializes A { end feature b; } }",
+        );
+        let a = r.resolve_qualified("P::A::a").unwrap();
+        let old_id = r.element_id(a);
+        if materialize_first {
+            implied_targets(&mut r, "P::B::b");
+        }
+        let new_id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"positional target override");
+        r.override_ids(&std::collections::HashMap::from([(old_id, new_id)]));
+        assert_eq!(implied_targets(&mut r, "P::B::b"), [new_id.to_string()]);
+        let b = r.resolve_qualified("P::B::b").unwrap();
+        assert!(r.conforms_with_implied(b, a));
+    }
+}
+
+#[test]
+fn semantic_incompleteness_does_not_masquerade_as_a_depth_cut() {
+    let mut model = Model::new();
+    model.add_source("cycle.kerml", "package P { assoc A specializes B { end feature a; } assoc B specializes A { end feature b; } }");
+    let mut r = ResolvedModel::build(&model);
+    let a = r.resolve_qualified("P::A").unwrap();
+    assert!(r.inheritance_incomplete(a, true));
+    assert!(!r.inheritance_walk_truncated(a, true));
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    assert_eq!(
+        r.derived_exact(a, "endFeature"),
+        Err(sysmlv2_parser::json::PropertyError::Approximate)
+    );
+    assert!(r.to_full_json_strict().is_err());
+    let policy = sysmlv2_parser::full::EmissionPolicy {
+        closures: ClosurePolicy::Closure {
+            include_implied: true,
+        },
+        ..Default::default()
+    };
+    assert!(sysmlv2_parser::full::resolved_to_full_json(&mut r, &model, policy).is_ok());
+}
+
+#[test]
+fn imported_feature_slots_enter_through_inheritance_not_direct_imports() {
+    for import in ["public import A::a;", "public import A::*;"] {
+        let mut r = build(&format!(
+            "package P {{
+            assoc A {{ end feature a; }}
+            assoc Base {{ {import} }}
+            assoc Child specializes Base {{ end feature x; }}
+            assoc Grand specializes Child {{ end feature slotOne; end feature slotTwo; }}
+        }}"
+        ));
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let base = r.resolve_qualified("P::Base").unwrap();
+        let child = r.resolve_qualified("P::Child").unwrap();
+        let a = r.resolve_qualified("P::A::a").unwrap();
+        let x = r.resolve_qualified("P::Child::x").unwrap();
+        assert!(elements(&mut r, base, "endFeature").is_empty());
+        assert_eq!(elements(&mut r, child, "endFeature"), [x, a]);
+        assert!(implied_targets(&mut r, "P::Child::x").is_empty());
+        let xi = r.element_id(x).to_string();
+        let ai = r.element_id(a).to_string();
+        assert_eq!(implied_targets(&mut r, "P::Grand::slotOne"), [xi]);
+        assert_eq!(implied_targets(&mut r, "P::Grand::slotTwo"), [ai]);
+        assert!(!r.inheritance_incomplete(child, true));
+    }
+}
+
+#[test]
+fn imported_aliases_and_package_owned_features_do_not_create_slots() {
+    let mut r = build(
+        "package P {
+        assoc A { end feature a; alias renamed for a; }
+        package N { feature p; }
+        assoc Base { public import A::renamed; public import N::p; }
+        assoc Child specializes Base;
+        assoc Grand specializes Child { end feature x; }
+    }",
+    );
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let child = r.resolve_qualified("P::Child").unwrap();
+    assert_eq!(r.inherited_memberships(child, true).len(), 2);
+    assert!(elements(&mut r, child, "feature").is_empty());
+    assert!(implied_targets(&mut r, "P::Grand::x").is_empty());
+    assert!(!r.inheritance_incomplete(child, true));
+}
+
+#[test]
+fn import_admission_controls_visibility_and_positional_order() {
+    let mut r = build("package P {
+        assoc A { private end feature hidden; end feature a; }
+        assoc Base {
+            protected end feature p;
+            protected import A::a;
+            public import all A::hidden;
+            public end feature q;
+        }
+        assoc Child specializes Base;
+        assoc Grand specializes Child { end feature slotOne; end feature slotTwo; end feature slotThree; end feature slotFour; }
+    }");
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let child = r.resolve_qualified("P::Child").unwrap();
+    let expected: Vec<_> = ["P::Base::q", "P::A::hidden", "P::Base::p", "P::A::a"]
+        .into_iter()
+        .map(|name| r.resolve_qualified(name).unwrap())
+        .collect();
+    assert_eq!(elements(&mut r, child, "endFeature"), expected);
+    for (name, target) in ["slotOne", "slotTwo", "slotThree", "slotFour"]
+        .into_iter()
+        .zip(expected)
+    {
+        let target = r.element_id(target).to_string();
+        assert_eq!(
+            implied_targets(&mut r, &format!("P::Grand::{name}")),
+            [target]
+        );
+    }
+}
+
+#[test]
+fn imported_memberships_enter_effective_results_and_parameters() {
+    let mut r = build(
+        "package P {
+        function F { in a; return r; alias namedResult for r; }
+        function Base { public import F::r; public import F::a; }
+        function Child specializes Base;
+        function Grand specializes Child { in x; return answer; }
+        function AliasBase { public import F::namedResult; }
+        function AliasChild specializes AliasBase;
+        function AliasGrand specializes AliasChild { return answer; }
+    }",
+    );
+    let result = id(&mut r, "P::F::r");
+    let a = id(&mut r, "P::F::a");
+    assert_eq!(implied_targets(&mut r, "P::Grand::answer"), [result]);
+    assert_eq!(implied_targets(&mut r, "P::Grand::x"), [a]);
+    assert!(implied_targets(&mut r, "P::AliasGrand::answer").is_empty());
+}
+
+#[test]
+fn imported_slots_agree_for_fresh_prepared_and_serialized_prepared_libraries() {
+    use std::sync::Arc;
+    use sysmlv2_parser::prepared::PreparedLibrary;
+    let library = "standard library package P { assoc A { end feature a; } assoc Base { public import A::a; } assoc Child specializes Base; }";
+    let user = "assoc Grand specializes P::Child { end feature slotOne; }";
+    let mut base = Model::new();
+    base.add_library_source("imports.kerml", library);
+    let prepared = base.prepare_library().unwrap();
+    let serialized =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(11).unwrap(), 11).unwrap());
+    let mut targets = Vec::new();
+    for mode in 0..3 {
+        let mut model = Model::new();
+        if mode == 0 {
+            model.add_library_source("imports.kerml", library);
+        } else if mode == 1 {
+            Arc::clone(&prepared).install(&mut model).unwrap();
+        } else {
+            Arc::clone(&serialized).install(&mut model).unwrap();
+        }
+        model.add_source("user.kerml", user);
+        let mut r = ResolvedModel::build(&model);
+        let child = r.resolve_qualified("P::Child").unwrap();
+        assert_eq!(r.inherited_memberships(child, true).len(), 1);
+        let expected = id(&mut r, "P::A::a");
+        let actual = implied_targets(&mut r, "Grand::slotOne");
+        assert_eq!(actual, [expected]);
+        targets.push(actual);
+    }
+    assert!(targets.windows(2).all(|pair| pair[0] == pair[1]));
+}
+
+#[test]
+fn visibility_specific_import_slots_retain_same_names_and_exclude_private_paths() {
+    let mut r = build(
+        "package P {
+        assoc A { end feature x; }
+        assoc B { end feature x; }
+        assoc C { end feature x; }
+        assoc Base { protected import B::x; private import C::x; public import A::x; }
+        assoc Child specializes Base;
+        assoc Grand specializes Child { end feature slotOne; end feature slotTwo; }
+    }",
+    );
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let a = r.resolve_qualified("P::A::x").unwrap();
+    let b = r.resolve_qualified("P::B::x").unwrap();
+    let child = r.resolve_qualified("P::Child").unwrap();
+    assert_eq!(elements(&mut r, child, "endFeature"), [a, b]);
+    let ai = r.element_id(a).to_string();
+    let bi = r.element_id(b).to_string();
+    assert_eq!(implied_targets(&mut r, "P::Grand::slotOne"), [ai]);
+    assert_eq!(implied_targets(&mut r, "P::Grand::slotTwo"), [bi]);
+}
+
+#[test]
+fn unresolved_import_provider_heritage_does_not_supply_partial_positions() {
+    let mut r = build(
+        "package P {
+        assoc Provider specializes Unknown { end feature a; }
+        assoc Base { public import Provider::*; }
+        assoc Child specializes Base;
+        assoc Grand specializes Child { end feature slot; }
+    }",
+    );
+    let grand = r.resolve_qualified("P::Grand").unwrap();
+    assert!(implied_targets(&mut r, "P::Grand::slot").is_empty());
+    assert!(r.inheritance_incomplete(grand, true));
+}
+
+#[test]
+fn inheritance_preserves_alias_positions_among_owned_and_imported_memberships() {
+    let mut r = build(
+        "package P {
+        class Values { feature imported; class AliasTarget; }
+        class Base {
+            feature a;
+            alias publicAlias for Values::AliasTarget;
+            public import Values::imported;
+            protected feature b;
+            protected alias protectedAlias for Values::AliasTarget;
+        }
+        class Child specializes Base;
+    }",
+    );
+    let child = r.resolve_qualified("P::Child").unwrap();
+    let memberships = r.inherited_memberships(child, false);
+    let names: Vec<_> = memberships
+        .into_iter()
+        .map(|m| r.membership_member_name(m).unwrap())
+        .collect();
+    assert_eq!(
+        names,
+        ["a", "publicAlias", "imported", "b", "protectedAlias"]
+    );
+}
+
+#[test]
+fn library_flow_and_succession_ends_redefine_their_actual_bases() {
+    let mut model = Model::new();
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    model.add_source(
+        "flows.sysml",
+        r#"package P {
+        port def Out { out attribute v : ScalarValues::Real; }
+        part def Box { port o : Out; port i : ~Out; }
+        part def System {
+            part a : Box; part b : Box;
+            flow from a.o.v to b.i.v;
+        }
+        action def Steps { action a; action b; first a then b; }
+    }"#,
+    );
+    assert!(!model.has_errors());
+    let mut r = ResolvedModel::build(&model);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let connectors: Vec<_> = r
+        .user_elements()
+        .filter(|&e| matches!(r.element_type(e), "FlowUsage" | "SuccessionAsUsage"))
+        .collect();
+    assert_eq!(connectors.len(), 2);
+    for connector in connectors {
+        let ends = elements(&mut r, connector, "ownedEndFeature");
+        assert_eq!(ends.len(), 2);
+        assert_eq!(elements(&mut r, connector, "connectorEnd"), ends);
+        for end in ends {
+            assert!(
+                r.implied_relationships(end)
+                    .into_iter()
+                    .any(|edge| r.element_type(edge) == "Redefinition"),
+                "{} has no implied end redefinition",
+                r.element_type(connector)
+            );
+        }
+        assert!(!r.inheritance_incomplete(connector, true));
+    }
+    for name in [
+        "Flows::MessageAction",
+        "Flows::messages",
+        "Transfers::flowTransfers",
+    ] {
+        let base = r.resolve_qualified(name).unwrap();
+        assert!(!r.inheritance_incomplete(base, true), "cyclic base: {name}");
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/qualified_positional_slots.rs b/crates/sysmlv2-parser/tests/qualified_positional_slots.rs
new file mode 100644
index 0000000..2507e63
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/qualified_positional_slots.rs
@@ -0,0 +1,218 @@
+//! A qualified redefinition removes only the selected inherited slot.
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{Reference, ResolvedModel},
+    model::{GraphFormat, Model},
+    prepared::PreparedLibrary,
+};
+
+fn assert_slots(mut r: ResolvedModel, signature_first: bool, remaining: &str) {
+    let c = r.resolve_qualified("P::C").unwrap();
+    let cr = r.resolve_qualified("P::C::r").unwrap();
+    let bq = r.resolve_qualified(remaining).unwrap();
+    let d = r.resolve_qualified("D").unwrap();
+    let dx = r.resolve_qualified("D::x").unwrap();
+    let dy = r.resolve_qualified("D::y").unwrap();
+    if signature_first {
+        assert_eq!(
+            r.callable_parameters(c)
+                .unwrap()
+                .iter()
+                .map(|p| p.element)
+                .collect::<Vec<_>>(),
+            [cr, bq]
+        );
+    }
+    assert_eq!(r.positional_redefinition_targets(dx), [cr]);
+    assert_eq!(r.positional_redefinition_targets(dy), [bq]);
+    assert_eq!(
+        r.callable_parameters(c)
+            .unwrap()
+            .iter()
+            .map(|p| p.element)
+            .collect::<Vec<_>>(),
+        [cr, bq]
+    );
+    assert_eq!(
+        r.callable_parameters(d)
+            .unwrap()
+            .iter()
+            .map(|p| p.element)
+            .collect::<Vec<_>>(),
+        [dx, dy]
+    );
+    let implied = r.implied_relationships(dy);
+    assert!(
+        implied
+            .into_iter()
+            .any(|rel| r.element_type(rel) == "Redefinition"
+                && r.relationship_ends(rel).1.contains(&Reference::Element(bq)))
+    );
+    assert_eq!(r.positional_redefinition_targets(dy), [bq]);
+}
+
+#[test]
+fn qualified_redefinitions_keep_unselected_same_named_slots_across_order_and_replay() {
+    for generals in ["A, B", "B, A"] {
+        for selected in [
+            "A::q",
+            "$::P::A::q",
+            "Chosen::q",
+            "A::shortQ",
+            "q",
+            "shortQ",
+        ] {
+            for forward in [false, true] {
+                let definitions = if forward {
+                    "calc def B { in b; in q; } calc def A { in a; in <shortQ> q; } alias Chosen for A;"
+                } else {
+                    "calc def A { in a; in <shortQ> q; } calc def B { in b; in q; } alias Chosen for A;"
+                };
+                let child = format!("calc def C :> {generals} {{ in r :>> {selected}; }}");
+                let source = if forward {
+                    format!("package P {{ {child} {definitions} }}")
+                } else {
+                    format!("package P {{ {definitions} {child} }}")
+                };
+                let mut base = Model::new();
+                let unit = base.add_library_source("slots.sysml", &source);
+                assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+                let prepared = base.prepare_library().unwrap();
+                let decoded = Arc::new(
+                    PreparedLibrary::from_bytes(&prepared.to_bytes(219).unwrap(), 219).unwrap(),
+                );
+                for mode in 0..3 {
+                    for signature_first in [false, true] {
+                        let mut model = Model::new();
+                        if mode == 0 {
+                            model.add_library_source("slots.sysml", &source);
+                        } else {
+                            Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                                .install(&mut model)
+                                .unwrap();
+                        }
+                        let unit =
+                            model.add_source("user.sysml", "calc def D :> P::C { in x; in y; }");
+                        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+                        assert_slots(
+                            ResolvedModel::build(&model),
+                            signature_first,
+                            if selected == "q" && generals == "B, A" {
+                                "P::A::q"
+                            } else {
+                                "P::B::q"
+                            },
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn qualified_redefinition_imported_qualifier_keeps_unselected_slot() {
+    for generals in ["A, B", "B, A"] {
+        let mut model = Model::new();
+        let source = format!(
+            "package Types {{ calc def A {{ in a; in q; }} }} package P {{ private import Types::A; calc def B {{ in b; in q; }} calc def C :> {generals} {{ in r :>> A::q; }} }} calc def D :> P::C {{ in x; in y; }}"
+        );
+        let unit = model.add_source("imported.sysml", &source);
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        assert_slots(ResolvedModel::build(&model), false, "P::B::q");
+    }
+}
+
+#[test]
+fn an_unresolved_qualified_redefinition_does_not_hide_namesakes() {
+    let mut model = Model::new();
+    model.add_source("missing.sysml", "calc def A { in a; in q; } calc def B { in b; in q; } calc def C :> A, B { in r :>> Missing::q; } calc def D :> C { in x; in y; in z; }");
+    let mut r = ResolvedModel::build(&model);
+    for (path, target) in [("D::y", "A::q"), ("D::z", "B::q")] {
+        let slot = r.resolve_qualified(path).unwrap();
+        let target = r.resolve_qualified(target).unwrap();
+        assert_eq!(r.positional_redefinition_targets(slot), [target]);
+    }
+}
+
+#[test]
+fn cold_descendant_queries_preserve_header_selection_across_recorded_replay() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        for spelling in ["A::q", "q"] {
+            let source = format!(
+                "package P {{ calc def A {{ in a; in q; }} calc def B {{ in b; in q; }} calc def C :> A, B {{ in r :>> {spelling}; }} }}"
+            );
+            let mut base = Model::with_graph_format(format);
+            assert!(
+                base.add_library_source("cold-slots.sysml", &source)
+                    .diagnostics
+                    .is_empty()
+            );
+            base.record_library_cache();
+            let prepared = base.prepare_library().unwrap();
+            let decoded = Arc::new(
+                PreparedLibrary::from_bytes(&prepared.to_bytes(223).unwrap(), 223).unwrap(),
+            );
+            for mode in 0..3 {
+                for complete_root in [false, true] {
+                    for signature_first in [false, true] {
+                        let mut model = Model::with_graph_format(format);
+                        if mode == 0 {
+                            model.add_library_source("cold-slots.sysml", &source);
+                        } else {
+                            Arc::clone(if mode == 1 { &prepared } else { &decoded })
+                                .install(&mut model)
+                                .unwrap();
+                        }
+                        // Supplying an implied root can invalidate prepared lookup
+                        // evidence; test the resulting cold graph as well.
+                        let root = if complete_root {
+                            "package Calculations;"
+                        } else {
+                            ""
+                        };
+                        assert!(
+                            model
+                                .add_source(
+                                    "descendant.sysml",
+                                    &format!("{root} calc def D :> P::C {{ in x; in y; }}")
+                                )
+                                .diagnostics
+                                .is_empty()
+                        );
+                        let mut r = ResolvedModel::build(&model);
+                        let d = r.resolve_qualified("D").unwrap();
+                        // Capture these results before querying any general or
+                        // expected target, which would warm the relevant scopes.
+                        let first_signature =
+                            signature_first.then(|| r.callable_parameters(d).unwrap());
+                        let dy = r.resolve_qualified("D::y").unwrap();
+                        let first_targets = r.positional_redefinition_targets(dy);
+                        let remaining = r.resolve_qualified("P::B::q").unwrap();
+                        assert_eq!(
+                            first_targets,
+                            [remaining],
+                            "{format:?} {spelling} mode {mode} root {complete_root} signature {signature_first}"
+                        );
+                        let dx = r.resolve_qualified("D::x").unwrap();
+                        if let Some(signature) = first_signature {
+                            assert_eq!(
+                                signature.into_iter().map(|p| p.element).collect::<Vec<_>>(),
+                                [dx, dy]
+                            );
+                        }
+                        assert_eq!(
+                            r.callable_parameters(d)
+                                .unwrap()
+                                .into_iter()
+                                .map(|p| p.element)
+                                .collect::<Vec<_>>(),
+                            [dx, dy]
+                        );
+                        assert_eq!(r.positional_redefinition_targets(dy), first_targets);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/query.rs b/crates/sysmlv2-parser/tests/query.rs
index 2453c4f..c181ba3 100644
--- a/crates/sysmlv2-parser/tests/query.rs
+++ b/crates/sysmlv2-parser/tests/query.rs
@@ -20,7 +20,7 @@ const DEMO: &str = "package Demo {
         part spare : SpareWheel;
         part engine : Engine;
     }
-    part car : Vehicle;
+    part car : Vehicle[1];
 }";
 
 fn resolved(src: &str) -> ResolvedModel {
@@ -284,7 +284,7 @@ fn istype_follows_semantic_metadata_annotation() {
             metadata def TaggedU :> Metaobjects::SemanticMetadata {
                 :>> baseType = pulses meta U;
             }
-            #TaggedU action blip;
+            #TaggedU action blip[1];
         }";
     // Annotated definition: Blink -> (semantic) Pulse.
     assert_eq!(
@@ -476,3 +476,60 @@ fn constructors_bind_inherited_fields() {
         Ok(Value::Integer(9))
     );
 }
+
+#[test]
+fn query_reflection_does_not_hijack_declared_functions() {
+    let src = "package P { part vehicle; calc def ownedMember { in x; return r = 99; } }";
+    assert_eq!(
+        query(src, "P::ownedMember(P::vehicle)"),
+        Ok(Value::Integer(99))
+    );
+    assert_eq!(
+        query(src, "ownedMember(P::vehicle)"),
+        Ok(Value::Sequence(vec![]))
+    );
+    assert!(matches!(
+        query(src, "Missing::ownedMember(P::vehicle)"),
+        Err(EvalError::Unsupported(_))
+    ));
+}
+
+#[test]
+fn unbound_redefined_collections_do_not_become_query_declarations() {
+    let source = "package P {
+        part def Motor { attribute mass = 0.55; }
+        part def Rack { part motors : Motor[4]; }
+        part rack : Rack[1] { part <slot> :>> motors; }
+        ref part unknown : Rack;
+    }";
+    for expression in [
+        "P::rack.slot.mass",
+        "P::rack.motors.mass",
+        "P::unknown.motors.mass",
+    ] {
+        assert_eq!(
+            query(source, expression),
+            Ok(Value::Indeterminate),
+            "{expression}"
+        );
+    }
+    assert_eq!(query(source, "size(P::rack.slot)"), Ok(Value::Integer(4)));
+}
+
+#[test]
+fn indexing_uncertain_chained_query_values_does_not_invent_positions() {
+    let source = "package P {
+        part def A {
+            attribute xs[4] ordered;
+            attribute flag[1];
+            attribute items[0..*] ordered = if flag ? xs else xs;
+        }
+        part def B { attribute items[1] = 99; }
+        part a : A[1]; part b : B[1];
+    }";
+    assert_eq!(
+        query(source, "(P::a, P::b).items#(2)"),
+        Ok(Value::Indeterminate)
+    );
+    assert_eq!(query(source, "P::b.items#(1)"), Ok(Value::Integer(99)));
+}
diff --git a/crates/sysmlv2-parser/tests/recorded_alias_paths.rs b/crates/sysmlv2-parser/tests/recorded_alias_paths.rs
new file mode 100644
index 0000000..56f49a7
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/recorded_alias_paths.rs
@@ -0,0 +1,173 @@
+//! Import-free alias paths retain Membership selection without losing provenance.
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+
+fn models(library: &str, user: &str) -> Vec<ResolvedModel> {
+    source_models(library, user)
+        .iter()
+        .map(ResolvedModel::build)
+        .collect()
+}
+
+fn source_models(library: &str, user: &str) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("lookup.kerml", library);
+    assert!(!base.has_errors());
+    base.record_library_cache();
+    let _ = ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(23).unwrap(), 23).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lookup.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            model.add_source("user.kerml", user);
+            assert!(!model.has_errors());
+            model
+        })
+        .collect()
+}
+
+#[test]
+fn qualified_alias_paths_retain_import_walks() {
+    for target in ["Exposed::x", "$::Exposed::x", "Intermediate::forwarded"] {
+        let library = format!(
+            "package Q {{ feature x; }}
+            package Exposed {{ public import Q::*; }}
+            package Intermediate {{ alias forwarded for Exposed::x; }}
+            class Base {{ alias ax for {target}; }}
+            class Child specializes Base;"
+        );
+        for mut r in models(&library, "feature useAlias references Child::ax;") {
+            let x = r.resolve_qualified("Q::x").unwrap();
+            assert_eq!(r.resolve_qualified("Child::ax"), Some(x));
+            let exposed = r.resolve_qualified("Exposed").unwrap();
+            let import = r
+                .owned_relationships(exposed)
+                .into_iter()
+                .find(|&e| r.element_type(e) == "NamespaceImport")
+                .unwrap();
+            let selected = r.resolve_qualified("useAlias").unwrap();
+            let relation = r
+                .owned_relationships(selected)
+                .into_iter()
+                .find(|&e| r.element_type(e) == "ReferenceSubsetting")
+                .unwrap();
+            assert_eq!(
+                r.element_properties(relation)["referencedFeature"]["@id"],
+                r.element_id(x).to_string()
+            );
+            let site = r
+                .reference_sites()
+                .iter()
+                .find(|site| site.owner == relation && site.kind == "referencedFeature")
+                .unwrap();
+            assert_eq!(
+                site.via_imports,
+                vec![(import, sysmlv2_parser::json::AccessMode::Public)]
+            );
+            assert!(r.unresolved_references().is_empty());
+        }
+    }
+}
+
+#[test]
+fn pure_alias_chains_keep_membership_suppression() {
+    for aliases in [
+        "feature x; alias ax for x; alias bx for ax;",
+        "feature <x> x; alias ax for x; alias bx for ax;",
+        "private feature x; alias ax for Base::x; alias bx for ax;",
+        "private feature x; alias ax for $::Base::x; alias bx for Base::ax;",
+    ] {
+        let library = format!("class Base {{ {aliases} }} class Child specializes Base;");
+        for mut r in models(&library, "feature useAlias references Child::bx;") {
+            for name in ["Child::ax", "Child::bx"] {
+                assert_eq!(r.resolve_qualified(name), None, "{name} in {aliases}");
+            }
+            let child = r.resolve_qualified("Child").unwrap();
+            assert!(r.inherited_memberships(child, false).is_empty());
+            let selected = r.resolve_qualified("useAlias").unwrap();
+            let relation = r
+                .owned_relationships(selected)
+                .into_iter()
+                .find(|&e| r.element_type(e) == "ReferenceSubsetting")
+                .unwrap();
+            assert_eq!(
+                r.element_properties(relation)["referencedFeature"]["@ref"],
+                "Child::bx"
+            );
+        }
+    }
+}
+
+#[test]
+fn unrelated_ancestor_imports_do_not_disqualify_local_aliases() {
+    let library = "package Unrelated { feature other; }
+        package P { private import Unrelated::*;
+            class Base { feature x; alias ax for x; alias bx for ax; }
+            class Child specializes Base;
+        }";
+    for mut r in models(library, "feature useAlias references P::Child::ax;") {
+        assert_eq!(r.resolve_qualified("P::Child::x"), None);
+        assert_eq!(r.resolve_qualified("P::Child::ax"), None);
+        assert_eq!(r.resolve_qualified("P::Child::bx"), None);
+    }
+}
+
+#[test]
+fn aliases_to_inherited_and_effective_bindings_remain_filtered() {
+    for member in ["", "feature redefines x;"] {
+        let library = format!(
+            "class A {{ feature x; }} class B specializes A {{ {member} }}
+            class Base {{ alias ax for B::x; alias bx for B::x; }}
+            class Child specializes Base;"
+        );
+        for mut r in models(&library, "feature useAlias references Child::ax;") {
+            assert!(r.resolve_qualified("B::x").is_some());
+            assert_eq!(r.resolve_qualified("Child::ax"), None);
+            assert_eq!(r.resolve_qualified("Child::bx"), None);
+        }
+    }
+}
+
+#[test]
+fn alias_certificates_use_filtered_multiple_inheritance() {
+    let library = "class A { feature x; }
+        class B specializes A { feature x redefines x; }
+        class Combined specializes A, B;
+        class Base { alias ax for Combined::x; alias bx for Combined::x; }
+        class Child specializes Base;";
+    for mut r in models(library, "feature useAlias references Child::ax;") {
+        let x = r.resolve_qualified("B::x").unwrap();
+        assert_eq!(r.resolve_qualified("Combined::x"), Some(x));
+        assert_eq!(r.resolve_qualified("Child::ax"), None);
+        assert_eq!(r.resolve_qualified("Child::bx"), None);
+    }
+}
+
+#[test]
+fn qualified_protected_alias_targets_keep_inherited_membership_filtering() {
+    let library = "class A { protected feature x; }
+        class Base specializes A { alias ax for A::x; alias bx for A::x; }
+        class Child specializes Base;";
+    for mut r in models(library, "feature useAlias references Child::ax;") {
+        assert!(r.resolve_qualified("Base::ax").is_some());
+        assert_eq!(r.resolve_qualified("Child::ax"), None);
+        assert_eq!(r.resolve_qualified("Child::bx"), None);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/recorded_lookup_effects.rs b/crates/sysmlv2-parser/tests/recorded_lookup_effects.rs
new file mode 100644
index 0000000..e52b234
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/recorded_lookup_effects.rs
@@ -0,0 +1,168 @@
+#![cfg(feature = "json")]
+use sysmlv2_parser::{json::ResolvedModel, model::Model};
+#[test]
+fn alias_identity_remains_fixed_when_its_target_is_excluded() {
+    let mut m = Model::new();
+    m.add_source(
+        "alias.kerml",
+        "class Base { feature x; alias ax for Child::x; }
+        class Child specializes Base { feature x subsets ax; }",
+    );
+    assert!(!m.has_errors());
+    let mut r = ResolvedModel::build(&m);
+    let x = r.resolve_qualified("Child::x").unwrap();
+    let base = r.resolve_qualified("Base").unwrap();
+    let alias = r
+        .owned_relationships(base)
+        .into_iter()
+        .find(|&e| {
+            r.element_properties(e)
+                .get("memberName")
+                .and_then(|v| v.as_str())
+                == Some("ax")
+        })
+        .unwrap();
+    assert_eq!(
+        r.element_properties(alias)["memberElement"]["@id"],
+        r.element_id(x).to_string()
+    );
+    let relation = r
+        .owned_relationships(x)
+        .into_iter()
+        .find(|&e| r.element_type(e) == "Subsetting")
+        .unwrap();
+    assert_eq!(
+        r.element_properties(relation)["subsettedFeature"]["@ref"],
+        "ax"
+    );
+    let unresolved = r.unresolved_references();
+    assert_eq!(unresolved.len(), 1);
+    assert_eq!(unresolved[0].owner, relation);
+    assert_eq!(unresolved[0].spelling, "ax");
+    assert_eq!(unresolved[0].unit, 0);
+    assert!(r.blocked_references().is_empty());
+}
+
+#[test]
+fn iterative_selection_preserves_deep_inheritance_after_preparation() {
+    let mut source = String::from("class T0 { feature x; } alias enable for T0;");
+    for i in 1..80 {
+        source += &format!(" class T{i} specializes T{};", i - 1);
+    }
+    let mut library = Model::new();
+    library.add_library_source("deep.kerml", &source);
+    let prepared = library.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(7).unwrap(), 7)
+            .unwrap(),
+    );
+    for mode in 0..3 {
+        let mut m = Model::new();
+        match mode {
+            0 => {
+                m.add_library_source("deep.kerml", &source);
+            }
+            1 => {
+                prepared.clone().install(&mut m).unwrap();
+            }
+            _ => {
+                decoded.clone().install(&mut m).unwrap();
+            }
+        }
+        m.add_source("use.kerml", "feature selected references T79::x;");
+        let mut r = ResolvedModel::build(&m);
+        let x = r.resolve_qualified("T0::x").unwrap();
+        assert_eq!(r.resolve_qualified("T79::x"), Some(x));
+        let selected = r.resolve_qualified("selected").unwrap();
+        let edge = r
+            .owned_relationships(selected)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "ReferenceSubsetting")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(edge)["referencedFeature"]["@id"],
+            r.element_id(x).to_string()
+        );
+    }
+}
+
+#[test]
+fn a_new_implicit_root_invalidates_prepared_absence_proofs() {
+    let source = "class Receiver; class Source { feature x; alias ax for x; }
+        class Child specializes Source;";
+    let mut library = Model::new();
+    library.add_library_source("library.kerml", source);
+    let prepared = library.prepare_library().unwrap();
+    let decoded = std::sync::Arc::new(
+        sysmlv2_parser::prepared::PreparedLibrary::from_bytes(&prepared.to_bytes(7).unwrap(), 7)
+            .unwrap(),
+    );
+    for mode in 0..3 {
+        let mut m = Model::new();
+        match mode {
+            0 => {
+                m.add_library_source("library.kerml", source);
+            }
+            1 => {
+                prepared.clone().install(&mut m).unwrap();
+            }
+            _ => {
+                decoded.clone().install(&mut m).unwrap();
+            }
+        }
+        m.add_source(
+            "root.kerml",
+            "package Occurrences { class Occurrence { feature token; } }
+            feature chosen references Receiver::token;",
+        );
+        let mut r = ResolvedModel::build(&m);
+        let token = r
+            .resolve_qualified("Occurrences::Occurrence::token")
+            .unwrap();
+        assert_eq!(r.resolve_qualified("Receiver::token"), Some(token));
+        let chosen = r.resolve_qualified("chosen").unwrap();
+        let edge = r
+            .owned_relationships(chosen)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "ReferenceSubsetting")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(edge)["referencedFeature"]["@id"],
+            r.element_id(token).to_string()
+        );
+    }
+}
+
+#[test]
+fn external_names_invalidate_prepared_recorded_projections() {
+    let mut library = Model::new();
+    library.add_library_source(
+        "external.kerml",
+        "class Source { feature x; alias ax for x; } class Child specializes Source;",
+    );
+    let prepared = library.prepare_library().unwrap();
+    let names = std::collections::HashMap::from([(
+        uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"external occurrence").to_string(),
+        vec!["Occurrences".to_owned(), "Occurrence".to_owned()],
+    )]);
+    let build = || {
+        let mut m = Model::new();
+        prepared.clone().install(&mut m).unwrap();
+        m.add_source("user.kerml", "feature user;");
+        ResolvedModel::build(&m)
+    };
+    let mut warm = build();
+    assert_eq!(warm.resolve_qualified("Child::x"), None);
+    warm.set_library_names(&names);
+    let mut cold = build();
+    cold.set_library_names(&names);
+    for name in ["Child::ax", "Child::x"] {
+        let actual = warm.resolve_qualified(name);
+        let expected = cold.resolve_qualified(name);
+        assert_eq!(actual, expected, "{name}");
+        assert!(
+            expected.is_some(),
+            "external base requires contextual fallback"
+        );
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/redefinition_direction.rs b/crates/sysmlv2-parser/tests/redefinition_direction.rs
new file mode 100644
index 0000000..50078e9
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/redefinition_direction.rs
@@ -0,0 +1,279 @@
+//! Direction validation and repair hints share context-aware identity proofs.
+#![cfg(feature = "json")]
+use std::{
+    collections::{BTreeSet, HashMap},
+    sync::Arc,
+};
+use sysmlv2_model::{
+    check, json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+const RULE: &str = "validateRedefinitionDirectionConformance";
+const ID: &str = "77777777-7777-4777-8777-777777777777";
+
+fn models(library: &str, users: &[(String, String)]) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    let u = base.add_library_source("directions.kerml", library);
+    assert!(u.diagnostics.is_empty(), "{:?}", u.diagnostics);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(51).unwrap(), 51).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("directions.kerml", library);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for (name, src) in users {
+                let u = m.add_source(name.clone(), src);
+                assert!(u.diagnostics.is_empty(), "{name}: {:?}", u.diagnostics);
+            }
+            let r = ResolvedModel::build(&m);
+            (m, r)
+        })
+        .collect()
+}
+fn user(src: &str) -> Vec<(String, String)> {
+    vec![("user.kerml".into(), src.into())]
+}
+fn direction_count(r: &mut ResolvedModel, m: &Model) -> usize {
+    check::validate_semantics_with(r, m)
+        .iter()
+        .filter(|(_, d)| d.code == Some(RULE))
+        .count()
+}
+fn allowed(target: usize, own: usize) -> bool {
+    target == 0 || (target == 3 && own != 0) || target == own
+}
+
+#[test]
+fn all_direction_pairs_distinguish_missing_from_inout() {
+    let dirs = ["", "in ", "out ", "inout "];
+    let library = dirs
+        .iter()
+        .enumerate()
+        .map(|(n, d)| format!("classifier B{n} {{{d}feature p;}}"))
+        .collect::<String>();
+    let mut users = Vec::new();
+    let mut expected = BTreeSet::new();
+    for target in 0..4 {
+        for (own, direction) in dirs.iter().enumerate() {
+            let name = format!("case-{target}-{own}.kerml");
+            users.push((name.clone(),format!("classifier Child{target}{own} specializes B{target} {{{}feature p redefines B{target}::p;}}",direction)));
+            if !allowed(target, own) {
+                expected.insert(name);
+            }
+        }
+    }
+    for (mode, (m, mut r)) in models(&library, &users).into_iter().enumerate() {
+        let loaded = m.loaded_library_unit_count();
+        for warm in [false, true] {
+            if warm {
+                for target in 0..4 {
+                    for own in 0..4 {
+                        let e = r
+                            .resolve_qualified(&format!("Child{target}{own}::p"))
+                            .unwrap();
+                        r.implied_relationships(e);
+                        r.derived(e, "featuringType");
+                    }
+                }
+            }
+            let ds = check::validate_semantics_with(&mut r, &m);
+            let actual = ds
+                .iter()
+                .filter(|(_, d)| d.code == Some(RULE))
+                .map(|(u, _)| m.unit(*u).name.clone())
+                .collect::<BTreeSet<_>>();
+            assert_eq!(actual, expected, "mode {mode}, warm {warm}: {ds:?}");
+            assert_eq!(ds.iter().filter(|(_, d)| d.code == Some(RULE)).count(), 7);
+        }
+        assert_eq!(m.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn conjugated_repair_hints_agree_with_spelled_redefinition() {
+    for double in [false, true] {
+        for (own, direction) in ["", "in ", "out ", "inout "].into_iter().enumerate() {
+            let (library, base, required) = if double {
+                (
+                    "classifier A {in feature p;} classifier B conjugates A;",
+                    "B",
+                    1,
+                )
+            } else {
+                ("classifier A {in feature p;}", "A", 2)
+            };
+            let src = format!(
+                "classifier C conjugates {base} {{{direction}feature p;}} classifier Spelled conjugates {base} {{{direction}feature p redefines A::p;}}"
+            );
+            for (mode, (m, mut r)) in models(library, &user(&src)).into_iter().enumerate() {
+                let loaded = m.loaded_library_unit_count();
+                for _ in 0..2 {
+                    let findings = check::inherited_name_collisions(&mut r);
+                    let c = r.resolve_qualified("C::p").unwrap();
+                    let finding = findings
+                        .iter()
+                        .find(|f| f.element == c)
+                        .unwrap_or_else(|| panic!("mode {mode}: {findings:?}"));
+                    assert_eq!(
+                        finding.redefinition_target.is_some(),
+                        own == required,
+                        "double {double}, local {direction:?}, mode {mode}: {finding:?}"
+                    );
+                    assert_eq!(direction_count(&mut r, &m), usize::from(own != required));
+                    r.implied_relationships(c);
+                    r.derived(c, "featuringType");
+                }
+                assert_eq!(m.loaded_library_unit_count(), loaded);
+            }
+        }
+    }
+}
+
+#[test]
+fn undirected_and_inout_targets_have_distinct_repair_requirements() {
+    for (target, td) in [(0, ""), (3, "inout ")] {
+        for (own, od) in ["", "in ", "out ", "inout "].into_iter().enumerate() {
+            let library = format!("classifier Base {{{td}feature p;}}");
+            let src = format!(
+                "classifier C specializes Base {{{od}feature p;}} classifier Spelled specializes Base {{{od}feature p redefines Base::p;}}"
+            );
+            for (m, mut r) in models(&library, &user(&src)) {
+                let c = r.resolve_qualified("C::p").unwrap();
+                let findings = check::inherited_name_collisions(&mut r);
+                let f = findings.iter().find(|f| f.element == c).unwrap();
+                assert_eq!(
+                    f.redefinition_target.is_some(),
+                    allowed(target, own),
+                    "{f:?}"
+                );
+                assert_eq!(
+                    direction_count(&mut r, &m),
+                    usize::from(!allowed(target, own))
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn typed_and_transitive_contexts_preserve_direction_requirements() {
+    let library = "classifier Base {in feature p;} classifier Mid specializes Base;";
+    let src = "classifier Good specializes Mid {in feature p redefines Base::p;}
+        classifier Missing specializes Mid {feature p redefines Base::p;}
+        feature good : Mid {in feature p redefines Base::p;}
+        feature missing : Mid {feature p redefines Base::p;}
+        feature wrong : Mid {out feature p redefines Base::p;}";
+    for (m, mut r) in models(library, &user(src)) {
+        let loaded = m.loaded_library_unit_count();
+        for _ in 0..2 {
+            assert_eq!(direction_count(&mut r, &m), 3);
+        }
+        assert_eq!(m.loaded_library_unit_count(), loaded);
+    }
+}
+
+#[test]
+fn incomplete_direction_contexts_do_not_offer_repairs_or_invent_errors() {
+    let library = "classifier Base {in feature p;}";
+    for (name, extra) in [("Missing", "missing"), ("Cycle", "C")] {
+        let src = format!(
+            "classifier C specializes Base, {extra} {{feature p;}} classifier Spelled specializes Base, {extra} {{feature p redefines Base::p;}}"
+        );
+        for (m, mut r) in models(library, &user(&src)) {
+            let findings = check::inherited_name_collisions(&mut r);
+            let local = r.resolve_qualified("C::p").unwrap();
+            let base = r.resolve_qualified("Base::p").unwrap();
+            let directed = findings
+                .iter()
+                .find(|f| f.element == local && f.hidden == Some(base))
+                .unwrap_or_else(|| panic!("missing directed collision {name}: {findings:?}"));
+            assert!(
+                directed.redefinition_target.is_none(),
+                "{name}: {directed:?}"
+            );
+            assert_eq!(direction_count(&mut r, &m), 0);
+        }
+    }
+}
+
+#[test]
+fn bound_redefinition_target_identity_is_local_to_its_source_unit() {
+    for (actual, spelled, expected) in [("in ", "out ", "B.kerml"), ("out ", "in ", "A.kerml")] {
+        let source = format!(
+            "classifier Base {{{actual}feature actual;{spelled}feature '{ID}';}} classifier Child specializes Base {{in feature p redefines '{ID}';}}"
+        );
+        let users = [
+            ("A.kerml".into(), format!("package A {{{source}}}")),
+            ("B.kerml".into(), format!("package B {{{source}}}")),
+        ];
+        for (m, mut r) in models("package Empty;", &users) {
+            let actual = r.resolve_qualified("A::Base::actual").unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(actual),
+                ID.parse().unwrap(),
+            )]));
+            let child = r.resolve_qualified("A::Child::p").unwrap();
+            let rel = r
+                .owned_relationships(child)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Redefinition")
+                .unwrap();
+            let mut hints = HashMap::from([(
+                (r.element_id(rel), "redefinedFeature".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let ds = check::validate_semantics_with(&mut r, &m);
+                let dirs = ds
+                    .iter()
+                    .filter(|(_, d)| d.code == Some(RULE))
+                    .collect::<Vec<_>>();
+                assert_eq!(dirs.len(), 1, "{ds:?}");
+                assert_eq!(m.unit(dirs[0].0).name, expected);
+                let source = &users.iter().find(|(n, _)| n == expected).unwrap().1;
+                assert_eq!(
+                    &source[dirs[0].1.span.start as usize..dirs[0].1.span.end as usize],
+                    format!("'{ID}'")
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn explicit_featuring_contexts_check_each_proven_direction() {
+    let library = "classifier A {in feature p;} classifier Ordinary specializes A; classifier Flipped conjugates A;";
+    let src = "in feature good redefines A::p featured by Ordinary;
+        feature missing redefines A::p featured by Ordinary;
+        in feature mixed redefines A::p featured by Ordinary, Flipped;
+        in feature partial redefines A::p featured by Flipped, missingType;
+        out feature unknown redefines A::p featured by missingType;";
+    for (m, mut r) in models(library, &user(src)) {
+        for warm in [false, true] {
+            if warm {
+                for name in ["good", "missing", "mixed", "partial", "unknown"] {
+                    let e = r.resolve_qualified(name).unwrap();
+                    r.derived(e, "featuringType");
+                }
+            }
+            assert_eq!(direction_count(&mut r, &m), 3);
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/reference_bindings.rs b/crates/sysmlv2-parser/tests/reference_bindings.rs
new file mode 100644
index 0000000..23405b2
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/reference_bindings.rs
@@ -0,0 +1,456 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, ElementRef, ResolvedModel},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+const LIBRARY: &str = "standard library package Values { datatype Integer; feature n:Integer[2]; alias a for n; feature libraryReference=n; }";
+fn value(r: &mut ResolvedModel, name: &str) -> ElementRef {
+    let owner = r.resolve_qualified(name).unwrap();
+    let rel = r
+        .owned_relationships(owner)
+        .into_iter()
+        .find(|&e| r.element_type(e) == "FeatureValue")
+        .unwrap();
+    one(r, rel, "value").unwrap()
+}
+fn one(r: &mut ResolvedModel, e: ElementRef, p: &str) -> Option<ElementRef> {
+    match r.derived(e, p) {
+        Derived::Value(v) => v.element(),
+        v => panic!("{p}: {v:?}"),
+    }
+}
+fn many(r: &mut ResolvedModel, e: ElementRef, p: &str) -> Vec<ElementRef> {
+    match r.derived(e, p) {
+        Derived::Value(sysmlv2_parser::json::DerivedValue::Elements(v)) => v,
+        v => panic!("{p}: {v:?}"),
+    }
+}
+
+#[test]
+fn reference_binding_is_an_owned_binary_connector_over_stored_identities() {
+    for (_, mut r) in models(LIBRARY, "feature x=Values::n;") {
+        let expression = value(&mut r, "x");
+        let referent = r.resolve_qualified("Values::n").unwrap();
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            let result = one(&mut r, expression, "result").unwrap();
+            let members = many(&mut r, expression, "ownedMember");
+            let bindings: Vec<_> = members
+                .into_iter()
+                .filter(|&e| r.element_type(e) == "BindingConnector")
+                .collect();
+            assert_eq!(bindings.len(), 1);
+            let binding = bindings[0];
+            assert_eq!(r.owner(binding), Some(expression));
+            assert_eq!(
+                one(&mut r, binding, "owningType"),
+                None,
+                "ownedMember does not invent expression featuring for an outer referent"
+            );
+            assert!(r.element_scope(binding).is_none());
+            assert!(r.is_implied(binding), "Connector is also a Relationship");
+            match r.derived(binding, "relatedFeature") {
+                Derived::Value(sysmlv2_parser::json::DerivedValue::References(ends)) => assert_eq!(
+                    ends,
+                    vec![
+                        sysmlv2_parser::json::Reference::Element(referent),
+                        sysmlv2_parser::json::Reference::Element(result)
+                    ]
+                ),
+                other => panic!("{other:?}"),
+            }
+            let ends = many(&mut r, binding, "connectorEnd");
+            assert_eq!(ends.len(), 2);
+            for (end, target) in ends.into_iter().zip([referent, result]) {
+                assert_eq!(one(&mut r, end, "owningType"), Some(binding));
+                let reference = one(&mut r, end, "ownedReferenceSubsetting").unwrap();
+                assert_eq!(
+                    r.relationship_ends(reference).1,
+                    vec![sysmlv2_parser::json::Reference::Element(target)]
+                );
+                assert!(r.conforms_with_implied(end, target));
+            }
+            assert_eq!(many(&mut r, expression, "ownedFeature"), vec![result]);
+            assert_eq!(
+                r.derived_exact(expression, "ownedFeature"),
+                Err(sysmlv2_parser::json::PropertyError::Approximate)
+            );
+        }
+    }
+}
+
+#[test]
+fn binding_node_id_collision_never_publishes_a_partial_expression_subtree() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    for collision in 0..8 {
+        for (_, mut r) in models("", "feature n; feature victim; feature x=n;") {
+            let expression = value(&mut r, "x");
+            let n = r.resolve_qualified("n").unwrap();
+            let victim = r.resolve_qualified("victim").unwrap();
+            let expr_id = r.element_id(expression);
+            let result = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{expr_id}/implied/ownedResult").as_bytes(),
+            );
+            let binding = Uuid::new_v5(
+                &Uuid::NAMESPACE_OID,
+                format!("{expr_id}/implied/referenceBinding").as_bytes(),
+            );
+            let seed = |s: String| Uuid::new_v5(&Uuid::NAMESPACE_OID, s.as_bytes());
+            let end0 = seed(format!("{binding}/implied/end/0"));
+            let end1 = seed(format!("{binding}/implied/end/1"));
+            let ids = [
+                seed(format!("{expr_id}/implied/referenceBindingMembership")),
+                binding,
+                seed(format!("{binding}/implied/endMembership/0")),
+                end0,
+                seed(format!(
+                    "{end0}/implied/ReferenceSubsetting/{}",
+                    r.element_id(n)
+                )),
+                seed(format!("{binding}/implied/endMembership/1")),
+                end1,
+                seed(format!("{end1}/implied/ReferenceSubsetting/{result}")),
+            ];
+            r.override_ids(&HashMap::from([(r.element_id(victim), ids[collision])]));
+            assert_eq!(one(&mut r, expression, "result"), None);
+            assert!(r.implied_relationships(expression).is_empty());
+            assert!(many(&mut r, expression, "ownedMember").is_empty());
+        }
+    }
+}
+
+fn binding(r: &mut ResolvedModel, expression: ElementRef) -> Option<ElementRef> {
+    many(r, expression, "ownedMember")
+        .into_iter()
+        .find(|&e| r.element_type(e) == "BindingConnector")
+}
+
+#[test]
+fn binding_tail_retargets_atomically_and_survives_bound_identity_remapping() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    let target_id = Uuid::parse_str("8cc9369e-e07e-453e-9aaa-79e5014b1885").unwrap();
+    for lexical in [false, true] {
+        let source = format!(
+            "{} feature actual; feature x='{}';",
+            if lexical {
+                format!("feature '{}';", target_id)
+            } else {
+                String::new()
+            },
+            target_id
+        );
+        for (_, mut r) in models("", &source) {
+            let expression = value(&mut r, "x");
+            let expression_id = r.element_id(expression);
+            let membership = r.owned_relationships(expression)[0];
+            let actual = r.resolve_qualified("actual").unwrap();
+            let original = binding(&mut r, expression);
+            assert_eq!(original.is_some(), lexical);
+            let old_reference_id = original.map(|connector| {
+                let end = many(&mut r, connector, "connectorEnd")[0];
+                let reference = one(&mut r, end, "ownedReferenceSubsetting").unwrap();
+                r.element_id(reference)
+            });
+            r.override_ids(&HashMap::from([(r.element_id(actual), target_id)]));
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".into()),
+                target_id,
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&target_id)
+            );
+            let connector = binding(&mut r, expression).unwrap();
+            let result = one(&mut r, expression, "result").unwrap();
+            assert_eq!(
+                r.relationship_ends(connector),
+                (
+                    vec![sysmlv2_parser::json::Reference::Element(actual)],
+                    vec![sysmlv2_parser::json::Reference::Element(result)]
+                )
+            );
+            if let Some(old) = old_reference_id {
+                assert!(r.element_by_id(&old.to_string()).is_none());
+            }
+            let connector_id = r.element_id(connector);
+            let result_id = r.element_id(result);
+            r.bind_id_spelled_references_with(&mut hints);
+            let current = binding(&mut r, expression).unwrap();
+            assert_eq!(r.element_id(current), connector_id);
+            let current_result = one(&mut r, expression, "result").unwrap();
+            assert_eq!(r.element_id(current_result), result_id);
+            // ID override remaps an already bound target; a repeated bind
+            // has no pending site and must preserve the generated handles.
+            let moved = Uuid::parse_str("bef446bc-013e-4a7d-ad44-0545804ab972").unwrap();
+            r.override_ids(&HashMap::from([(target_id, moved)]));
+            let mut stale_hint = HashMap::from([(
+                (r.element_id(membership), "memberElement".into()),
+                target_id,
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut stale_hint)
+                    .is_empty()
+            );
+            assert_eq!(binding(&mut r, expression), Some(current));
+            assert_eq!(one(&mut r, expression, "result"), Some(current_result));
+            assert_eq!(
+                r.relationship_ends(current),
+                (
+                    vec![sysmlv2_parser::json::Reference::Element(actual)],
+                    vec![sysmlv2_parser::json::Reference::Element(current_result)]
+                )
+            );
+            let end = many(&mut r, current, "connectorEnd")[0];
+            let reference = one(&mut r, end, "ownedReferenceSubsetting").unwrap();
+            assert_eq!(
+                r.element_properties(reference)["referencedFeature"],
+                serde_json::json!({"@id": moved.to_string()})
+            );
+            assert_eq!(r.element_id(expression), expression_id);
+            assert_eq!(r.element_id(actual), moved);
+        }
+    }
+}
+
+#[test]
+fn pending_identity_binding_loss_discards_both_result_and_binding() {
+    use std::collections::HashMap;
+    use uuid::Uuid;
+    let target_id = Uuid::parse_str("79c36d19-0f87-4e62-9b15-25b6d331d355").unwrap();
+    let source = format!("feature '{target_id}'; class wrongKind; feature x='{target_id}';");
+    for wrong_kind in [false, true] {
+        for (_, mut r) in models("", &source) {
+            let expression = value(&mut r, "x");
+            let expression_id = r.element_id(expression);
+            let membership = r.owned_relationships(expression)[0];
+            let old_binding = binding(&mut r, expression).unwrap();
+            let old_binding_id = r.element_id(old_binding);
+            let old_result = one(&mut r, expression, "result").unwrap();
+            let old_result_id = r.element_id(old_result);
+            if wrong_kind {
+                let target = r.resolve_qualified("wrongKind").unwrap();
+                r.override_ids(&HashMap::from([(r.element_id(target), target_id)]));
+            }
+            let mut hints = HashMap::from([(
+                (r.element_id(membership), "memberElement".into()),
+                target_id,
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&target_id)
+            );
+            assert_eq!(binding(&mut r, expression), None);
+            assert_eq!(one(&mut r, expression, "result"), None);
+            assert!(r.element_by_id(&old_binding_id.to_string()).is_none());
+            assert!(r.element_by_id(&old_result_id.to_string()).is_none());
+            assert_eq!(r.element_id(expression), expression_id);
+        }
+    }
+}
+
+#[test]
+fn full_binding_subtrees_have_consistent_generic_endpoints_and_lift_away_atomically() {
+    use std::collections::HashSet;
+    use sysmlv2_parser::{
+        full::{EmissionPolicy, UnresolvedReferencePolicy, resolved_to_full_json},
+        json::model_to_compact_json,
+        lift::from_compact_json_with_names,
+        print::print_source,
+    };
+    for (model, mut r) in models(LIBRARY, "feature x=Values::n;") {
+        let compact = model_to_compact_json(&model);
+        let compact_ids: HashSet<_> = compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|row| row["@id"].as_str().unwrap())
+            .collect();
+        let names = sysmlv2_parser::json::library_element_name_map(&model);
+        let compact_lift = from_compact_json_with_names(&compact, &names).unwrap();
+        assert!(
+            compact_lift.errors.is_empty(),
+            "compact baseline lift: {:?}",
+            compact_lift.errors
+        );
+        let source = print_source(&compact_lift.unit);
+        let expression = value(&mut r, "x");
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            let full = resolved_to_full_json(
+                &mut r,
+                &model,
+                EmissionPolicy {
+                    unresolved: UnresolvedReferencePolicy::Reject,
+                    closures: policy,
+                },
+            )
+            .unwrap();
+            let connector = binding(&mut r, expression).unwrap();
+            let result = one(&mut r, expression, "result").unwrap();
+            let target = r.resolve_qualified("Values::n").unwrap();
+            let rows = full.as_array().unwrap();
+            assert_eq!(rows.len(), compact_ids.len() + 14);
+            let generated: Vec<_> = rows
+                .iter()
+                .filter(|row| !compact_ids.contains(row["@id"].as_str().unwrap()))
+                .collect();
+            assert_eq!(generated.len(), 14);
+            let unique: HashSet<_> = generated
+                .iter()
+                .map(|row| row["@id"].as_str().unwrap())
+                .collect();
+            assert_eq!(unique.len(), 14);
+            let featuring: Vec<_> = generated
+                .iter()
+                .filter(|row| row["@type"] == "TypeFeaturing")
+                .collect();
+            assert_eq!(featuring.len(), 3);
+            let ends = many(&mut r, connector, "connectorEnd");
+            assert_eq!(ends.len(), 2);
+            let sources = std::iter::once((result, expression))
+                .chain(ends.into_iter().map(|end| (end, connector)));
+            for (source, target) in sources {
+                let relationship = featuring
+                    .iter()
+                    .find(|row| row["featureOfType"]["@id"] == r.element_id(source).to_string())
+                    .unwrap();
+                assert_eq!(
+                    relationship["owningRelatedElement"],
+                    relationship["featureOfType"]
+                );
+                assert_eq!(
+                    relationship["owningFeatureOfType"],
+                    relationship["featureOfType"]
+                );
+                assert_eq!(
+                    relationship["featuringType"]["@id"],
+                    r.element_id(target).to_string()
+                );
+                assert_eq!(
+                    relationship["source"],
+                    serde_json::json!([relationship["featureOfType"]])
+                );
+                assert_eq!(
+                    relationship["target"],
+                    serde_json::json!([relationship["featuringType"]])
+                );
+            }
+            let row = rows
+                .iter()
+                .find(|row| row["@id"] == r.element_id(connector).to_string())
+                .unwrap();
+            assert_eq!(
+                row["source"],
+                serde_json::json!([{"@id":r.element_id(target).to_string()}])
+            );
+            assert_eq!(
+                row["target"],
+                serde_json::json!([{"@id":r.element_id(result).to_string()}])
+            );
+            assert_eq!(
+                row["relatedElement"],
+                serde_json::json!([{"@id":r.element_id(target).to_string()},{"@id":r.element_id(result).to_string()}])
+            );
+            assert_eq!(row["relatedFeature"], row["relatedElement"]);
+            assert_eq!(
+                row["owningRelatedElement"],
+                serde_json::Value::Null,
+                "binding is owned through its membership, not as a direct relationship"
+            );
+            assert_eq!(r.owner(connector), Some(expression));
+            let full_lift = from_compact_json_with_names(&full, &names).unwrap();
+            assert!(
+                full_lift.errors.is_empty(),
+                "full lift: {:?}",
+                full_lift.errors
+            );
+            assert_eq!(print_source(&full_lift.unit), source);
+            assert_eq!(model_to_compact_json(&model), compact);
+        }
+    }
+}
+
+#[test]
+fn generated_binding_does_not_change_sysml_lift_dialect() {
+    use sysmlv2_parser::{
+        ast::Dialect, full::model_to_full_json, json::model_to_compact_json,
+        lift::from_compact_json, print::print_source,
+    };
+    for (model, _) in models_named(
+        "",
+        "part def Container { attribute n; attribute x=n; }",
+        "reference.sysml",
+    ) {
+        let compact = from_compact_json(&model_to_compact_json(&model)).unwrap();
+        let full = model_to_full_json(&model);
+        assert!(
+            full.as_array()
+                .unwrap()
+                .iter()
+                .any(|row| { row["@type"] == "BindingConnector" && row["isImplied"] == true })
+        );
+        let lifted = from_compact_json(&full).unwrap();
+        assert!(compact.errors.is_empty(), "{:?}", compact.errors);
+        assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+        assert_eq!(lifted.unit.dialect, Dialect::Sysml);
+        assert_eq!(print_source(&lifted.unit), print_source(&compact.unit));
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/roundtrip.rs b/crates/sysmlv2-parser/tests/roundtrip.rs
index 25bf22b..17fd872 100644
--- a/crates/sysmlv2-parser/tests/roundtrip.rs
+++ b/crates/sysmlv2-parser/tests/roundtrip.rs
@@ -674,7 +674,7 @@ fn deep_ownership_chain_lifts_without_overflowing() {
 }
 
 /// One naming rule, several representations: an unnamed feature is named
-/// by the feature it redefines, references, or chains to. The lift reads
+/// by its redefined feature or applicable SysML reference naming rule. The lift reads
 /// that rule off payload JSON (for the qualified names a cross-document
 /// reference prints), the full form derives it over its own element maps
 /// (for `name` and `memberName`), and the id derivation runs it as a
@@ -1016,3 +1016,273 @@ fn full_form_preserves_elements_the_lifter_cannot_reconstruct() {
         assert_eq!(output["ownedRelationship"], element["ownedRelationship"]);
     }
 }
+
+#[test]
+fn anonymous_chains_stay_unnamed_across_interchange() {
+    let source = "package P {
+        part def Base { part chassis { attribute mass; } attribute other; }
+        part anonymous : Base { attribute :>> chassis.mass, other = 2; }
+        part named : Base { attribute mass :>> chassis.mass = 2; }
+        part child :> named { attribute :>> mass = 3; }
+        action actions { action run; }
+        perform actions.run;
+        requirement r { require constraint check { true } }
+        requirement s { require r.check; }
+    }";
+    let parsed = parse(source, Dialect::Sysml);
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let compact = to_compact_json(&parsed.unit);
+    let elements = compact.as_array().unwrap();
+    let full = sysmlv2_parser::full::from_compact_value(compact.clone(), &Default::default(), true);
+    let names = sysmlv2_parser::lift::document_name_map(&compact);
+    for el in elements
+        .iter()
+        .filter(|e| e["@type"] == "Feature" && e["declaredName"].is_null())
+    {
+        if !elements.iter().any(|r| {
+            r["@type"] == "FeatureChaining"
+                && el["ownedRelationship"]
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .any(|owned| owned["@id"] == r["@id"])
+        }) {
+            continue;
+        }
+        let derived = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|f| f["@id"] == el["@id"])
+            .unwrap();
+        assert!(derived["name"].is_null(), "{derived}");
+        assert!(!names.contains_key(el["@id"].as_str().unwrap()));
+    }
+    let anonymous_owner = elements
+        .iter()
+        .find(|e| e["declaredName"] == "anonymous")
+        .unwrap();
+    let membership = elements
+        .iter()
+        .find(|e| {
+            e["@type"] == "FeatureMembership"
+                && anonymous_owner["ownedRelationship"]
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .any(|r| r["@id"] == e["@id"])
+        })
+        .unwrap();
+    let attr = elements
+        .iter()
+        .find(|e| e["owningRelationship"]["@id"] == membership["@id"])
+        .unwrap();
+    let derived = full
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|e| e["@id"] == attr["@id"])
+        .unwrap();
+    assert!(derived["name"].is_null(), "{derived}");
+    assert!(!names.contains_key(attr["@id"].as_str().unwrap()));
+    let lifted = from_compact_json(&compact).unwrap();
+    assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+    let text = print_source(&lifted.unit);
+    assert_eq!(
+        to_compact_json(&parse(&text, Dialect::Sysml).unit),
+        compact,
+        "{text}"
+    );
+    let paths = sysmlv2_parser::ids::segment_paths(&compact, &|_| None).unwrap();
+    let i = elements
+        .iter()
+        .position(|e| e["@id"] == attr["@id"])
+        .unwrap();
+    assert!(!paths[i].as_ref().unwrap().1.ends_with("::mass"));
+}
+
+#[test]
+fn specialized_reference_names_do_not_name_their_anonymous_chains() {
+    let source = "package P {
+        action actions { action run; }
+        perform actions.run;
+        requirement r { require constraint check { true } }
+        requirement s { require r.check; }
+        part vehicle { part chassis; }
+        variation part choices { variant part ::> vehicle.chassis; }
+    }";
+    let parsed = parse(source, Dialect::Sysml);
+    assert!(parsed.diagnostics.is_empty(), "{:?}", parsed.diagnostics);
+    let compact = to_compact_json(&parsed.unit);
+    let elements = compact.as_array().unwrap();
+    let full = sysmlv2_parser::full::from_compact_value(compact.clone(), &Default::default(), true);
+    let names = sysmlv2_parser::lift::document_name_map(&compact);
+    for (kind, expected) in [
+        ("PerformActionUsage", Some("run")),
+        ("ConstraintUsage", Some("check")),
+        ("PartUsage", None),
+    ] {
+        let candidates: Vec<_> = elements
+            .iter()
+            .filter(|e| {
+                e["@type"] == kind
+                    && e["declaredName"].is_null()
+                    && elements.iter().any(|r| {
+                        r["@type"] == "ReferenceSubsetting"
+                            && e["ownedRelationship"]
+                                .as_array()
+                                .unwrap()
+                                .iter()
+                                .any(|owned| owned["@id"] == r["@id"])
+                    })
+            })
+            .collect();
+        assert_eq!(candidates.len(), 1, "{kind}: {compact}");
+        let el = candidates[0];
+        let derived = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|f| f["@id"] == el["@id"])
+            .unwrap();
+        assert_eq!(derived["name"].as_str(), expected, "{kind}");
+        assert_eq!(
+            names
+                .get(el["@id"].as_str().unwrap())
+                .and_then(|p| p.last())
+                .map(String::as_str),
+            expected,
+            "{kind}"
+        );
+    }
+    let lifted = from_compact_json(&compact).unwrap();
+    assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+    let text = print_source(&lifted.unit);
+    assert_eq!(
+        to_compact_json(&parse(&text, Dialect::Sysml).unit),
+        compact,
+        "{text}"
+    );
+}
+
+#[test]
+fn redefining_a_named_chain_preserves_its_name() {
+    let source = "package P {
+        class Base { feature b { feature x; } feature path chains b.x; }
+        class Child specializes Base { feature redefines path; }
+    }";
+    let compact = to_compact_json(&parse(source, Dialect::Kerml).unit);
+    let elements = compact.as_array().unwrap();
+    let redefinition = elements
+        .iter()
+        .find(|e| e["@type"] == "Redefinition")
+        .unwrap();
+    let id = redefinition["redefiningFeature"]["@id"].as_str().unwrap();
+    let names = sysmlv2_parser::lift::document_name_map(&compact);
+    assert_eq!(names.get(id).unwrap(), &["P", "Child", "path"]);
+    let full = sysmlv2_parser::full::from_compact_value(compact.clone(), &Default::default(), true);
+    let e = full
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|e| e["@id"] == id)
+        .unwrap();
+    assert_eq!(e["name"], "path");
+    let lifted = from_compact_json(&compact).unwrap();
+    assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+    assert_eq!(
+        to_compact_json(&parse(&print_source(&lifted.unit), Dialect::Kerml).unit),
+        compact
+    );
+}
+
+#[test]
+fn specialized_reference_names_take_precedence_over_redefinitions() {
+    for target in ["missing", "other"] {
+        for (usage, kind, expected) in [
+            (
+                format!("perform actions.run :>> {target};"),
+                "PerformActionUsage",
+                Some("run"),
+            ),
+            (
+                format!("requirement s {{ require constraint :>> {target} ::> r.check; }}"),
+                "ConstraintUsage",
+                Some("check"),
+            ),
+            (
+                format!(
+                    "variation part choices {{ variant part :>> {target} ::> vehicle.chassis; }}"
+                ),
+                "PartUsage",
+                None,
+            ),
+            (
+                format!("variation part choices {{ variant part :>> {target} ::> vehicle; }}"),
+                "PartUsage",
+                Some("vehicle"),
+            ),
+        ] {
+            let source = format!(
+                "package P {{ action actions {{ action run; }} requirement r {{ require constraint check {{ true }} }} part vehicle {{ part chassis; }} part other; {usage} }}"
+            );
+            let parsed = parse(&source, Dialect::Sysml);
+            assert!(
+                parsed.diagnostics.is_empty(),
+                "{usage}: {:?}",
+                parsed.diagnostics
+            );
+            let compact = to_compact_json(&parsed.unit);
+            let elements = compact.as_array().unwrap();
+            let el = elements
+                .iter()
+                .find(|e| {
+                    e["@type"] == kind
+                        && e["declaredName"].is_null()
+                        && elements.iter().any(|r| {
+                            r["@type"] == "ReferenceSubsetting"
+                                && e["ownedRelationship"]
+                                    .as_array()
+                                    .unwrap()
+                                    .iter()
+                                    .any(|owned| owned["@id"] == r["@id"])
+                        })
+                })
+                .unwrap();
+            let names = sysmlv2_parser::lift::document_name_map(&compact);
+            let full = sysmlv2_parser::full::from_compact_value(
+                compact.clone(),
+                &Default::default(),
+                true,
+            );
+            let derived = full
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|f| f["@id"] == el["@id"])
+                .unwrap();
+            assert_eq!(derived["name"].as_str(), expected, "{usage}");
+            assert_eq!(
+                names
+                    .get(el["@id"].as_str().unwrap())
+                    .and_then(|p| p.last())
+                    .map(String::as_str),
+                expected,
+                "{usage}"
+            );
+            let paths = sysmlv2_parser::ids::segment_paths(&compact, &|_| None).unwrap();
+            if let Some(expected) = expected {
+                let i = elements.iter().position(|e| e["@id"] == el["@id"]).unwrap();
+                assert!(
+                    paths[i]
+                        .as_ref()
+                        .unwrap()
+                        .1
+                        .ends_with(&format!("::{expected}")),
+                    "{usage}: {:?}",
+                    paths[i]
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/sdk_semantic_regressions.rs b/crates/sysmlv2-parser/tests/sdk_semantic_regressions.rs
new file mode 100644
index 0000000..a0dae06
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/sdk_semantic_regressions.rs
@@ -0,0 +1,286 @@
+//! Typed facade regressions across navigation, export and replay.
+#![cfg(feature = "json")]
+use serde_json::json;
+use std::collections::HashMap;
+use sysmlv2_parser::{
+    full::model_to_full_json,
+    json::{
+        ClosurePolicy, Derived, DerivedValue, OperationError, Reference, ResolvedModel,
+        model_to_compact_json,
+    },
+    loader::load_document,
+    model::Model,
+};
+fn model(text: &str) -> Model {
+    let mut m = Model::new();
+    let result = m.add_source("facade.sysml", text);
+    assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
+    m
+}
+#[test]
+fn flow_interface_compositions_preserve_the_declared_target_type() {
+    let m =
+        model("part def D { flow f; interface i; ref x; } part d { flow f; interface i; ref x; }");
+    let mut r = ResolvedModel::build(&m);
+    let full = model_to_full_json(&m);
+    for (name, flow, interface) in [
+        ("D", "ownedFlow", "ownedInterface"),
+        ("d", "nestedFlow", "nestedInterface"),
+    ] {
+        let owner = r.resolve_qualified(name).unwrap();
+        let row = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|row| row["@id"] == r.element_id(owner).to_string())
+            .unwrap();
+        for (prop, member) in [(flow, "f"), (interface, "i")] {
+            let child = r.resolve_qualified(&format!("{name}::{member}")).unwrap();
+            let expected = json!([{"@id": r.element_id(child).to_string()}]);
+            assert_eq!(r.property(owner, prop).unwrap(), expected, "{name}.{prop}");
+            assert_eq!(row[prop], expected, "export {name}.{prop}");
+        }
+    }
+}
+#[test]
+fn generic_reference_subsetting_does_not_name_anonymous_features() {
+    let m = model("part a; connection connect a to a;");
+    let compact = model_to_compact_json(&m);
+    let mut r = ResolvedModel::build(&m);
+    let refs: Vec<_> = r
+        .elements()
+        .filter(|&e| r.element_type(e) == "ReferenceUsage")
+        .collect();
+    assert_eq!(refs.len(), 2);
+    // Connector ends have positional names, never the generic subset target's name.
+    for e in refs {
+        assert_ne!(r.element_effective_name(e).as_deref(), Some("a"));
+    }
+    let (_, mut replay, _, warnings) = load_document(&compact, &HashMap::new()).unwrap();
+    assert!(warnings.is_empty(), "{warnings:?}");
+    for e in r.user_elements().collect::<Vec<_>>() {
+        let id = r.element_id(e).to_string();
+        let other = replay.element_by_id(&id).unwrap();
+        assert_eq!(
+            r.element_effective_name(e),
+            replay.element_effective_name(other)
+        );
+    }
+}
+#[test]
+fn shorthand_succession_keeps_source_and_target_roles() {
+    for text in [
+        "state s { entry; then off; state off; }",
+        "action a { action firstAction; attribute n; then lastAction; action lastAction; }",
+    ] {
+        let m = model(text);
+        let compact = model_to_compact_json(&m);
+        let mut r = ResolvedModel::build(&m);
+        r.set_closure_policy(ClosurePolicy::Closure {
+            include_implied: true,
+        });
+        let succession = r
+            .elements()
+            .find(|&e| r.element_type(e) == "SuccessionAsUsage")
+            .unwrap();
+        let (source, target) = r.relationship_ends(succession);
+        assert_eq!(source.len(), 1, "{text}");
+        assert_eq!(target.len(), 1, "{text}");
+        assert_ne!(source, target);
+        assert_eq!(
+            r.derived(succession, "sourceFeature"),
+            Derived::Value(DerivedValue::Reference(source[0].clone()))
+        );
+        assert_eq!(
+            r.derived(succession, "targetFeature"),
+            Derived::Value(DerivedValue::References(target))
+        );
+        assert_eq!(compact, model_to_compact_json(&m));
+        assert!(
+            r.implied_relationships(match source[0] {
+                Reference::Element(e) => e,
+                _ => panic!(),
+            })
+            .iter()
+            .all(|&e| r.element_type(e) != "ReferenceSubsetting")
+        );
+    }
+}
+#[test]
+fn absent_succession_source_does_not_shift_the_target() {
+    let m = model("action a { then lastAction; action lastAction; }");
+    let mut r = ResolvedModel::build(&m);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let succession = r
+        .elements()
+        .find(|&e| r.element_type(e) == "SuccessionAsUsage")
+        .unwrap();
+    let (source, target) = r.relationship_ends(succession);
+    assert!(source.is_empty());
+    assert_eq!(target.len(), 1);
+}
+#[test]
+fn effective_name_operations_dispatch_and_refuse_uncertified_inheritance() {
+    let m = model("package <p> P { part <x> named; part :> named; }");
+    let mut r = ResolvedModel::build(&m);
+    let name = "Root-Elements-Element-effectiveName_";
+    let short = "Root-Elements-Element-effectiveShortName_";
+    let p = r.resolve_qualified("P").unwrap();
+    let x = r.resolve_qualified("P::named").unwrap();
+    assert_eq!(
+        r.invoke_operation(p, name, &[]).unwrap().value,
+        DerivedValue::Str("P".into())
+    );
+    assert_eq!(
+        r.invoke_operation(p, short, &[]).unwrap().value,
+        DerivedValue::Str("p".into())
+    );
+    let result = r.invoke_operation(x, name, &[]).unwrap();
+    assert_eq!(result.effective, "Core-Features-Feature-effectiveName_");
+    assert_eq!(result.value, DerivedValue::Str("named".into()));
+    let anonymous = r
+        .elements()
+        .find(|&e| {
+            r.element_type(e) == "PartUsage"
+                && r.element_properties(e)
+                    .get("declaredName")
+                    .is_none_or(|v| v.is_null())
+        })
+        .unwrap();
+    assert!(matches!(
+        r.invoke_operation(anonymous, name, &[]),
+        Err(OperationError::Incomplete { .. })
+    ));
+}
+
+#[test]
+fn generic_reference_naming_is_null_across_public_readers_and_reload() {
+    let mut m = Model::new();
+    assert!(m.add_source("names.kerml", "feature <short> x; package Referenced {feature references x;} package Redefined {feature :>> x;} package Short {feature <s> :>> x;}").diagnostics.is_empty());
+    let compact = model_to_compact_json(&m);
+    let ids = sysmlv2_parser::ids::derive_ids(&compact, &|_| None).unwrap();
+    for (row, id) in compact.as_array().unwrap().iter().zip(ids) {
+        if let Some(id) = id {
+            assert_eq!(row["@id"], id.to_string());
+        }
+    }
+    let full = model_to_full_json(&m);
+    let mut r = ResolvedModel::build(&m);
+    for (owner, name, short) in [
+        ("Referenced", json!(null), json!(null)),
+        ("Redefined", json!("x"), json!("short")),
+        ("Short", json!(null), json!("s")),
+    ] {
+        let parent = r.resolve_qualified(owner).unwrap();
+        let e = match r.derived(parent, "ownedMember") {
+            Derived::Value(v) => v.elements()[0],
+            x => panic!("{x:?}"),
+        };
+        assert_eq!(r.property(e, "name").unwrap(), name);
+        if name.is_null() && short.is_null() {
+            assert!(r.element_qualified_name(e).is_none());
+        }
+
+        assert_eq!(r.property(e, "shortName").unwrap(), short);
+        assert_eq!(
+            r.element_effective_name(e),
+            name.as_str().map(str::to_owned)
+        );
+        let id = r.element_id(e).to_string();
+        let row = full
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|v| v["@id"] == id)
+            .unwrap();
+        assert_eq!(row["name"], name);
+        assert_eq!(row["shortName"], short);
+        for document in [&compact, &full] {
+            let (_, mut replay, _, warnings) = load_document(document, &HashMap::new()).unwrap();
+            assert!(warnings.is_empty(), "{warnings:?}");
+            let target = replay.element_by_id(&id).unwrap();
+            assert_eq!(replay.property(target, "name").unwrap(), name);
+            assert_eq!(replay.property(target, "shortName").unwrap(), short);
+        }
+    }
+}
+
+#[test]
+fn anonymous_reference_locators_replay_without_becoming_semantic_names() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "owner.sysml",
+            "package P { part def D {attribute x;} part a : D {attribute ::> x = 1;} }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    assert!(
+        m.add_source("reader.sysml", "package Q { attribute result = P::a.x; }")
+            .diagnostics
+            .is_empty()
+    );
+    let compact = model_to_compact_json(&m);
+    let full = model_to_full_json(&m);
+    let mut r = ResolvedModel::build(&m);
+    let anonymous = r
+        .user_elements()
+        .find(|&e| {
+            r.element_type(e) == "AttributeUsage"
+                && r.element_properties(e)
+                    .get("declaredName")
+                    .is_none_or(|v| v.is_null())
+        })
+        .unwrap();
+    let id = r.element_id(anonymous).to_string();
+    assert!(r.element_effective_name(anonymous).is_none());
+    for document in [&compact, &full] {
+        // Both documented public replay helpers must retain cross-document locators.
+        for names in [
+            sysmlv2_parser::lift::document_name_map(document),
+            sysmlv2_parser::lift::document_reference_name_map(document),
+        ] {
+            assert!(names.contains_key(&id));
+            let docs = sysmlv2_parser::lift::split_documents(document).unwrap();
+            assert_eq!(docs.len(), 2);
+            let mut restored = Model::new();
+            for (i, (_, doc)) in docs.iter().enumerate() {
+                let lifted =
+                    sysmlv2_parser::lift::from_compact_json_with_names(doc, &names).unwrap();
+                assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+                let source = sysmlv2_parser::print::print_source(&lifted.unit);
+                assert!(
+                    restored
+                        .add_source(["owner.sysml", "reader.sysml"][i], &source)
+                        .diagnostics
+                        .is_empty()
+                );
+            }
+            let mut replay = ResolvedModel::build(&restored);
+            let target = replay.element_by_id(&id).unwrap();
+            assert!(replay.element_effective_name(target).is_none());
+            assert!(!replay.references_to(target).is_empty());
+        }
+        let (_, mut replay, _, warnings) = load_document(document, &HashMap::new()).unwrap();
+        assert!(warnings.is_empty(), "{warnings:?}");
+        let target = replay.element_by_id(&id).unwrap();
+        assert!(replay.element_effective_name(target).is_none());
+        let before = r.references_to(anonymous);
+        let after = replay.references_to(target);
+        assert!(!before.is_empty());
+        let mut before_ids: Vec<_> = before
+            .iter()
+            .map(|site| (r.element_id(site.owner), site.kind.clone()))
+            .collect();
+        let mut after_ids: Vec<_> = after
+            .iter()
+            .map(|site| (replay.element_id(site.owner), site.kind.clone()))
+            .collect();
+        before_ids.sort();
+        after_ids.sort();
+        assert_eq!(before_ids, after_ids);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/semantic_names_reporting.rs b/crates/sysmlv2-parser/tests/semantic_names_reporting.rs
new file mode 100644
index 0000000..f1ef1f4
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/semantic_names_reporting.rs
@@ -0,0 +1,272 @@
+//! Semantic names and failure reporting preserve identity and source provenance.
+#![cfg(feature = "json")]
+use sysmlv2_parser::{
+    json::{ClosurePolicy, Derived, DerivedValue, ResolvedModel},
+    model::Model,
+};
+
+#[test]
+fn ambiguous_references_are_included_in_unresolved_reporting() {
+    let text = "package A { package B { part x; } package C { part x :> B::x; } }
+                package D { public import A::**; part y :> x; part z :> missing; }";
+    let mut m = Model::new();
+    assert!(m.add_source("ambiguous.sysml", text).diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&m);
+    assert_eq!(r.unresolved_count(), 2);
+    let references = r.unresolved_references();
+    assert_eq!(references.len(), 2);
+    for (name, spelling) in [("D::y", "x"), ("D::z", "missing")] {
+        let feature = r.resolve_qualified(name).unwrap();
+        let rel = r
+            .owned_relationships(feature)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "Subsetting")
+            .unwrap();
+        let site = references.iter().find(|site| site.owner == rel).unwrap();
+        assert_eq!(site.spelling, spelling);
+        assert_eq!(site.unit, 0);
+        assert_eq!(
+            &text[site.span.start as usize..site.span.end as usize],
+            spelling
+        );
+        assert_eq!(
+            r.element_properties(rel)["subsettedFeature"]["@ref"],
+            spelling
+        );
+    }
+}
+
+#[test]
+fn anonymous_subject_takes_the_redefined_subjects_names() {
+    let text = "part def Vehicle;
+        requirement def Spec { subject <v> vehicle : Vehicle; }
+        requirement req : Spec;
+        part unit { satisfy req by unit; }";
+    let mut m = Model::new();
+    assert!(m.add_source("subject.sysml", text).diagnostics.is_empty());
+    let mut r = ResolvedModel::build(&m);
+    let memberships: Vec<_> = r
+        .user_elements()
+        .filter(|&e| r.element_type(e) == "SubjectMembership")
+        .collect();
+    let subject = memberships
+        .into_iter()
+        .find_map(|m| {
+            let Derived::Value(DerivedValue::Element(f)) = r.derived(m, "ownedSubjectParameter")
+            else {
+                return None;
+            };
+            r.element_name(f).is_none().then_some(f)
+        })
+        .unwrap();
+    // Reading before and after implied materialization must agree.
+    for materialized in [false, true] {
+        if materialized {
+            r.set_closure_policy(ClosurePolicy::Closure {
+                include_implied: true,
+            });
+        }
+        assert_eq!(
+            r.element_effective_name(subject).as_deref(),
+            Some("vehicle")
+        );
+        assert_eq!(r.element_short_name(subject).as_deref(), Some("v"));
+        assert_eq!(
+            r.derived(subject, "name"),
+            Derived::Value(DerivedValue::Str("vehicle".into()))
+        );
+    }
+}
+
+#[test]
+fn unnamed_satisfy_locators_do_not_collide_in_recursive_imports() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "names.sysml",
+            "package P {
+        requirement def Spec;
+        package Q {
+            package Requirements { requirement spec : Spec; }
+            package Parts { part v { satisfy Requirements::spec by v { part child; } } }
+        }
+        package U { public import Q::**; requirement r :> spec; }
+        alias satisfaction for Q::Parts::v::spec;
+    }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    let satisfy = r.resolve_qualified("P::Q::Parts::v::spec").unwrap();
+    assert_eq!(r.element_type(satisfy), "SatisfyRequirementUsage");
+    assert!(r.element_effective_name(satisfy).is_none());
+    assert!(
+        r.resolve_semantic_qualified("P::Q::Parts::v::spec")
+            .is_none()
+    );
+    assert!(
+        r.resolve_semantic_qualified("P::Q::Parts::v::spec::child")
+            .is_none()
+    );
+    assert_eq!(
+        r.resolve_semantic_qualified("P::satisfaction"),
+        Some(satisfy)
+    );
+    let actual = r.resolve_qualified("P::Q::Requirements::spec").unwrap();
+    assert_eq!(r.resolve_semantic_qualified("P::U::spec"), Some(actual));
+    let feature = r.resolve_qualified("P::U::r").unwrap();
+    let rel = r
+        .owned_relationships(feature)
+        .into_iter()
+        .find(|&e| r.element_type(e) == "Subsetting")
+        .unwrap();
+    assert_eq!(
+        r.element_properties(rel)["subsettedFeature"]["@id"],
+        r.element_id(actual).to_string()
+    );
+    assert!(r.unresolved_references().is_empty());
+}
+
+#[test]
+fn semantic_lookup_checks_short_names_aliases_and_unresolved_redefinitions() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "qualified.kerml",
+            "package <p> P {
+        feature <s> named; alias <a> other for named;
+        package Q { feature redefines missing; }
+    }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    let named = r.resolve_qualified("P::named").unwrap();
+    for name in ["P::named", "p::s", "P::other", "p::a"] {
+        assert_eq!(r.resolve_semantic_qualified(name), Some(named), "{name}");
+    }
+    assert!(r.resolve_qualified("P::Q::missing").is_some());
+    assert!(r.resolve_semantic_qualified("P::Q::missing").is_none());
+}
+
+#[test]
+fn subject_names_agree_with_library_backed_redefinition_and_export() {
+    let mut m = Model::new();
+    m.load_library_dir(&sysmlv2_testkit::library_dir()).unwrap();
+    assert!(
+        m.add_source(
+            "subject.sysml",
+            "part def Vehicle;
+        requirement def Spec { subject <v> vehicle : Vehicle; }
+        requirement req : Spec; part unit { satisfy req by unit; }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    let memberships: Vec<_> = r
+        .user_elements()
+        .filter(|&e| r.element_type(e) == "SubjectMembership")
+        .collect();
+    let subject = memberships
+        .into_iter()
+        .find_map(|m| {
+            let Derived::Value(DerivedValue::Element(f)) = r.derived(m, "ownedSubjectParameter")
+            else {
+                return None;
+            };
+            r.element_name(f).is_none().then_some(f)
+        })
+        .unwrap();
+    let target = r.resolve_qualified("Spec::vehicle").unwrap();
+    let Derived::Value(DerivedValue::Elements(redefinitions)) =
+        r.derived(subject, "ownedRedefinition")
+    else {
+        panic!()
+    };
+    assert_eq!(redefinitions.len(), 1);
+    assert_eq!(
+        r.property(redefinitions[0], "redefinedFeature").unwrap()["@id"],
+        r.element_id(target).to_string()
+    );
+    assert_eq!(
+        r.element_effective_name(subject),
+        r.element_effective_name(target)
+    );
+    assert_eq!(r.element_short_name(subject), r.element_short_name(target));
+    let full = sysmlv2_parser::full::model_to_full_json(&m);
+    let row = full
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|row| row["@id"] == r.element_id(subject).to_string())
+        .unwrap();
+    assert_eq!(row["name"], "vehicle");
+    assert_eq!(row["shortName"], "v");
+}
+
+#[test]
+fn multiple_replay_locators_do_not_hide_inherited_or_imported_names() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "multiple.sysml",
+            "package P {
+        requirement def Spec;
+        package R { requirement spec : Spec; }
+        part def Base { requirement spec : Spec; }
+        package Q { part v : Base { satisfy R::spec by v; satisfy R::spec by v; } }
+        package U { public import Q::**; requirement r :> spec; }
+    }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    let inherited = r.resolve_qualified("P::Base::spec").unwrap();
+    assert_eq!(r.resolve_semantic_qualified("P::U::spec"), Some(inherited));
+    assert_eq!(
+        r.resolve_semantic_qualified("P::Q::v::spec"),
+        Some(inherited)
+    );
+    assert!(r.unresolved_references().is_empty());
+    // Direct compatibility lookup retains its original ambiguity rather than
+    // reusing a semantic import query's cached inherited candidate.
+    assert!(r.resolve_qualified("P::Q::v::spec").is_none());
+}
+
+#[test]
+fn recursive_imports_keep_alias_names_and_declared_shadowing() {
+    let mut m = Model::new();
+    assert!(
+        m.add_source(
+            "aliases.sysml",
+            "package P {
+        requirement def Spec; requirement req : Spec;
+        part def Base { requirement spec : Spec; }
+        package Q {
+            part v : Base { requirement spec : Spec; satisfy req by v; }
+            alias satisfaction for v::req;
+        }
+        package U { public import Q::**; requirement r :> spec; }
+    }"
+        )
+        .diagnostics
+        .is_empty()
+    );
+    let mut r = ResolvedModel::build(&m);
+    let declared = r.resolve_qualified("P::Q::v::spec").unwrap();
+    let anonymous = r.resolve_qualified("P::Q::v::req").unwrap();
+    assert_eq!(r.resolve_semantic_qualified("P::U::spec"), Some(declared));
+    assert_eq!(
+        r.resolve_semantic_qualified("P::U::satisfaction"),
+        Some(anonymous)
+    );
+    assert!(r.resolve_semantic_qualified("P::U::req").is_none());
+    assert!(r.unresolved_references().is_empty());
+}
diff --git a/crates/sysmlv2-parser/tests/semantic_reads.rs b/crates/sysmlv2-parser/tests/semantic_reads.rs
new file mode 100644
index 0000000..a7bd843
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/semantic_reads.rs
@@ -0,0 +1,231 @@
+#![cfg(feature = "json")]
+
+use sysmlv2_parser::json::{
+    ClosurePolicy, DerivedValue, Derives, PropertyError, ResolvedModel, TypeInputIssue,
+    derives_under,
+};
+use sysmlv2_parser::model::Model;
+
+#[test]
+fn exact_reads_refuse_incomplete_closures_but_preserve_empty_and_null() {
+    let mut model = Model::new();
+    model.add_source("m.sysml", "package P { part def A; part def B :> A; }");
+    let mut r = ResolvedModel::build(&model);
+    let b = r.resolve_qualified("P::B").unwrap();
+    r.set_closure_policy(ClosurePolicy::Closure {
+        include_implied: true,
+    });
+    assert_eq!(
+        derives_under("PartDefinition", "inheritedMembership", r.closure_policy()),
+        Derives::Passthrough
+    );
+    // PartDefinition has a checked membership provider, but this model omits
+    // the canonical library ancestors needed to certify its complete closure.
+    assert_eq!(
+        r.derived_exact(b, "inheritedMembership"),
+        Err(PropertyError::IncompleteTypeFeatures(
+            TypeInputIssue::IncompleteProvider
+        ))
+    );
+    assert_eq!(
+        r.derived_exact(b, "ownedFeature"),
+        Ok(DerivedValue::Elements(vec![]))
+    );
+    assert_eq!(r.derived_exact(b, "shortName"), Ok(DerivedValue::Null));
+    assert_eq!(
+        r.derived_exact(b, "unknown"),
+        Err(PropertyError::NotDeclared)
+    );
+}
+
+#[test]
+fn checked_type_reads_refuse_incomplete_typing_before_compatibility_references() {
+    let mut model = Model::new();
+    model.add_source("m.sysml", "package P { part a : Missing; }");
+    let mut r = ResolvedModel::build(&model);
+    let a = r.resolve_qualified("P::a").unwrap();
+    assert!(
+        matches!(r.derived(a,"type"), sysmlv2_parser::json::Derived::Value(DerivedValue::References(ref values)) if values.iter().any(|v|matches!(v,sysmlv2_parser::json::Reference::Unresolved(_))))
+    );
+    assert_eq!(r.derived_exact(a, "type"), Err(PropertyError::Approximate));
+}
+
+#[test]
+fn exact_reads_check_required_values_and_keep_external_identity() {
+    use std::collections::HashMap;
+    use sysmlv2_parser::json::Reference;
+    let mut model = Model::new();
+    model.add_source(
+        "m.sysml",
+        "package P { attribute a = 1 + 2; port def D; port p : ~D; }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let plus = r
+        .elements()
+        .find(|&e| r.element_type(e) == "OperatorExpression")
+        .unwrap();
+    let typing = r
+        .elements()
+        .find(|&e| r.element_type(e) == "ConjugatedPortTyping")
+        .unwrap();
+    assert_eq!(
+        r.derived_exact(plus, "instantiatedType"),
+        Err(PropertyError::MissingRequiredValue)
+    );
+    let definition = r.resolve_qualified("P::D").unwrap();
+    assert_eq!(
+        r.derived_exact(typing, "portDefinition"),
+        Ok(DerivedValue::Element(definition))
+    );
+    let id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"test-plus");
+    r.set_library_names(&HashMap::from([(
+        id.to_string(),
+        vec!["BaseFunctions".into(), "+".into()],
+    )]));
+    assert_eq!(
+        r.derived_exact(plus, "instantiatedType"),
+        Ok(DerivedValue::Reference(Reference::External(id)))
+    );
+}
+
+#[test]
+fn semantic_reader_follows_redefinitions_and_requested_shape() {
+    let mut model = Model::new();
+    model.add_source(
+        "m.sysml",
+        "package P { part def D; part p : D; interface def I; }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let p = r.resolve_qualified("P::p").unwrap();
+    let d = r.resolve_qualified("P::D").unwrap();
+    let interface = r.resolve_qualified("P::I").unwrap();
+    let typing = r
+        .elements()
+        .find(|&e| r.element_type(e) == "FeatureTyping")
+        .unwrap();
+    let dref = serde_json::json!({"@id": r.element_id(d).to_string()});
+    let pref = serde_json::json!({"@id": r.element_id(p).to_string()});
+    assert_eq!(r.property(typing, "general").unwrap(), dref);
+    assert_eq!(r.property(typing, "type").unwrap(), dref);
+    assert_eq!(
+        r.property(typing, "target").unwrap(),
+        serde_json::json!([dref])
+    );
+    assert_eq!(r.property(typing, "specific").unwrap(), pref);
+    assert_eq!(
+        r.property(typing, "source").unwrap(),
+        serde_json::json!([pref])
+    );
+    assert_eq!(
+        r.property(interface, "isSufficient").unwrap(),
+        serde_json::json!(true)
+    );
+    assert_eq!(r.property(p, "isVariable"), Err(PropertyError::Approximate));
+    let owning = r.property(p, "owningRelationship").unwrap();
+    let membership = r.element_by_id(owning["@id"].as_str().unwrap()).unwrap();
+    assert_eq!(
+        r.property(membership, "memberName").unwrap(),
+        serde_json::json!("p")
+    );
+    assert_eq!(
+        r.property(membership, "ownedMemberName").unwrap(),
+        serde_json::json!("p")
+    );
+}
+
+#[test]
+fn semantic_reader_exposes_nonmembership_ownership_and_defaults() {
+    let mut model = Model::new();
+    model.add_source(
+        "m.sysml",
+        "package P { part a { part b; } part c; connection connect a.b to c; }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let chain = r
+        .elements()
+        .find(|&e| r.element_type(e) == "Feature")
+        .unwrap();
+    let relation = r.property(chain, "owningRelationship").unwrap();
+    let owner = r.element_by_id(relation["@id"].as_str().unwrap()).unwrap();
+    assert_eq!(r.element_type(owner), "ReferenceSubsetting");
+    assert_eq!(
+        r.property(owner, "ownedRelatedElement").unwrap(),
+        serde_json::json!([{"@id": r.element_id(chain).to_string()}])
+    );
+    assert_eq!(
+        r.property(chain, "isImpliedIncluded").unwrap(),
+        serde_json::json!(false)
+    );
+    assert_eq!(
+        r.property(chain, "isConstant").unwrap(),
+        serde_json::json!(false)
+    );
+}
+
+#[test]
+fn strict_export_refuses_incomplete_semantics_without_recovery() {
+    let mut model = Model::new();
+    model.add_source(
+        "m.sysml",
+        "package P { port p : Missing; attribute a = 1; }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let before = r.closure_policy();
+    let err = r.to_full_json_strict().unwrap_err();
+    assert!(err.issues.iter().any(|i| i.property == "result"));
+    assert!(
+        err.issues
+            .iter()
+            .any(|i| matches!(i.reason, PropertyError::UnresolvedReference(_)))
+    );
+    assert_eq!(r.closure_policy(), before);
+}
+
+#[test]
+fn strict_export_of_structural_namespace_has_no_placeholders() {
+    let mut model = Model::new();
+    model.add_source("m.sysml", "package P;");
+    let mut r = ResolvedModel::build(&model);
+    let value = r.to_full_json_strict().unwrap();
+    assert!(
+        value
+            .as_array()
+            .unwrap()
+            .iter()
+            .all(|e| e["isImpliedIncluded"] == false)
+    );
+    assert!(!value.to_string().contains("x-sysmlv2-unresolved-reference"));
+}
+
+#[test]
+fn checked_namespace_member_includes_alias_targets() {
+    let mut model = Model::new();
+    model.add_source(
+        "m.sysml",
+        "package P { package A; alias second for A; package Q { alias other for P::A; } }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let a = r.resolve_qualified("P::A").unwrap();
+    let q = r.resolve_qualified("P::Q").unwrap();
+    let p = r.resolve_qualified("P").unwrap();
+    assert_eq!(
+        r.property(p, "member").unwrap().as_array().unwrap().len(),
+        2
+    );
+    assert_eq!(
+        r.property(q, "member").unwrap(),
+        serde_json::json!([{"@id": r.element_id(a).to_string()}])
+    );
+    let export = r.to_full_json_strict().unwrap();
+    let qid = r.element_id(q).to_string();
+    let row = export
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|e| e["@id"] == qid)
+        .unwrap();
+    assert_eq!(
+        row["member"],
+        serde_json::json!([{"@id": r.element_id(a).to_string()}])
+    );
+}
diff --git a/crates/sysmlv2-parser/tests/shared_implied_plan.rs b/crates/sysmlv2-parser/tests/shared_implied_plan.rs
new file mode 100644
index 0000000..4cc4884
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/shared_implied_plan.rs
@@ -0,0 +1,159 @@
+#![cfg(feature = "json")]
+
+use std::collections::HashMap;
+use sysmlv2_parser::{
+    json::{ElementRef, ResolvedModel},
+    model::Model,
+};
+use uuid::Uuid;
+
+fn model(source: &str) -> ResolvedModel {
+    let mut model = Model::new();
+    model.add_library_source(
+        "parts.sysml",
+        "standard library package Parts { part def Part; part parts; }",
+    );
+    model.add_source("user.sysml", source);
+    assert!(!model.has_errors());
+    ResolvedModel::build(&model)
+}
+
+fn target_ids(r: &mut ResolvedModel, e: ElementRef, key: &str) -> Vec<String> {
+    r.implied_relationships(e)
+        .into_iter()
+        .filter_map(|rel| {
+            r.element_properties(rel)
+                .get(key)
+                .and_then(|v| v.get("@id"))
+                .and_then(|v| v.as_str())
+                .map(str::to_owned)
+        })
+        .collect()
+}
+
+#[test]
+fn shared_requirement_plan_rebuilds_after_explicit_id_override() {
+    let mut r = model("package U { variation part def Choice { variant part option; } }");
+    let choice = r.resolve_qualified("U::Choice").unwrap();
+    let option = r.resolve_qualified("U::Choice::option").unwrap();
+    r.inherited_memberships(option, true);
+    let target = Uuid::parse_str("12340000-0000-4000-8000-000000000001").unwrap();
+    r.override_ids(&HashMap::from([(r.element_id(choice), target)]));
+    assert_eq!(target_ids(&mut r, option, "type"), [target.to_string()]);
+}
+
+#[test]
+fn external_names_bypass_a_warm_loaded_library_requirement_plan() {
+    let mut r = model("package U { part def P; }");
+    let p = r.resolve_qualified("U::P").unwrap();
+    r.inherited_memberships(p, true);
+    let target = "12340000-0000-4000-8000-000000000002";
+    r.set_library_names(&HashMap::from([(
+        target.to_owned(),
+        vec!["Parts".to_owned(), "Part".to_owned()],
+    )]));
+    assert_eq!(
+        target_ids(&mut r, p, "superclassifier"),
+        [target.to_owned()]
+    );
+}
+
+#[test]
+fn bound_references_recompute_requirement_reachability_after_a_warm_query() {
+    let target = Uuid::parse_str("12340000-0000-4000-8000-000000000003").unwrap();
+    let mut r = model(&format!(
+        "package U {{ part def Base; part def Sub :> '{target}'; }}"
+    ));
+    let base = r.resolve_qualified("U::Base").unwrap();
+    let sub = r.resolve_qualified("U::Sub").unwrap();
+    r.override_ids(&HashMap::from([(r.element_id(base), target)]));
+    r.inherited_memberships(sub, true);
+    assert!(r.bind_id_spelled_references().contains(&target));
+    assert!(
+        target_ids(&mut r, sub, "superclassifier").is_empty(),
+        "the now-resolved Base already reaches the required Part"
+    );
+    assert!(r.conforms_with_implied(sub, base));
+}
+
+#[test]
+fn external_base_override_does_not_pair_against_the_loaded_library_base() {
+    for warm in [false, true] {
+        let mut source = Model::new();
+        source.add_library_source(
+            "parts.sysml",
+            "standard library package Parts { part def Part { end part a; } part parts; }",
+        );
+        source.add_source("user.sysml", "package U { part def R { end part x; } }");
+        assert!(!source.has_errors());
+        let mut r = ResolvedModel::build(&source);
+        let owner = r.resolve_qualified("U::R").unwrap();
+        let x = r.resolve_qualified("U::R::x").unwrap();
+        if warm {
+            r.inherited_memberships(owner, true);
+        }
+        let target = "12340000-0000-4000-8000-000000000004";
+        r.set_library_names(&HashMap::from([(
+            target.to_owned(),
+            vec!["Parts".to_owned(), "Part".to_owned()],
+        )]));
+        assert_eq!(
+            target_ids(&mut r, owner, "superclassifier"),
+            [target.to_owned()]
+        );
+        assert!(
+            target_ids(&mut r, x, "redefinedFeature").is_empty(),
+            "external base has unknown end ordering"
+        );
+    }
+}
+
+#[test]
+fn in_model_base_override_supplies_the_positional_member_sequence() {
+    let mut source = Model::new();
+    source.add_library_source("parts.sysml", "standard library package Parts { part def Part { end part a; } part def Alternate { end part b; } part parts; }");
+    source.add_source("user.sysml", "package U { part def R { end part x; } }");
+    assert!(!source.has_errors());
+    let mut r = ResolvedModel::build(&source);
+    let owner = r.resolve_qualified("U::R").unwrap();
+    let x = r.resolve_qualified("U::R::x").unwrap();
+    let base = r.resolve_qualified("Parts::Alternate").unwrap();
+    let b = r.resolve_qualified("Parts::Alternate::b").unwrap();
+    r.set_library_names(&HashMap::from([(
+        r.element_id(base).to_string(),
+        vec!["Parts".to_owned(), "Part".to_owned()],
+    )]));
+    assert_eq!(
+        target_ids(&mut r, owner, "superclassifier"),
+        [r.element_id(base).to_string()]
+    );
+    assert_eq!(
+        target_ids(&mut r, x, "redefinedFeature"),
+        [r.element_id(b).to_string()]
+    );
+}
+
+#[test]
+fn library_identity_overrides_update_loaded_and_supplied_name_indexes() {
+    for warm in [false, true] {
+        for supplied in [false, true] {
+            let mut r = model("package U { part def P; }");
+            let base = r.resolve_qualified("Parts::Part").unwrap();
+            let p = r.resolve_qualified("U::P").unwrap();
+            let old = r.element_id(base);
+            if supplied {
+                r.set_library_names(&HashMap::from([(
+                    old.to_string(),
+                    vec!["Parts".into(), "Part".into()],
+                )]));
+            }
+            if warm {
+                r.inherited_memberships(p, true);
+            }
+            let new = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"remapped library general");
+            r.override_ids(&HashMap::from([(old, new)]));
+            assert_eq!(target_ids(&mut r, p, "superclassifier"), [new.to_string()]);
+            assert!(r.conforms_with_implied(p, base));
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/static_rules.rs b/crates/sysmlv2-parser/tests/static_rules.rs
index 3be2a78..12dd54e 100644
--- a/crates/sysmlv2-parser/tests/static_rules.rs
+++ b/crates/sysmlv2-parser/tests/static_rules.rs
@@ -788,3 +788,33 @@ fn standalone_typing_participates_in_binding_conformance() {
         );
     }
 }
+
+#[test]
+fn fixed_value_override_names_the_original_binding_even_for_equal_values() {
+    for (base_value, new_value, rejected) in [
+        ("= 1", "= 1", true),
+        ("= 1", "default = 1", true),
+        ("default = 1", "= 2", false),
+    ] {
+        let mut model = Model::new();
+        model.add_source("base.kerml", &format!("class Base {{\n    feature mass {base_value};\n}}\nclass Mid specializes Base {{ feature redefines mass; }}"));
+        let source =
+            format!("class Child specializes Mid {{ feature redefines mass {new_value}; }}");
+        model.add_source("child.kerml", &source);
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let findings: Vec<_> = check::validate_semantics_with(&mut r, &model)
+            .into_iter()
+            .filter(|(_, d)| d.code == Some("validateFeatureValueOverriding"))
+            .collect();
+        assert_eq!(findings.len(), usize::from(rejected), "{findings:?}");
+        if rejected {
+            let (unit, d) = &findings[0];
+            assert_eq!(*unit, 1);
+            assert_eq!(d.span.slice(&source), "1");
+            assert!(d.message.contains("`Base::mass`"), "{d:?}");
+            assert!(d.message.contains("base.kerml:2:"), "{d:?}");
+            assert!(d.message.contains("inherited value must be default"));
+        }
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/supertypes_operation.rs b/crates/sysmlv2-parser/tests/supertypes_operation.rs
new file mode 100644
index 0000000..9f48b33
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/supertypes_operation.rs
@@ -0,0 +1,165 @@
+#![cfg(feature = "json")]
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_parser::{
+    json::{
+        ClosurePolicy, DerivedValue, OperationArgumentIssue, OperationError, Reference,
+        ResolvedModel,
+    },
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+use uuid::Uuid;
+const SUPERTYPES: &str = "Core-Types-Type-supertypes_Boolean";
+fn models(library: &str, user: &str) -> Vec<(Model, ResolvedModel)> {
+    models_named(library, user, "calls.kerml")
+}
+fn models_named(library: &str, user: &str, user_name: &str) -> Vec<(Model, ResolvedModel)> {
+    let mut base = Model::new();
+    assert!(
+        base.add_library_source("functions.kerml", library)
+            .diagnostics
+            .is_empty()
+    );
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(71).unwrap(), 71).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("functions.kerml", library);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            assert!(model.add_source(user_name, user).diagnostics.is_empty());
+            let resolved = ResolvedModel::build(&model);
+            (model, resolved)
+        })
+        .collect()
+}
+
+#[test]
+fn explicit_direct_supertypes_preserve_order_conjugation_and_chain_identity() {
+    for (model, mut r) in models(
+        "package L {class A; class B;}",
+        "class C specializes L::A,L::B; class D conjugates C; class E conjugates D; class T {feature x;} feature p:T; feature q chains p.x; class Missing specializes L::A,Unknown; class Duplicate specializes L::A,L::A;",
+    ) {
+        let loaded = model.loaded_library_unit_count();
+        let a = r.resolve_qualified("L::A").unwrap();
+        let b = r.resolve_qualified("L::B").unwrap();
+        let c = r.resolve_qualified("C").unwrap();
+        let d = r.resolve_qualified("D").unwrap();
+        let e = r.resolve_qualified("E").unwrap();
+        let p = r.resolve_qualified("p").unwrap();
+        let t = r.resolve_qualified("T").unwrap();
+        let q = r.resolve_qualified("q").unwrap();
+        let x = r.resolve_qualified("T::x").unwrap();
+        let before: Vec<_> = r
+            .user_elements()
+            .map(|e| {
+                (
+                    r.element_id(e),
+                    r.element_properties(e),
+                    r.owned_relationships(e),
+                )
+            })
+            .collect();
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            for _ in 0..2 {
+                for (receiver, targets) in [
+                    (a, vec![]),
+                    (c, vec![a, b]),
+                    (d, vec![c]),
+                    (e, vec![d]),
+                    (p, vec![t]),
+                    (q, vec![x]),
+                ] {
+                    let result = r
+                        .invoke_operation(receiver, SUPERTYPES, &[DerivedValue::Bool(true)])
+                        .unwrap();
+                    assert_eq!(
+                        result.value,
+                        DerivedValue::References(
+                            targets.into_iter().map(Reference::Element).collect()
+                        )
+                    );
+                    if receiver == q {
+                        assert_eq!(result.effective, "Core-Features-Feature-supertypes_Boolean");
+                    }
+                }
+            }
+            for (receiver, target) in [(d, c), (e, d)] {
+                assert_eq!(
+                    r.invoke_operation(receiver, SUPERTYPES, &[DerivedValue::Bool(false)])
+                        .unwrap()
+                        .value,
+                    DerivedValue::References(vec![Reference::Element(target)])
+                );
+            }
+            for name in ["Missing", "Duplicate"] {
+                let receiver = r.resolve_qualified(name).unwrap();
+                assert!(matches!(
+                    r.invoke_operation(receiver, SUPERTYPES, &[DerivedValue::Bool(true)]),
+                    Err(OperationError::Incomplete { .. })
+                ));
+            }
+            assert!(matches!(
+                r.invoke_operation(c, SUPERTYPES, &[DerivedValue::Bool(false)]),
+                Err(OperationError::UnsupportedConfiguration { .. })
+            ));
+            assert!(matches!(
+                r.invoke_operation(c, SUPERTYPES, &[DerivedValue::Str("true".into())]),
+                Err(OperationError::InvalidArgument {
+                    issue: OperationArgumentIssue::WrongShape,
+                    ..
+                })
+            ));
+            assert!(matches!(
+                r.invoke_operation(c, SUPERTYPES, &[DerivedValue::Null]),
+                Err(OperationError::InvalidArgument {
+                    issue: OperationArgumentIssue::NullNotAllowed,
+                    ..
+                })
+            ));
+        }
+        let after: Vec<_> = r
+            .user_elements()
+            .map(|e| {
+                (
+                    r.element_id(e),
+                    r.element_properties(e),
+                    r.owned_relationships(e),
+                )
+            })
+            .collect();
+        assert_eq!(before, after);
+        let id = Uuid::new_v4();
+        r.override_ids(&HashMap::from([(r.element_id(a), id)]));
+        assert_eq!(
+            r.invoke_operation(c, SUPERTYPES, &[DerivedValue::Bool(true)])
+                .unwrap()
+                .value,
+            DerivedValue::References(vec![Reference::Element(a), Reference::Element(b)])
+        );
+        assert_eq!(model.loaded_library_unit_count(), loaded);
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/sysml_assertion_roles.rs b/crates/sysmlv2-parser/tests/sysml_assertion_roles.rs
new file mode 100644
index 0000000..9475a06
--- /dev/null
+++ b/crates/sysmlv2-parser/tests/sysml_assertion_roles.rs
@@ -0,0 +1,210 @@
+#![cfg(feature = "json")]
+use std::sync::Arc;
+use sysmlv2_parser::{
+    json::{ClosurePolicy, ResolvedModel, model_to_compact_json},
+    libcache::LibraryCache,
+    model::Model,
+    prepared::PreparedLibrary,
+};
+
+#[test]
+fn actual_library_assertion_roles_replay_with_identity_and_source_stability() {
+    let library = sysmlv2_testkit::library_dir();
+    if !library.is_dir() {
+        eprintln!("skipping: standard library unavailable");
+        return;
+    }
+    let mut base = Model::new();
+    base.load_library_dir(&library).unwrap();
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let recorded =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(91).unwrap(), 91).unwrap());
+    let mut replay_ids = None;
+    for mode in 0..4 {
+        let mut m = Model::new();
+        match mode {
+            2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+            3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+            _ => {
+                m.load_library_dir(&library).unwrap();
+                if mode == 1 {
+                    m.set_library_cache(recorded.clone());
+                }
+            }
+        }
+        let parsed=m.add_source("assertion-roles.sysml","package P { constraint plain {true} requirement ordinary; assert constraint yes {true} assert not constraint no {false} part thing; requirement def R { subject s; } satisfy requirement sat : R by thing; not satisfy requirement unsat : R by thing; assert constraint direct :> Constraints::assertedConstraintChecks; assert constraint indirect :> direct; satisfy requirement directSat :> Requirements::satisfiedRequirementChecks; satisfy requirement indirectSat :> directSat; }");
+        assert!(
+            parsed.diagnostics.is_empty(),
+            "mode {mode}: {:?}",
+            parsed.diagnostics
+        );
+        let compact = model_to_compact_json(&m);
+        let mut r = ResolvedModel::build(&m);
+        let source_ids: Vec<_> = r.user_elements().map(|e| r.element_id(e)).collect();
+        let cases: Vec<_> = [
+            (
+                "P::yes",
+                "AssertConstraintUsage",
+                "Constraints::assertedConstraintChecks",
+                false,
+            ),
+            (
+                "P::no",
+                "AssertConstraintUsage",
+                "Constraints::negatedConstraintChecks",
+                true,
+            ),
+            (
+                "P::sat",
+                "SatisfyRequirementUsage",
+                "Requirements::satisfiedRequirementChecks",
+                false,
+            ),
+            (
+                "P::unsat",
+                "SatisfyRequirementUsage",
+                "Requirements::notSatisfiedRequirementChecks",
+                true,
+            ),
+        ]
+        .into_iter()
+        .map(|(name, kind, role, negated)| {
+            let owner = r.resolve_qualified(name).unwrap();
+            let role = r.resolve_qualified(role).unwrap();
+            assert_eq!(r.element_type(owner), kind);
+            assert_eq!(
+                r.element_type(role),
+                if kind == "SatisfyRequirementUsage" {
+                    "RequirementUsage"
+                } else {
+                    "ConstraintUsage"
+                }
+            );
+            (owner, role, negated)
+        })
+        .collect();
+        let mut policy_ids = None;
+        for policy in [
+            ClosurePolicy::Passthrough,
+            ClosurePolicy::Closure {
+                include_implied: false,
+            },
+            ClosurePolicy::Closure {
+                include_implied: true,
+            },
+        ] {
+            r.set_closure_policy(policy);
+            let mut ids = Vec::new();
+            for &(owner, role, negated) in &cases {
+                assert_eq!(
+                    r.property(owner, "isNegated").unwrap(),
+                    serde_json::json!(negated)
+                );
+                assert!(r.conforms_with_implied(owner, role));
+                let assertion = if negated {
+                    "Constraints::negatedConstraintChecks"
+                } else {
+                    "Constraints::assertedConstraintChecks"
+                };
+                let invariant = if negated {
+                    "Performances::falseEvaluations"
+                } else {
+                    "Performances::trueEvaluations"
+                };
+                for parent in [
+                    assertion,
+                    invariant,
+                    "Constraints::constraintChecks",
+                    "Performances::booleanEvaluations",
+                    "Performances::evaluations",
+                ] {
+                    let parent = r.resolve_qualified(parent).unwrap();
+                    assert!(r.conforms_with_implied(owner, parent), "{parent:?}");
+                }
+                let role_id = r.element_id(role);
+                let rows = r.implied_relationships(owner);
+                let direct: Vec<_> = rows
+                    .iter()
+                    .copied()
+                    .filter(|&row| {
+                        r.element_properties(row)["subsettedFeature"]["@id"] == role_id.to_string()
+                    })
+                    .collect();
+                assert_eq!(direct.len(), 1);
+                let key = format!("{}/implied/Subsetting/{}", r.element_id(owner), role_id);
+                assert_eq!(
+                    r.element_id(direct[0]),
+                    uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, key.as_bytes())
+                );
+                for redundant in [
+                    "Constraints::constraintChecks",
+                    "Requirements::requirementChecks",
+                    assertion,
+                    invariant,
+                    "Performances::booleanEvaluations",
+                    "Performances::evaluations",
+                ] {
+                    let redundant = r.resolve_qualified(redundant).unwrap();
+                    if redundant != role {
+                        assert!(
+                            !rows
+                                .iter()
+                                .any(|&row| r.element_properties(row)["subsettedFeature"]["@id"]
+                                    == r.element_id(redundant).to_string()),
+                            "redundant inherited role"
+                        );
+                    }
+                }
+                ids.extend(rows.into_iter().map(|row| r.element_id(row)));
+            }
+            for (name, role) in [
+                ("P::plain", "Constraints::constraintChecks"),
+                ("P::ordinary", "Requirements::requirementChecks"),
+            ] {
+                let owner = r.resolve_qualified(name).unwrap();
+                let role = r.resolve_qualified(role).unwrap();
+                let role_id = r.element_id(role).to_string();
+                let rows = r.implied_relationships(owner);
+                let row = *rows
+                    .iter()
+                    .find(|&&row| r.element_properties(row)["subsettedFeature"]["@id"] == role_id)
+                    .unwrap();
+                let key = format!("{}/implied0", r.element_id(owner));
+                assert_eq!(
+                    r.element_id(row),
+                    uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, key.as_bytes()),
+                    "surviving legacy obligation changed identity"
+                );
+                ids.push(r.element_id(row));
+            }
+            for name in ["P::direct", "P::indirect", "P::directSat", "P::indirectSat"] {
+                let owner = r.resolve_qualified(name).unwrap();
+                assert!(
+                    r.implied_relationships(owner).is_empty(),
+                    "redundant explicit path {name}"
+                );
+            }
+            if let Some(expected) = &policy_ids {
+                assert_eq!(&ids, expected)
+            } else {
+                policy_ids = Some(ids)
+            }
+        }
+        if let Some(expected) = &replay_ids {
+            assert_eq!(&policy_ids, expected)
+        } else {
+            replay_ids = Some(policy_ids)
+        }
+        assert_eq!(
+            source_ids,
+            r.user_elements()
+                .map(|e| r.element_id(e))
+                .collect::<Vec<_>>()
+        );
+        assert_eq!(compact, model_to_compact_json(&m));
+    }
+}
diff --git a/crates/sysmlv2-parser/tests/xmi_audit.rs b/crates/sysmlv2-parser/tests/xmi_audit.rs
index f2bb434..0547e79 100644
--- a/crates/sysmlv2-parser/tests/xmi_audit.rs
+++ b/crates/sysmlv2-parser/tests/xmi_audit.rs
@@ -185,7 +185,10 @@ fn corpus_model() -> Model {
         .expect("library loads");
     for f in testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     assert!(!model.has_errors(), "corpus parses clean");
     model
diff --git a/crates/sysmlv2-py/Cargo.toml b/crates/sysmlv2-py/Cargo.toml
index 30863bc..3561f37 100644
--- a/crates/sysmlv2-py/Cargo.toml
+++ b/crates/sysmlv2-py/Cargo.toml
@@ -17,10 +17,10 @@ name = "sysmlv2"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
-sysmlv2-transform = { path = "../sysmlv2-transform", version = "0.9.1" }
-sysmlv2-viz = { path = "../sysmlv2-viz", version = "0.9.1" }
-sysmlv2-lsp = { path = "../sysmlv2-lsp", version = "0.9.1" }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
+sysmlv2-transform = { path = "../sysmlv2-transform", version = "0.10.0" }
+sysmlv2-viz = { path = "../sysmlv2-viz", version = "0.10.0" }
+sysmlv2-lsp = { path = "../sysmlv2-lsp", version = "0.10.0" }
 serde_json.workspace = true
 pyo3 = { version = "0.29", features = ["abi3-py39"] }
diff --git a/crates/sysmlv2-py/src/lib.rs b/crates/sysmlv2-py/src/lib.rs
index 386fcc2..dba0036 100644
--- a/crates/sysmlv2-py/src/lib.rs
+++ b/crates/sysmlv2-py/src/lib.rs
@@ -765,6 +765,14 @@ impl Session {
         Ok(self.inner.resolved().conforms(e.e, ancestor.e))
     }
 
+    /// Reachability including supported implied library and variation bases.
+    /// A negative result does not establish complete non-conformance.
+    fn conforms_with_implied(&mut self, e: &Element, ancestor: &Element) -> PyResult<bool> {
+        self.guard(e.gen)?;
+        self.guard(ancestor.gen)?;
+        Ok(self.inner.resolved().conforms_with_implied(e.e, ancestor.e))
+    }
+
     /// Every element of the given metaclass.
     fn elements_of_metaclass(&mut self, ty: &str) -> Vec<Element> {
         let gen = self.gen;
@@ -851,6 +859,25 @@ impl Session {
             .expect("serializable")
     }
 
+    /// Checked owned/derived property as JSON, with references encoded by ID.
+    fn property_json(&mut self, e: &Element, name: &str) -> PyResult<String> {
+        self.guard(e.gen)?;
+        self.inner
+            .resolved()
+            .property(e.e, name)
+            .map(|v| v.to_string())
+            .map_err(refused)
+    }
+
+    /// Strict full JSON; refuses approximate or unavailable properties.
+    #[allow(clippy::wrong_self_convention)] // Lazy semantic caches require mutable access.
+    fn to_full_json_strict(&mut self) -> PyResult<String> {
+        self.inner
+            .to_full_json_strict()
+            .map(|v| v.to_string())
+            .map_err(refused)
+    }
+
     /// Map an interchange document's ids to this session's ids by
     /// qualified name: `[(input id, session id)]`.
     fn id_map_from(&mut self, json: &str) -> PyResult<Vec<(String, String)>> {
diff --git a/crates/sysmlv2-py/tests/implied_conformance.py b/crates/sysmlv2-py/tests/implied_conformance.py
new file mode 100644
index 0000000..9cbdb98
--- /dev/null
+++ b/crates/sysmlv2-py/tests/implied_conformance.py
@@ -0,0 +1,25 @@
+"""Implied-conformance reachability and stale-handle guards."""
+import pathlib
+import tempfile
+import sysmlv2
+
+# Implied conformance is additive; both element arguments remain guarded.
+with tempfile.TemporaryDirectory() as library_dir:
+    pathlib.Path(library_dir, "Parts.kerml").write_text(
+        "standard library package Parts { class Part; }", encoding="utf-8"
+    )
+    implied_session = sysmlv2.Session.from_sources([("p.sysml", "package P { part def Box; }")])
+    stale_box = implied_session.resolve("P::Box")
+    implied_session.load_library(library_dir)
+    box = implied_session.resolve("P::Box")
+    part = implied_session.resolve("Parts::Part")
+    assert not implied_session.conforms(box, part)
+    assert implied_session.conforms_with_implied(box, part)
+    for source, target in [(stale_box, part), (box, stale_box)]:
+        try:
+            implied_session.conforms_with_implied(source, target)
+            raise AssertionError("stale argument must raise")
+        except ValueError:
+            pass
+
+print("implied conformance: passed")
diff --git a/crates/sysmlv2-py/tests/smoke.py b/crates/sysmlv2-py/tests/smoke.py
index 91b8c0f..7716132 100644
--- a/crates/sysmlv2-py/tests/smoke.py
+++ b/crates/sysmlv2-py/tests/smoke.py
@@ -70,7 +70,9 @@
 s2.set_closure_policy("closure")
 assert s2.closure_policy() == "closure"
 assert [s2.name(f) for f in s2.derived(b, "feature")] == ["x"]
-s2.edit([{"op": "moveMember", "target": "O::w", "index": 0}])
+closure_edit = s2.edit()
+closure_edit.rename(w, "renamed")
+s2.commit(closure_edit)
 assert s2.closure_policy() == "closure"
 s2.set_closure_policy("passthrough")
 
diff --git a/crates/sysmlv2-solve/Cargo.toml b/crates/sysmlv2-solve/Cargo.toml
index 9248191..fce3969 100644
--- a/crates/sysmlv2-solve/Cargo.toml
+++ b/crates/sysmlv2-solve/Cargo.toml
@@ -12,8 +12,8 @@ repository.workspace = true
 include = ["src/**", "Cargo.toml"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
 
 [dev-dependencies]
 sysmlv2-testkit.workspace = true
diff --git a/crates/sysmlv2-solve/examples/solvestats.rs b/crates/sysmlv2-solve/examples/solvestats.rs
index d8e1df1..0e94ee6 100644
--- a/crates/sysmlv2-solve/examples/solvestats.rs
+++ b/crates/sysmlv2-solve/examples/solvestats.rs
@@ -17,7 +17,10 @@ fn main() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let solved = solve_constraints(&model, &cfg).unwrap();
     let (mut sat, mut vio, mut und) = (0, 0, 0);
diff --git a/crates/sysmlv2-solve/examples/unknowns.rs b/crates/sysmlv2-solve/examples/unknowns.rs
index 3ff3897..aa32fbf 100644
--- a/crates/sysmlv2-solve/examples/unknowns.rs
+++ b/crates/sysmlv2-solve/examples/unknowns.rs
@@ -14,7 +14,10 @@ fn main() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let solved = solve_constraints(&model, &SolverConfig::default()).unwrap();
     let mut by_reason: BTreeMap<String, Vec<String>> = BTreeMap::new();
diff --git a/crates/sysmlv2-solve/src/lib.rs b/crates/sysmlv2-solve/src/lib.rs
index 4f59b6e..2c55744 100644
--- a/crates/sysmlv2-solve/src/lib.rs
+++ b/crates/sysmlv2-solve/src/lib.rs
@@ -218,20 +218,39 @@ pub fn solve_constraints(
 ) -> Result<Vec<SolvedConstraint>, SolveError> {
     z3_version(cfg)?;
     let mut r = ResolvedModel::build(model);
-    let tables = translate::EnumTables::build(&r);
+    solve_resolved(&mut r, model, cfg)
+}
+
+/// Solve against an existing resolved graph, preserving its bound identities.
+/// `model` must be the source model from which `r` was built.
+pub fn solve_constraints_with(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &SolverConfig,
+) -> Result<Vec<SolvedConstraint>, SolveError> {
+    z3_version(cfg)?;
+    solve_resolved(r, model, cfg)
+}
+
+fn solve_resolved(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &SolverConfig,
+) -> Result<Vec<SolvedConstraint>, SolveError> {
+    let tables = translate::EnumTables::build(r);
     let mut out = Vec::new();
     for c in r.constraints() {
         if model.is_library_unit(c.unit) {
             continue;
         }
-        let verdict = constraint_verdict(&mut r, &c);
+        let verdict = constraint_verdict(r, &c);
         let solve = match &verdict {
-            ConstraintVerdict::Undecided(_) => Some(solve_one(&mut r, &tables, &c, cfg, None)),
+            ConstraintVerdict::Undecided(_) => Some(solve_one(r, &tables, &c, cfg, None)),
             _ => None,
         };
         let bindings = match verdict {
             ConstraintVerdict::Satisfied => Vec::new(),
-            _ => constraint_bindings(&mut r, &c),
+            _ => constraint_bindings(r, &c),
         };
         out.push(SolvedConstraint {
             unit: c.unit,
@@ -294,7 +313,9 @@ pub struct FeatureRange {
 #[non_exhaustive]
 pub enum PropagateOutcome {
     /// The body's forward interval is `{true}`: holds for every assignment
-    /// consistent with the narrowed domains.
+    /// consistent with the narrowed domains. If translation approximated any
+    /// feature definition in the joint unit, the body must also be true over
+    /// the declaration domains before asserted constraints narrow them.
     Satisfied,
     /// The body's forward interval is `{false}`: holds for none.
     Violated,
@@ -354,18 +375,28 @@ pub struct Propagation {
 #[must_use]
 pub fn propagate_constraints(model: &Model, cfg: &PropagateConfig) -> Propagation {
     let mut r = ResolvedModel::build(model);
-    let tables = translate::EnumTables::build(&r);
-    let all = user_constraints(&mut r, model);
-    let verdicts: Vec<ConstraintVerdict> =
-        all.iter().map(|c| constraint_verdict(&mut r, c)).collect();
-    let (outcomes, ranges, features) = propagate_core(&mut r, &tables, &all, &verdicts, cfg);
+    propagate_constraints_with(&mut r, model, cfg)
+}
+
+/// Propagate against an existing resolved graph, preserving its bound identities.
+/// `model` must be the source model from which `r` was built.
+#[must_use]
+pub fn propagate_constraints_with(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &PropagateConfig,
+) -> Propagation {
+    let tables = translate::EnumTables::build(r);
+    let all = user_constraints(r, model);
+    let verdicts: Vec<ConstraintVerdict> = all.iter().map(|c| constraint_verdict(r, c)).collect();
+    let (outcomes, ranges, features) = propagate_core(r, &tables, &all, &verdicts, cfg);
     let constraints = all
         .iter()
         .enumerate()
         .map(|(i, c)| {
             let bindings = match verdicts[i] {
                 ConstraintVerdict::Satisfied => Vec::new(),
-                _ => constraint_bindings(&mut r, c),
+                _ => constraint_bindings(r, c),
             };
             PropagatedConstraint {
                 unit: c.unit,
@@ -447,7 +478,7 @@ fn propagate_core(
         let cs: Vec<&sysmlv2_model::json::ConstraintInfo> = idxs.iter().map(|&i| &all[i]).collect();
         let jt = match translate::translate_all(r, tables, &cs) {
             Ok(jt) => jt,
-            Err(translate::Unsupported(m)) => {
+            Err(translate::Unsupported(m, _)) => {
                 for &i in idxs {
                     if undecided(i) {
                         outcomes[i] = Some(PropagateOutcome::Unsupported(format!(
@@ -529,7 +560,25 @@ fn propagate_core(
                 // operand, so a reference to an emptied feature reads as
                 // `Empty` here.)
                 translate::JointRoot::Root(t) => match ival::eval_term(t, &doms) {
-                    ival::Dom::B(ival::Tri::True) => PropagateOutcome::Satisfied,
+                    ival::Dom::B(ival::Tri::True) => {
+                        // Approximate definitions can affect other roots through
+                        // shared variables. Only declaration-only validity may
+                        // certify a positive result in an approximate joint unit.
+                        // Exact translations retain their existing fast path.
+                        if jt.approx.is_empty()
+                            || matches!(
+                                ival::eval_term(t, &baseline),
+                                ival::Dom::B(ival::Tri::True)
+                            )
+                        {
+                            PropagateOutcome::Satisfied
+                        } else {
+                            PropagateOutcome::Unsupported(format!(
+                                "cannot certify satisfaction with approximated definitions: `{}`",
+                                jt.approx.join("`, `")
+                            ))
+                        }
+                    }
                     ival::Dom::B(ival::Tri::False) => PropagateOutcome::Violated,
                     d if d.is_empty() => PropagateOutcome::Unsatisfiable,
                     _ => PropagateOutcome::Undecided,
@@ -619,11 +668,33 @@ pub fn verify_constraints(
         z3_version(cfg)?;
     }
     let mut r = ResolvedModel::build(model);
-    let tables = translate::EnumTables::build(&r);
-    let all = user_constraints(&mut r, model);
-    let verdicts: Vec<ConstraintVerdict> =
-        all.iter().map(|c| constraint_verdict(&mut r, c)).collect();
-    let (propagate, ranges, features) = propagate_core(&mut r, &tables, &all, &verdicts, prop_cfg);
+    verify_resolved(&mut r, model, solver, prop_cfg)
+}
+
+/// Verify against an existing resolved graph, preserving its bound identities.
+/// `model` must be the source model from which `r` was built.
+pub fn verify_constraints_with(
+    r: &mut ResolvedModel,
+    model: &Model,
+    solver: Option<&SolverConfig>,
+    prop_cfg: &PropagateConfig,
+) -> Result<VerifyReport, SolveError> {
+    if let Some(cfg) = solver {
+        z3_version(cfg)?;
+    }
+    verify_resolved(r, model, solver, prop_cfg)
+}
+
+fn verify_resolved(
+    r: &mut ResolvedModel,
+    model: &Model,
+    solver: Option<&SolverConfig>,
+    prop_cfg: &PropagateConfig,
+) -> Result<VerifyReport, SolveError> {
+    let tables = translate::EnumTables::build(r);
+    let all = user_constraints(r, model);
+    let verdicts: Vec<ConstraintVerdict> = all.iter().map(|c| constraint_verdict(r, c)).collect();
+    let (propagate, ranges, features) = propagate_core(r, &tables, &all, &verdicts, prop_cfg);
 
     let mut constraints = Vec::with_capacity(all.len());
     for (i, c) in all.iter().enumerate() {
@@ -634,13 +705,13 @@ pub fn verify_constraints(
                 if matches!(verdicts[i], ConstraintVerdict::Undecided(_))
                     && !propagation_is_definitive(&propagate[i]) =>
             {
-                Some(solve_one(&mut r, &tables, c, cfg, Some(prop_cfg)))
+                Some(solve_one(r, &tables, c, cfg, Some(prop_cfg)))
             }
             _ => None,
         };
         let bindings = match verdicts[i] {
             ConstraintVerdict::Satisfied => Vec::new(),
-            _ => constraint_bindings(&mut r, c),
+            _ => constraint_bindings(r, c),
         };
         constraints.push(VerifiedConstraint {
             unit: c.unit,
@@ -744,7 +815,7 @@ fn solve_one(
 ) -> SolveOutcome {
     let tr = match translate::translate(r, tables, c) {
         Ok(tr) => tr,
-        Err(translate::Unsupported(m)) => {
+        Err(translate::Unsupported(m, _)) => {
             return SolveOutcome::Unknown(format!("not in the solvable fragment: {m}"));
         }
     };
@@ -972,7 +1043,10 @@ mod witness_containment {
             .unwrap();
         for f in sysmlv2_testkit::user_files() {
             let src = std::fs::read_to_string(&f).unwrap();
-            model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+            model.add_source(
+                sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+                &src,
+            );
         }
         let mut r = ResolvedModel::build(&model);
         let tables = translate::EnumTables::build(&r);
@@ -1114,7 +1188,10 @@ mod bound_injection {
             .unwrap();
         for f in sysmlv2_testkit::user_files() {
             let src = std::fs::read_to_string(&f).unwrap();
-            model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+            model.add_source(
+                sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+                &src,
+            );
         }
         let mut r = ResolvedModel::build(&model);
         let tables = translate::EnumTables::build(&r);
diff --git a/crates/sysmlv2-solve/src/translate.rs b/crates/sysmlv2-solve/src/translate.rs
index 8e35beb..71cf2a6 100644
--- a/crates/sysmlv2-solve/src/translate.rs
+++ b/crates/sysmlv2-solve/src/translate.rs
@@ -34,16 +34,60 @@
 use crate::term::{EnumSort, Op, Sort, Term};
 use std::collections::{HashMap, HashSet, VecDeque};
 use sysmlv2_model::eval::Value;
-use sysmlv2_model::json::{ConstraintInfo, ElementRef, ResolvedModel, ScopeRef};
+use sysmlv2_model::json::{
+    CallableBody, CallableResult, ConstraintInfo, ElementRef, ResolvedModel, RuntimeFrame,
+    RuntimeFrameProof, ScopeRef,
+};
 use sysmlv2_model::rational::Rational;
 use sysmlv2_syntax::ast::*;
 
 /// The construct (with context) that put an expression outside the
 /// solvable fragment.
-pub(crate) struct Unsupported(pub String);
+pub(crate) struct Unsupported(pub String, pub bool);
+
+impl Unsupported {
+    fn ordinary(message: String) -> Self {
+        Self(message, false)
+    }
+
+    /// Runtime dependencies cannot be replaced by declaration variables, even
+    /// after unwinding through outer value expressions.
+    fn runtime(mut self) -> Self {
+        self.1 = true;
+        self
+    }
+}
 
 fn bail<T>(msg: impl Into<String>) -> Result<T, Unsupported> {
-    Err(Unsupported(msg.into()))
+    Err(Unsupported::ordinary(msg.into()))
+}
+
+/// The reason a feature cannot stand for one value. A usage that is a
+/// collection only by the implicit default (a package-owned attribute
+/// written without a multiplicity) names the one-line fix; any other
+/// unknown or non-scalar cardinality is reported as such.
+fn not_one_value(r: &mut ResolvedModel, elem: ElementRef, display: &str) -> Unsupported {
+    if r.implicit_open_multiplicity(elem) {
+        Unsupported::ordinary(format!(
+            "`{display}` declares no multiplicity, so it is a collection of any size; declare `[1]` for one value"
+        ))
+    } else {
+        Unsupported::ordinary(format!("non-scalar or unknown cardinality of `{display}`"))
+    }
+}
+
+/// [`not_one_value`] for a chain's intermediate feature.
+fn not_one_receiver(r: &mut ResolvedModel, elem: ElementRef, display: &str) -> Unsupported {
+    let name = r.render_value(&Value::Unbound(elem));
+    if r.implicit_open_multiplicity(elem) {
+        Unsupported::ordinary(format!(
+            "a chain through `{name}`, which declares no multiplicity and so is a collection of any size; declare `[1]` on it for one value"
+        ))
+    } else if display.is_empty() {
+        Unsupported::ordinary("a chain through an unbound collection".to_string())
+    } else {
+        Unsupported::ordinary(format!("a chain through an unbound collection `{display}`"))
+    }
 }
 
 /// One free SMT constant.
@@ -119,6 +163,14 @@ enum SortState {
 enum Binding {
     /// An ordinary scalar term (calculation arguments, sequence items).
     Scalar(Term, Option<UTag>),
+    /// A singleton retains its model identity and receiver expression, so
+    /// lambda member access follows the same rules as ordinary navigation.
+    Singleton {
+        feature: ElementRef,
+        scope: ScopeRef,
+        target: Box<Expr>,
+        source: Option<ElementRef>,
+    },
     /// The k-th anonymous member of a skolemized bounded collection:
     /// a bare reference mints one variable per instance
     /// (`path`, sorted like the collection feature); chains resolve
@@ -127,9 +179,19 @@ enum Binding {
         feature: ElementRef,
         ty: Option<ElementRef>,
         path: String,
+        key: InstanceKey,
     },
 }
 
+/// Semantic identity of one expanded member and its navigation path.
+/// Source spellings are presentation only: aliases must share variables.
+#[derive(Clone, Hash, PartialEq, Eq)]
+struct InstanceKey {
+    root: ElementRef,
+    ordinal: usize,
+    members: Vec<(ElementRef, Option<ScopeRef>)>,
+}
+
 /// Cap on skolem instances per collection — quantifier expansion is
 /// n × body-size, so a runaway multiplicity must stay a bail, not a blowup.
 const SKOLEM_CAP: usize = 32;
@@ -173,17 +235,18 @@ pub(crate) enum JointRoot {
 /// true-by-declaration facts or definitions of auxiliaries, so keeping
 /// them narrows nothing.
 ///
-/// An over-approximated feature (a definition outside the fragment, treated
-/// as free) is not tracked here the way [`Translation::approx`] tracks it
-/// for the SMT path: propagation's definitive verdicts (satisfied /
-/// violated / unsatisfiable) all stay sound under a *wider* reachable set,
-/// so the extra freedom never invalidates them.
+/// An over-approximated feature has an unsupported definition and is treated
+/// as free. Refutation remains sound in this wider domain, but satisfaction
+/// after asserting the roots can depend on impossible approximate values.
+/// Callers must retain this distinction when reporting a positive outcome.
 pub(crate) struct JointTranslation {
     /// Index-aligned with the input constraints.
     pub roots: Vec<JointRoot>,
     pub vars: Vec<VarInfo>,
     pub enums: Vec<EnumSort>,
     pub side: Vec<Term>,
+    /// Unsupported feature definitions retained as free variables.
+    pub approx: Vec<String>,
 }
 
 /// The model's enumeration literals, indexed for translation. Deriving
@@ -232,6 +295,8 @@ pub(crate) fn translate_all(
     let mut tr = Translator::new(r, tables);
     let mut roots = Vec::with_capacity(cs.len());
     for c in cs {
+        tr.source = Some(c.element);
+        tr.lexical_scope = Some(c.scope);
         let translated = tr
             .expr(c.scope, &c.expr)
             .and_then(|ut| tr.demand(&ut.term, Demand::Bool).map(|()| ut));
@@ -241,7 +306,7 @@ pub(crate) fn translate_all(
             } else {
                 ut.term
             })),
-            Err(Unsupported(m)) => {
+            Err(Unsupported(m, _)) => {
                 // A conjunction degrades per conjunct: the ones inside
                 // the fragment still contribute (one spoiled term no
                 // longer silences its siblings' narrowing). Half-
@@ -268,13 +333,13 @@ pub(crate) fn translate_all(
             }
         }
     }
-    // `approx` is intentionally dropped — see [`JointTranslation`].
-    let (vars, enums, side, _approx) = tr.finish()?;
+    let (vars, enums, side, approx) = tr.finish()?;
     Ok(JointTranslation {
         roots,
         vars,
         enums,
         side,
+        approx,
     })
 }
 
@@ -317,6 +382,8 @@ pub(crate) fn translate(
     c: &ConstraintInfo,
 ) -> Result<Translation, Unsupported> {
     let mut tr = Translator::new(r, tables);
+    tr.source = Some(c.element);
+    tr.lexical_scope = Some(c.scope);
     let root = tr.expr(c.scope, &c.expr)?.term;
     tr.demand(&root, Demand::Bool)?;
     let (vars, enums, side, approx) = tr.finish()?;
@@ -334,8 +401,21 @@ pub(crate) fn translate(
     })
 }
 
+#[derive(Clone)]
+struct ParameterValue {
+    parameter: ElementRef,
+    frame: Option<usize>,
+    binding: Binding,
+}
+
 struct Translator<'m> {
     r: &'m mut ResolvedModel,
+    source: Option<ElementRef>,
+    lexical_scope: Option<ScopeRef>,
+    frames: Vec<RuntimeFrame>,
+    frame_proofs: RuntimeFrameProof,
+    proof_steps: usize,
+    value_scopes: sysmlv2_model::json::ValueScopeResolver,
     /// Free variables keyed by (element, featuring context) — the same
     /// inherited feature reached through two different usages is two
     /// distinct unknowns.
@@ -355,14 +435,12 @@ struct Translator<'m> {
     /// Calculations whose bodies are being inlined (recursion bails —
     /// unbounded unrolling has no finite translation).
     inlining_calcs: HashSet<ElementRef>,
-    /// Calculation/lambda-parameter bindings, innermost last — dynamic
-    /// extent with one level of shadowing, exactly like the evaluator's
-    /// lambda/parameter environment.
-    env: Vec<(String, Binding)>,
+    /// Runtime arguments keyed by parameter declaration, innermost last.
+    env: Vec<ParameterValue>,
     /// Per-instance variables of skolemized bounded collections,
-    /// keyed by their display path (`ws#2.radius`) — the same collection
-    /// quantified twice shares its instances.
-    skolem_vars: HashMap<String, usize>,
+    /// keyed by resolved root, ordinal and member path. Aliases and repeated
+    /// quantifiers over the same collection share their instances.
+    skolem_vars: HashMap<InstanceKey, usize>,
     approx: Vec<String>,
     /// Inferred unit tag per variable (index-aligned with `displays`).
     var_units: Vec<Option<UTag>>,
@@ -380,6 +458,12 @@ impl<'m> Translator<'m> {
     fn new(r: &'m mut ResolvedModel, tables: &'m EnumTables) -> Translator<'m> {
         Translator {
             r,
+            source: None,
+            lexical_scope: None,
+            frames: Vec::new(),
+            frame_proofs: RuntimeFrameProof::default(),
+            proof_steps: 0,
+            value_scopes: Default::default(),
             var_keys: HashMap::new(),
             displays: Vec::new(),
             states: Vec::new(),
@@ -400,13 +484,96 @@ impl<'m> Translator<'m> {
         }
     }
 
+    fn read<T>(&mut self, read: impl FnOnce(&mut ResolvedModel) -> T) -> T {
+        match self.source {
+            Some(source) => self.r.with_source(source, read),
+            None => read(self.r),
+        }
+    }
+
+    fn in_source<T>(
+        &mut self,
+        source: ElementRef,
+        lexical_scope: ScopeRef,
+        read: impl FnOnce(&mut Self) -> T,
+    ) -> T {
+        let previous = self.source.replace(source);
+        let previous_lexical = self.lexical_scope.replace(lexical_scope);
+        let result = read(self);
+        self.source = previous;
+        self.lexical_scope = previous_lexical;
+        result
+    }
+
+    /// Prepare every proof before mutating visibility. An exhausted or
+    /// incomplete proof must not leave a partially masked caller environment.
+    fn mask_frames(
+        &mut self,
+        lexical: ScopeRef,
+        receiver: ScopeRef,
+    ) -> Result<Vec<usize>, Unsupported> {
+        let mut hidden = Vec::new();
+        for (index, frame) in self.frames.iter().copied().enumerate() {
+            if !frame.visible {
+                continue;
+            }
+            match self
+                .frame_proofs
+                .permits(self.r, frame, lexical, receiver, &mut self.proof_steps)
+            {
+                Some(true) => {}
+                Some(false) => hidden.push(index),
+                None => {
+                    return Err(Unsupported::ordinary(
+                        "runtime frame visibility is incomplete or exceeds the budget".into(),
+                    )
+                    .runtime());
+                }
+            }
+        }
+        for &index in &hidden {
+            self.frames[index].visible = false;
+        }
+        Ok(hidden)
+    }
+
+    fn restore_frames(&mut self, hidden: Vec<usize>) {
+        for index in hidden {
+            self.frames[index].visible = true;
+        }
+    }
+
+    /// A nested declaration can hide an existing activation, but can never
+    /// reactivate one hidden by an enclosing declaration boundary.
+    fn in_declaration<T>(
+        &mut self,
+        source: ElementRef,
+        lexical: ScopeRef,
+        receiver: ScopeRef,
+        read: impl FnOnce(&mut Self) -> Result<T, Unsupported>,
+    ) -> Result<T, Unsupported> {
+        let hidden = self.mask_frames(lexical, receiver)?;
+        let result = self.in_source(source, lexical, read);
+        self.restore_frames(hidden);
+        result
+    }
+
     // -- constant folding ---------------------------------------------------
 
     /// Try the evaluator first: anything it computes to a scalar is a
     /// literal term (quantities carry their unit tag). `Ok(None)` = not a
     /// constant (translate structurally).
     fn fold(&mut self, scope: ScopeRef, e: &Expr) -> Result<Option<UT>, Unsupported> {
-        match self.r.evaluate_in(scope, e) {
+        // The evaluator cannot see symbolic argument/lambda bindings.
+        // Folding a declaration instead can invent a default or arity.
+        // Literals are independent; everything else translates through
+        // the environment, including transitive aliases and calculations.
+        if (!self.env.is_empty() || !self.frames.is_empty())
+            && !matches!(e.kind, ExprKind::Literal(_))
+        {
+            return Ok(None);
+        }
+        match self.read(|r| r.evaluate_in(scope, e)) {
             Ok(Value::Boolean(b)) => Ok(Some(UT::plain(Term::BoolLit(b)))),
             Ok(Value::Integer(i)) => Ok(Some(UT::plain(Term::IntLit(i)))),
             Ok(Value::Rational(r)) => Ok(Some(UT::plain(Term::RealLit(r)))),
@@ -504,9 +671,8 @@ impl<'m> Translator<'m> {
                 }
                 self.demand(&t.term, Demand::Numeric)?;
                 let unit = self
-                    .r
-                    .unit_of_in(scope, arg)
-                    .map_err(|e| Unsupported(format!("a quantity-unit bracket: {e}")))?;
+                    .read(|r| r.unit_of_in(scope, arg))
+                    .map_err(|e| Unsupported::ordinary(format!("a quantity-unit bracket: {e}")))?;
                 if unit.dims_key().is_empty() {
                     return if unit.scale().is_one() {
                         Ok(UT::plain(t.term))
@@ -532,9 +698,7 @@ impl<'m> Translator<'m> {
                 bail("collect/select over unbound features")
             }
             ExprKind::Constructor { .. } => bail("`new` constructors"),
-            ExprKind::Body { .. } | ExprKind::BodyTerminator => {
-                bail("expression bodies over unbound features")
-            }
+            ExprKind::Body { .. } => bail("expression bodies over unbound features"),
             ExprKind::Classification { .. } => bail("classification operators"),
             ExprKind::Extent { .. } => bail("`all` extents"),
             ExprKind::MetadataAccess { .. } => bail("`.metadata` access"),
@@ -652,7 +816,7 @@ impl<'m> Translator<'m> {
             // else translates the left side, which then denotes a
             // *present* scalar (free variables model existing values —
             // the fragment-wide treatment of multiplicities) and wins.
-            NullCoalescing => match self.r.evaluate_in(scope, lhs) {
+            NullCoalescing => match self.read(|r| r.evaluate_in(scope, lhs)) {
                 Ok(Value::Sequence(s)) if s.is_empty() => self.expr(scope, rhs),
                 _ => self.expr(scope, lhs),
             },
@@ -667,6 +831,17 @@ impl<'m> Translator<'m> {
         Ok(UT::plain(Term::App(Op::Eq, vec![l.term, r.term])))
     }
 
+    /// Share the evaluator's identity admission rule. Bare unresolved names
+    /// retain standalone-expression compatibility; bound names never select a
+    /// built-in merely because of their spelling.
+    fn intrinsic_name(&mut self, scope: ScopeRef, qn: &QualifiedName) -> Option<String> {
+        match self.env_binding(scope, qn) {
+            Ok(None) => {}
+            Ok(Some(_)) | Err(_) => return None,
+        }
+        self.read(|r| r.intrinsic_function_name(scope, qn))
+    }
+
     /// Translate *through* a user-calculation body: arguments translate
     /// in the caller's scope, bind to the declared `in`/`inout`
     /// parameters (positionally or by name), and the body translates in
@@ -680,79 +855,133 @@ impl<'m> Translator<'m> {
         scope: ScopeRef,
         ty: &TargetRef,
         args: &[Arg],
+    ) -> Result<UT, Unsupported> {
+        self.invocation_inner(scope, ty, args)
+            .map_err(Unsupported::runtime)
+    }
+
+    fn invocation_inner(
+        &mut self,
+        scope: ScopeRef,
+        ty: &TargetRef,
+        args: &[Arg],
     ) -> Result<UT, Unsupported> {
         let TargetRef::Name(qn) = ty else {
             return bail("chained function references");
         };
         let display = qn.to_display_string();
-        // Kernel Function Library sequence intrinsics: KFL names
-        // are *reserved* — dispatched on the invoked name's last segment
-        // with positional arguments, before resolution and before any
-        // user body, exactly like the evaluator. A shape the table does
-        // not admit (named arguments, wrong arity) falls through to the
-        // ordinary calculation path.
-        let simple = qn
-            .segments
-            .last()
-            .map(|s| s.value.clone())
-            .unwrap_or_default();
+        if self.env_binding(scope, qn)?.is_some() {
+            return bail("symbolic function-valued arguments");
+        }
+        // Use the same resolved function identity as concrete evaluation.
         if args.iter().all(|a| a.name.is_none()) {
-            let exprs: Vec<&Expr> = args.iter().map(|a| &a.value).collect();
-            if seq_intrinsic_arity_ok(&simple, exprs.len()) {
-                return self.seq_intrinsic(scope, &simple, &exprs, &display);
+            if let Some(simple) = self.intrinsic_name(scope, qn) {
+                let exprs: Vec<&Expr> = args.iter().map(|a| &a.value).collect();
+                if seq_intrinsic_arity_ok(&simple, exprs.len()) {
+                    return self.seq_intrinsic(scope, &simple, &exprs, &display);
+                }
             }
         }
-        let Some(callee) = self.r.resolve_in(scope, qn) else {
+        let Some(callee) = self.read(|r| r.resolve_in(scope, qn)) else {
             return bail(format!("unresolved function `{display}`"));
         };
-        let Some((body_scope, body)) = self.r.calc_body(callee) else {
+        // The result the callee declares, else the nearest one its written
+        // heritage declares, read in the callee's own context.
+        let (owner, body_scope, body) = match self.r.callable_body(callee) {
+            Some(CallableBody::Declared {
+                owner,
+                result: CallableResult::Expression { scope, expression },
+            }) => (owner, scope, expression),
+            Some(CallableBody::Declared {
+                owner,
+                result: CallableResult::Parameter(ret),
+            }) => match self.r.value_expr(ret) {
+                Some((scope, expression)) => (owner, scope, expression),
+                None => return bail("function invocation over unbound features"),
+            },
+            Some(CallableBody::Ambiguous(_)) => {
+                return bail(format!("`{display}` inherits more than one result"));
+            }
             // Abstract library functions and bodiless declarations.
-            return bail("function invocation over unbound features");
+            None => return bail("function invocation over unbound features"),
         };
-        let params = self.r.calc_params(callee);
+        let receiver = if owner == callee {
+            body_scope
+        } else {
+            match self.r.element_scope(callee) {
+                Some(scope) => scope,
+                None => return bail(format!("`{display}` has no scope of its own")),
+            }
+        };
+        let params = self.r.calc_parameter_bindings(callee).ok_or_else(|| {
+            Unsupported::ordinary(
+                "calculation parameter identities are incomplete or ambiguous".into(),
+            )
+        })?;
         // Arguments translate in the caller's scope *before* any
         // parameter binding is visible (applicative order).
-        let mut bindings: Vec<(String, Binding)> = Vec::with_capacity(args.len());
+        let mut bindings: Vec<(ElementRef, Binding)> = Vec::with_capacity(args.len());
         let mut pos = 0usize;
         for a in args {
             let t = self.expr(scope, &a.value)?;
-            let name = match &a.name {
-                Some(n) => n
-                    .segments
-                    .last()
-                    .map(|s| s.value.clone())
-                    .unwrap_or_default(),
+            let parameter = match &a.name {
+                Some(n) => params.iter().find(|p| p.name == n.to_display_string()),
                 None => {
-                    let p = params.get(pos).cloned().unwrap_or_default();
+                    let p = params.get(pos);
                     pos += 1;
                     p
                 }
-            };
-            bindings.push((name, Binding::Scalar(t.term, t.unit)));
+            }
+            .ok_or_else(|| Unsupported::ordinary(format!("invalid argument to `{display}`")))?;
+            if bindings.iter().any(|(p, _)| *p == parameter.element) {
+                return bail(format!(
+                    "duplicate argument `{}` to `{display}`",
+                    parameter.name
+                ));
+            }
+            bindings.push((parameter.element, Binding::Scalar(t.term, t.unit)));
         }
-        // Every unbound parameter must have its own (default) value —
-        // otherwise two call sites would share one free variable, which
-        // could prove a spurious UNSAT.
         for p in &params {
-            if bindings.iter().any(|(n, _)| n == p) {
+            // No name reaches a parameter that has none of its own and
+            // redefines none, so no body reads it.
+            if p.name.is_empty() || bindings.iter().any(|(id, _)| *id == p.element) {
                 continue;
             }
-            let has_default = self
-                .r
-                .owned_member(callee, p)
-                .and_then(|m| self.r.value_expr(m))
-                .is_some();
-            if !has_default {
-                return bail(format!("invocation of `{display}` leaves `{p}` unbound"));
+            if self.r.value_expr(p.element).is_none() {
+                return bail(format!(
+                    "invocation of `{display}` leaves `{}` unbound",
+                    p.name
+                ));
             }
         }
-        if !self.inlining_calcs.insert(callee) {
+        if self.inlining_calcs.contains(&callee) {
             return bail(format!("recursive calculation `{display}`"));
         }
-        let depth = self.env.len();
-        self.env.extend(bindings);
-        let out = self.expr(body_scope, &body);
-        self.env.truncate(depth);
+        let hidden = self.mask_frames(receiver, receiver)?;
+        self.inlining_calcs.insert(callee);
+        let caller_env = self.env.clone();
+        self.env
+            .retain(|value| !params.iter().any(|p| p.element == value.parameter));
+        let frame = self.frames.len();
+        self.frames
+            .push(RuntimeFrame::calculation(callee, receiver));
+        self.env.extend(
+            bindings
+                .into_iter()
+                .map(|(parameter, binding)| ParameterValue {
+                    parameter,
+                    binding,
+                    frame: Some(frame),
+                }),
+        );
+        let out = if owner == callee {
+            self.in_source(callee, body_scope, |tr| tr.expr(body_scope, &body))
+        } else {
+            self.in_declaration(owner, body_scope, receiver, |tr| tr.expr(receiver, &body))
+        };
+        self.env = caller_env;
+        self.frames.pop();
+        self.restore_frames(hidden);
         self.inlining_calcs.remove(&callee);
         out
     }
@@ -764,17 +993,31 @@ impl<'m> Translator<'m> {
     /// are flat), `null` is empty, and a reference to a feature with a
     /// value expression recurses into it (cycle-guarded, like
     /// [`Self::feature_term`]). A valueless reference contributes one
-    /// scalar exactly when it is declared scalar — no explicit
-    /// multiplicity (the source default) or an explicit `[1]`, the
-    /// fragment-wide one-existing-value treatment; any other declared
-    /// multiplicity has no static arity here (bounded expansion is the
-    /// quantifier path). Anything else contributes one scalar via the ordinary
+    /// scalar exactly when its effective multiplicity is `[1]`; `[0]`
+    /// contributes none. Other multiplicities decline (bounded expansion
+    /// is the quantifier path). Anything else contributes one scalar via the ordinary
     /// expression path.
     fn seq_terms(
         &mut self,
         scope: ScopeRef,
         e: &Expr,
         out: &mut Vec<UT>,
+    ) -> Result<(), Unsupported> {
+        self.seq_terms_inner(scope, e, out)?;
+        // Scalar over-approximation does not preserve sequence arity.
+        // Include cached approximations and lambda parameter bindings;
+        // dependency-precise admission can recover precision separately.
+        if !self.approx.is_empty() {
+            return bail("sequence arity depends on approximate scalar translation");
+        }
+        Ok(())
+    }
+
+    fn seq_terms_inner(
+        &mut self,
+        scope: ScopeRef,
+        e: &Expr,
+        out: &mut Vec<UT>,
     ) -> Result<(), Unsupported> {
         match &e.kind {
             ExprKind::Sequence(items) => {
@@ -786,30 +1029,38 @@ impl<'m> Translator<'m> {
             ExprKind::Null => Ok(()),
             ExprKind::Ref(qn) => {
                 // Parameter bindings shadow model names, as one item.
-                if let Some(b) = self.env_binding(qn) {
+                if let Some(b) = self.env_binding(scope, qn)? {
                     out.push(self.binding_term(b)?);
                     return Ok(());
                 }
                 let display = qn.to_display_string();
-                let Some(elem) = self.r.resolve_in(scope, qn) else {
+                let Some(elem) = self.read(|r| r.resolve_in(scope, qn)) else {
                     return bail(format!("unresolved reference `{display}`"));
                 };
                 let Some((own_scope, vexpr)) = self.r.value_expr(elem) else {
-                    return match self.r.declared_multiplicity(elem) {
-                        None | Some((1.0, 1.0)) => {
+                    return match self.r.effective_cardinality(elem) {
+                        Some((0, Some(0))) => Ok(()),
+                        Some((1, Some(1))) => {
                             out.push(self.feature_term(elem, None, display)?);
                             Ok(())
                         }
-                        Some((lo, hi)) => bail(format!(
-                            "a collection `{display}` (multiplicity [{lo}..{hi}]) \
-                             with no bound value: arity unknown"
+                        _ => bail(format!(
+                            "a collection `{display}` with no bound values: scalar arity unknown"
                         )),
                     };
                 };
+                let receiver = if !qn.is_global && qn.segments.len() == 1 {
+                    scope
+                } else {
+                    own_scope
+                };
+                let receiver = self.value_scope(elem, Some(receiver))?;
                 if !self.inlining.insert(elem) {
                     return bail(format!("cyclic value of `{display}`"));
                 }
-                let r = self.seq_terms(own_scope, &vexpr, out);
+                let r = self.in_declaration(elem, own_scope, receiver, |tr| {
+                    tr.seq_terms(receiver, &vexpr, out)
+                });
                 self.inlining.remove(&elem);
                 r
             }
@@ -874,13 +1125,13 @@ impl<'m> Translator<'m> {
                 items
                     .into_iter()
                     .next()
-                    .ok_or_else(|| Unsupported("`head` of an empty sequence".into()))
+                    .ok_or_else(|| Unsupported::ordinary("`head` of an empty sequence".into()))
             }
             "last" => {
                 let mut items = self.seq_arg(scope, args, display)?;
                 items
                     .pop()
-                    .ok_or_else(|| Unsupported("`last` of an empty sequence".into()))
+                    .ok_or_else(|| Unsupported::ordinary("`last` of an empty sequence".into()))
             }
             // One sequence, or the two-scalar spelling — either way a
             // fold over the flattened elements.
@@ -1030,11 +1281,9 @@ impl<'m> Translator<'m> {
         let TargetRef::Name(qn) = ty else {
             return bail("chained function references");
         };
-        let simple = qn
-            .segments
-            .last()
-            .map(|s| s.value.clone())
-            .unwrap_or_default();
+        let Some(simple) = self.intrinsic_name(scope, qn) else {
+            return bail("non-intrinsic arrow over unbound features");
+        };
         let display = qn.to_display_string();
         match args {
             ArrowArgs::Body(body) if simple == "forAll" || simple == "exists" => {
@@ -1088,15 +1337,32 @@ impl<'m> Translator<'m> {
         let Some(result) = result else {
             return bail("a lambda body without a result");
         };
+        let Some(source) = self.source else {
+            return bail("lambda source is unavailable");
+        };
+        let Some((body_scope, parameters)) = self.r.lambda_parameter_bindings(source, body) else {
+            return bail("lambda parameter identities are incomplete or ambiguous");
+        };
+        if parameters.len() != 1 || param.as_ref() != Some(&parameters[0].name) {
+            return bail("a quantifier lambda requires one input parameter");
+        }
         let bindings = self.collection_bindings(scope, target)?;
         let mut acc: Option<Term> = None;
         for b in bindings {
             let depth = self.env.len();
-            if let Some(p) = &param {
-                self.env.push((p.clone(), b));
-            }
+            let frame = self.frames.len();
+            self.frames
+                .push(RuntimeFrame::lambda(Some(body_scope), scope));
+            self.env.push(ParameterValue {
+                parameter: parameters[0].element,
+                binding: b,
+                frame: Some(frame),
+            });
+            let lexical = self.lexical_scope.replace(body_scope);
             let t = self.expr(scope, result);
+            self.lexical_scope = lexical;
             self.env.truncate(depth);
+            self.frames.pop();
             let t = t?;
             self.demand(&t.term, Demand::Bool)?;
             acc = Some(match acc {
@@ -1108,10 +1374,10 @@ impl<'m> Translator<'m> {
     }
 
     /// The members a quantifier ranges over. An *unbound* feature with an
-    /// exact declared multiplicity `[n]` (≤ the skolem cap; own
-    /// declaration, or borrowed one hop from a redefinition target)
-    /// skolemizes into `n` anonymous instances — sound for `forAll` /
-    /// `exists` because quantified bodies are aliasing-insensitive.
+    /// exact supported cardinality `[n]` (≤ the skolem cap, including
+    /// transitive redefinitions) expands into `n` members. A singleton
+    /// preserves ordinary feature identity and navigation; larger collections
+    /// share anonymous members across reference spellings and quantifiers.
     /// Everything else lowers through [`Self::seq_terms`] as scalars.
     fn collection_bindings(
         &mut self,
@@ -1119,35 +1385,43 @@ impl<'m> Translator<'m> {
         target: &Expr,
     ) -> Result<Vec<Binding>, Unsupported> {
         if let ExprKind::Ref(qn) = &target.kind {
-            if self.env_binding(qn).is_none() {
-                if let Some(elem) = self.r.resolve_in(scope, qn) {
+            if self.env_binding(scope, qn)?.is_none() {
+                if let Some(elem) = self.read(|r| r.resolve_in(scope, qn)) {
                     if self.r.value_expr(elem).is_none() {
-                        if let Some((lo, hi)) = self.multiplicity_with_hop(elem) {
-                            let display = qn.to_display_string();
-                            if lo == hi && lo >= 0.0 && lo.fract() == 0.0 {
-                                let n = lo as usize;
-                                if n > SKOLEM_CAP {
-                                    return bail(format!(
-                                        "a collection `{display}` with multiplicity \
-                                         [{n}] over the expansion cap ({SKOLEM_CAP})"
-                                    ));
-                                }
-                                let ty = self.r.typings(elem).into_iter().next();
-                                return Ok((1..=n)
-                                    .map(|k| Binding::Instance {
-                                        feature: elem,
-                                        ty,
-                                        path: format!("{display}#{k}"),
-                                    })
-                                    .collect());
-                            }
-                            if hi != 1.0 {
-                                return bail(format!(
-                                    "a collection `{display}` (multiplicity \
-                                     [{lo}..{hi}]) without static arity"
-                                ));
-                            }
+                        let display = qn.to_display_string();
+                        let Some((lo, Some(hi))) = self.r.effective_cardinality(elem) else {
+                            return bail(format!("a collection `{display}` without static arity"));
+                        };
+                        if lo != hi {
+                            return bail(format!("a collection `{display}` without static arity"));
                         }
+                        if lo > SKOLEM_CAP as i128 {
+                            return bail(format!(
+                                "a collection `{display}` with multiplicity [{lo}] \
+                                 over the expansion cap ({SKOLEM_CAP})"
+                            ));
+                        }
+                        if lo == 1 {
+                            return Ok(vec![Binding::Singleton {
+                                feature: elem,
+                                scope,
+                                target: Box::new(target.clone()),
+                                source: self.source,
+                            }]);
+                        }
+                        let ty = self.r.typings(elem).into_iter().next();
+                        return Ok((1..=lo)
+                            .map(|k| Binding::Instance {
+                                feature: elem,
+                                ty,
+                                path: format!("{display}#{k}"),
+                                key: InstanceKey {
+                                    root: elem,
+                                    ordinal: k as usize,
+                                    members: Vec::new(),
+                                },
+                            })
+                            .collect());
                     }
                 }
             }
@@ -1160,32 +1434,19 @@ impl<'m> Translator<'m> {
             .collect())
     }
 
-    /// The element's evaluated exact multiplicity bounds: its own
-    /// explicit declaration, else (one hop) a redefinition target's —
-    /// the same borrow the semantic checks use for undeclared
-    /// characteristics of redefining features.
-    fn multiplicity_with_hop(&mut self, elem: ElementRef) -> Option<(f64, f64)> {
-        if let Some(b) = self.r.declared_multiplicity(elem) {
-            return Some(b);
-        }
-        for t in self.r.redefinition_targets(elem) {
-            if let Some(b) = self.r.declared_multiplicity(t) {
-                return Some(b);
-            }
-        }
-        None
-    }
-
-    /// A per-instance variable of a skolemized collection, keyed by its
-    /// display path so the same collection quantified twice shares its
-    /// instances. Sorted like `sort_from`'s declaration.
-    fn skolem_var(&mut self, sort_from: ElementRef, display: String) -> Result<UT, Unsupported> {
-        if let Some(&i) = self.skolem_vars.get(&display) {
+    /// A per-instance variable, sorted like `sort_from`'s declaration.
+    fn skolem_var(
+        &mut self,
+        sort_from: ElementRef,
+        display: String,
+        key: InstanceKey,
+    ) -> Result<UT, Unsupported> {
+        if let Some(&i) = self.skolem_vars.get(&key) {
             return Ok(UT::plain(Term::Var(i)));
         }
         let (state, lower) = self.declared_sort(sort_from)?;
         let i = self.displays.len();
-        self.skolem_vars.insert(display.clone(), i);
+        self.skolem_vars.insert(key, i);
         self.displays.push(display);
         self.states.push(state);
         self.var_units.push(None);
@@ -1200,53 +1461,64 @@ impl<'m> Translator<'m> {
     /// A leaf reached through a skolem instance. Instance-independent
     /// leaves (enum literals) translate normally. A *closed* value
     /// expression — one the evaluator settles with no unbound references
-    /// — inlines shared (it is the same constant for every instance); an
-    /// *open* one must not (shared inlining would equate the instances'
-    /// sibling features, a spurious-UNSAT risk), so it falls to a
-    /// per-instance free variable recorded as an over-approximation,
-    /// exactly [`Self::feature_term`]'s out-of-fragment fallback.
+    /// — is shared (it is the same constant for every instance); an
+    /// *open* one must decline because its sibling references need the
+    /// instance's identity and cannot use their declaration variables.
     fn skolem_leaf(
         &mut self,
         elem: ElementRef,
         ctx: Option<ScopeRef>,
         display: String,
+        key: InstanceKey,
     ) -> Result<UT, Unsupported> {
         if self.tables.lit_to_enum.contains_key(&elem) || self.r.is_enum_value(elem) {
             return self.feature_term(elem, ctx, display);
         }
+        if self.r.effective_cardinality(elem) != Some((1, Some(1))) {
+            return Err(not_one_value(self.r, elem, &display));
+        }
         if let Some((own_scope, vexpr)) = self.r.value_expr(elem) {
-            let scope = ctx.unwrap_or(own_scope);
-            let closed = self.r.evaluate_in(scope, &vexpr).is_ok_and(|v| {
-                !matches!(
-                    v,
-                    Value::Element(_)
-                        | Value::Unbound(_)
-                        | Value::UnboundMember(_)
-                        | Value::Indeterminate
-                )
+            let receiver = self.value_scope(elem, ctx)?;
+            return self.in_declaration(elem, own_scope, receiver, |tr| {
+                tr.closed_member_term(receiver, &vexpr, &display)
             });
-            if closed && self.inlining.insert(elem) {
-                let out = self.expr(scope, &vexpr);
-                self.inlining.remove(&elem);
-                if let Ok(t) = out {
-                    return Ok(t);
-                }
-            }
-            if !self.approx.contains(&display) {
-                self.approx.push(display.clone());
-            }
         }
-        self.skolem_var(elem, display)
+        self.skolem_var(elem, display, key)
+    }
+
+    /// A declaration formula does not capture its caller's lambda names.
+    /// Without contextual symbolic substitution, only an evaluator-proven
+    /// scalar is safe. Active calculation arguments are invisible to that
+    /// evaluator, so their nonliteral formulas must remain unsupported.
+    fn closed_member_term(
+        &mut self,
+        scope: ScopeRef,
+        expression: &Expr,
+        display: &str,
+    ) -> Result<UT, Unsupported> {
+        if !self.inlining_calcs.is_empty() && !matches!(expression.kind, ExprKind::Literal(_)) {
+            return bail(format!(
+                "a contextual member formula during a calculation `{display}`"
+            ));
+        }
+        let environment = std::mem::take(&mut self.env);
+        let frames = std::mem::take(&mut self.frames);
+        let folded = self.fold(scope, expression);
+        self.frames = frames;
+        self.env = environment;
+        folded?.ok_or_else(|| {
+            Unsupported::ordinary(format!("an open contextual member formula `{display}`"))
+        })
     }
 
     /// A chain whose spine roots at a skolem-instance lambda parameter:
     /// members resolve statically from the instance's type, minting the
     /// per-instance leaf. `Ok(None)` = not such a chain (the ordinary
     /// path applies).
-    fn instance_chain(&mut self, whole: &Expr) -> Result<Option<UT>, Unsupported> {
+    fn instance_chain(&mut self, scope: ScopeRef, whole: &Expr) -> Result<Option<UT>, Unsupported> {
         let mut links: Vec<&QualifiedName> = Vec::new();
         let mut cur = whole;
-        let (ty, path) = loop {
+        let binding = loop {
             match &cur.kind {
                 ExprKind::ChainStep { target, member } => {
                     let TargetRef::Name(qn) = member else {
@@ -1255,14 +1527,39 @@ impl<'m> Translator<'m> {
                     links.push(qn);
                     cur = target;
                 }
-                ExprKind::Ref(qn) => match self.env_binding(qn) {
-                    Some(Binding::Instance { ty, path, .. }) => break (ty, path),
+                ExprKind::Ref(qn) => match self.env_binding(scope, qn)? {
+                    Some(b @ (Binding::Instance { .. } | Binding::Singleton { .. })) => break b,
                     _ => return Ok(None),
                 },
                 _ => return Ok(None),
             }
         };
         links.reverse();
+        let (ty, path, mut key) = match binding {
+            Binding::Singleton {
+                scope,
+                target,
+                source,
+                ..
+            } => {
+                // Retained receiver syntax and lambda links can come from
+                // different files. Evaluate each fragment in its own source.
+                let target = match source {
+                    Some(source) => self
+                        .r
+                        .with_source(source, |r| r.evaluate_in(scope, &target)),
+                    None => self.r.evaluate_in(scope, &target),
+                }
+                .map_err(|e| Unsupported::ordinary(format!("chain target: {e}")))?;
+                let (last, prefix) = links.split_last().expect("a chain has a member");
+                let target = self
+                    .read(|r| r.evaluate_value_chain(target, prefix))
+                    .map_err(|e| Unsupported::ordinary(format!("chain target: {e}")))?;
+                return self.ordinary_chain_value(whole, target, last).map(Some);
+            }
+            Binding::Instance { ty, path, key, .. } => (ty, path, key),
+            Binding::Scalar(..) => unreachable!("only model bindings are admitted"),
+        };
         let Some(ty) = ty else {
             return bail(format!("an untyped skolemized collection `{path}`"));
         };
@@ -1272,11 +1569,15 @@ impl<'m> Translator<'m> {
         };
         let mut cur_elem = ty;
         for (i, qn) in links.iter().enumerate() {
-            let Some((hit, s)) = self.r.member_of(cur_elem, qn) else {
+            let Some((hit, s)) = self.read(|r| r.member_of(cur_elem, qn)) else {
                 return bail(format!("unresolved reference `{display}`"));
             };
+            key.members.push((hit, s));
             if i + 1 == links.len() {
-                return self.skolem_leaf(hit, s, display).map(Some);
+                return self.skolem_leaf(hit, s, display, key).map(Some);
+            }
+            if self.r.effective_cardinality(hit) != Some((1, Some(1))) {
+                return Err(not_one_receiver(self.r, hit, &display));
             }
             cur_elem = hit;
         }
@@ -1285,17 +1586,99 @@ impl<'m> Translator<'m> {
 
     // -- references and free variables ---------------------------------------
 
-    /// The environment binding of a single-segment name, if any.
-    fn env_binding(&self, qn: &QualifiedName) -> Option<Binding> {
-        if qn.segments.len() != 1 || qn.is_global {
-            return None;
+    /// Runtime arguments follow the declaration resolved in the lexical scope.
+    fn env_binding(
+        &mut self,
+        scope: ScopeRef,
+        qn: &QualifiedName,
+    ) -> Result<Option<Binding>, Unsupported> {
+        self.env_binding_inner(scope, qn)
+            .map_err(Unsupported::runtime)
+    }
+
+    fn env_binding_inner(
+        &mut self,
+        scope: ScopeRef,
+        qn: &QualifiedName,
+    ) -> Result<Option<Binding>, Unsupported> {
+        if self.env.is_empty() && self.frames.is_empty() {
+            return Ok(None);
         }
-        let name = &qn.segments[0].value;
-        self.env
-            .iter()
+        let lexical_scope = self.lexical_scope.unwrap_or(scope);
+        let target = self
+            .read(|r| r.reference_identity(lexical_scope, qn))
+            .target;
+        for frame in (0..self.frames.len())
             .rev()
-            .find(|(n, _)| n == name)
-            .map(|(_, b)| b.clone())
+            .map(Some)
+            .chain(std::iter::once(None))
+        {
+            if frame.is_some_and(|frame| !self.frames[frame].visible) {
+                continue;
+            }
+            if let Some(value) = self
+                .env
+                .iter()
+                .rev()
+                .find(|value| value.frame == frame && Some(value.parameter) == target)
+            {
+                let visible =
+                    self.r
+                        .runtime_parameter_visible_with_steps(
+                            value.parameter,
+                            lexical_scope,
+                            &mut self.proof_steps,
+                        )
+                        .ok_or_else(|| {
+                            Unsupported::ordinary(
+                    "runtime parameter lexical scope is incomplete or exceeds the budget".into(),
+                )
+                        })?;
+                if visible {
+                    return Ok(Some(value.binding.clone()));
+                }
+            }
+            if let (Some(frame), Some(target)) = (frame, target) {
+                let Some(callee) = self.frames[frame].callee else {
+                    continue;
+                };
+                match self.r.runtime_parameter_selection_with_steps(
+                    callee,
+                    lexical_scope,
+                    scope,
+                    target,
+                    &mut self.proof_steps,
+                ) {
+                    sysmlv2_model::json::RuntimeParameterSelection::Selected(parameter) => {
+                        if let Some(value) = self.env.iter().rev().find(|value| {
+                            value.frame == Some(frame) && value.parameter == parameter
+                        }) {
+                            return Ok(Some(value.binding.clone()));
+                        }
+                        if parameter != target {
+                            let receiver = self.frames[frame].receiver_scope;
+                            let value = self.feature_term_in(
+                                parameter,
+                                None,
+                                Some(receiver),
+                                qn.to_display_string(),
+                            )?;
+                            return Ok(Some(Binding::Scalar(value.term, value.unit)));
+                        }
+                    }
+                    sysmlv2_model::json::RuntimeParameterSelection::NotApplicable => {}
+                    sysmlv2_model::json::RuntimeParameterSelection::Unsupported => {
+                        return bail("runtime parameter redefinition is incomplete or ambiguous");
+                    }
+                }
+            }
+        }
+        if let Some(receiver_target) = self.read(|r| r.resolve_in(scope, qn)) {
+            if Some(receiver_target) != target && self.r.is_parameter(receiver_target) {
+                return bail("receiver lookup selects an unrelated parameter declaration");
+            }
+        }
+        Ok(None)
     }
 
     /// A binding used as a value: scalars pass through; a skolem
@@ -1305,21 +1688,29 @@ impl<'m> Translator<'m> {
     fn binding_term(&mut self, b: Binding) -> Result<UT, Unsupported> {
         match b {
             Binding::Scalar(t, u) => Ok(UT { term: t, unit: u }),
-            Binding::Instance { feature, path, .. } => self.skolem_leaf(feature, None, path),
+            Binding::Singleton {
+                feature, target, ..
+            } => self.feature_term(feature, None, display_expr(&target)),
+            // This binding already denotes one expanded member. Its
+            // root declaration's multiplicity describes the collection,
+            // not this scalar instance; nested members use skolem_leaf.
+            Binding::Instance {
+                feature, path, key, ..
+            } => self.skolem_var(feature, path, key),
         }
     }
 
     fn ref_term(&mut self, scope: ScopeRef, qn: &QualifiedName) -> Result<UT, Unsupported> {
-        // Calculation/lambda parameters shadow model names (dynamic
-        // extent, like the evaluator's environment).
-        if let Some(b) = self.env_binding(qn) {
+        // Parameter declarations retain their active runtime arguments.
+        if let Some(b) = self.env_binding(scope, qn)? {
             return self.binding_term(b);
         }
         let display = qn.to_display_string();
-        let Some(elem) = self.r.resolve_in(scope, qn) else {
+        let Some(elem) = self.read(|r| r.resolve_in(scope, qn)) else {
             return bail(format!("unresolved reference `{display}`"));
         };
-        self.feature_term(elem, None, display)
+        let receiver = (!qn.is_global && qn.segments.len() == 1).then_some(scope);
+        self.feature_term_in(elem, None, receiver, display)
     }
 
     fn chain(
@@ -1329,29 +1720,52 @@ impl<'m> Translator<'m> {
         target: &Expr,
         member: &TargetRef,
     ) -> Result<UT, Unsupported> {
-        let TargetRef::Name(qn) = member else {
-            return bail("chained chain members");
-        };
         // A spine rooted at a skolem-instance lambda parameter resolves
         // statically — the evaluator below cannot see the binding.
-        if let Some(out) = self.instance_chain(whole)? {
+        if let Some(out) = self.instance_chain(scope, whole)? {
             return Ok(out);
         }
+        self.ordinary_chain(scope, whole, target, member)
+    }
+
+    fn ordinary_chain(
+        &mut self,
+        scope: ScopeRef,
+        whole: &Expr,
+        target: &Expr,
+        member: &TargetRef,
+    ) -> Result<UT, Unsupported> {
+        let TargetRef::Name(qn) = member else {
+            return bail("chained chain members");
+        };
         let tval = self
-            .r
-            .evaluate_in(scope, target)
-            .map_err(|e| Unsupported(format!("chain target: {e}")))?;
+            .read(|r| r.evaluate_in(scope, target))
+            .map_err(|e| Unsupported::ordinary(format!("chain target: {e}")))?;
+        self.ordinary_chain_value(whole, tval, qn)
+    }
+
+    fn ordinary_chain_value(
+        &mut self,
+        whole: &Expr,
+        tval: Value,
+        qn: &QualifiedName,
+    ) -> Result<UT, Unsupported> {
         if matches!(tval, Value::Indeterminate | Value::UnboundMember(_)) {
             // A nested unknown member has no concrete featuring context.
             // Do not identify distinct receiver paths by their shared
             // declaration, or inline defaults from that declaration.
             return bail("a chain through an unknown receiver member");
         }
+        if let Value::Unbound(t) = &tval {
+            if self.r.effective_cardinality(*t) != Some((1, Some(1))) {
+                return Err(not_one_receiver(self.r, *t, ""));
+            }
+        }
         let unbound = matches!(&tval, Value::Unbound(t) if self.r.is_reference_feature(*t));
         let (Value::Element(t) | Value::Unbound(t)) = tval else {
             return bail("a chain whose target is not a model element");
         };
-        let Some((hit, sub)) = self.r.member_of(t, qn) else {
+        let Some((hit, sub)) = self.read(|r| r.member_of(t, qn)) else {
             return bail(format!("unresolved reference `{}`", display_expr(whole)));
         };
         if unbound {
@@ -1365,6 +1779,12 @@ impl<'m> Translator<'m> {
             }
             return self.var(hit, sub, display);
         }
+        if let Some((own_scope, expression)) = self.r.value_expr(hit) {
+            let receiver = self.value_scope(hit, sub)?;
+            return self.in_declaration(hit, own_scope, receiver, |tr| {
+                tr.closed_member_term(receiver, &expression, &display_expr(whole))
+            });
+        }
         self.feature_term(hit, sub, display_expr(whole))
     }
 
@@ -1378,6 +1798,36 @@ impl<'m> Translator<'m> {
         elem: ElementRef,
         ctx: Option<ScopeRef>,
         display: String,
+    ) -> Result<UT, Unsupported> {
+        self.feature_term_in(elem, ctx, ctx, display)
+    }
+
+    fn value_scope(
+        &mut self,
+        element: ElementRef,
+        receiver: Option<ScopeRef>,
+    ) -> Result<ScopeRef, Unsupported> {
+        match self
+            .value_scopes
+            .select(self.r, element, receiver, &mut self.proof_steps)
+        {
+            sysmlv2_model::json::ValueScopeDecision::Lexical(scope)
+            | sysmlv2_model::json::ValueScopeDecision::Receiver(scope) => Ok(scope),
+            sysmlv2_model::json::ValueScopeDecision::Unsupported => Err(Unsupported::ordinary(
+                "value receiver identity is incomplete or ambiguous".into(),
+            )
+            .runtime()),
+        }
+    }
+
+    /// An expression receiver can differ from the context identifying a free
+    /// variable: a simple inherited reference evaluates in the caller's scope.
+    fn feature_term_in(
+        &mut self,
+        elem: ElementRef,
+        ctx: Option<ScopeRef>,
+        receiver: Option<ScopeRef>,
+        display: String,
     ) -> Result<UT, Unsupported> {
         if self.tables.lit_to_enum.contains_key(&elem) {
             return self.enum_term(elem).map(UT::plain);
@@ -1386,13 +1836,21 @@ impl<'m> Translator<'m> {
             return bail(format!("variant value `{display}`"));
         }
         if let Some((own_scope, vexpr)) = self.r.value_expr(elem) {
+            let receiver = self.value_scope(elem, receiver)?;
             if !self.inlining.insert(elem) {
                 return bail(format!("cyclic value of `{display}`"));
             }
-            let out = self.expr(ctx.unwrap_or(own_scope), &vexpr);
+            let out =
+                self.in_declaration(elem, own_scope, receiver, |tr| tr.expr(receiver, &vexpr));
             self.inlining.remove(&elem);
             match out {
                 Ok(t) => return Ok(t),
+                // A call-local formula can depend on runtime arguments. Turning
+                // a refused dependency into a declaration variable loses that
+                // identity contract and can manufacture a satisfied constraint.
+                Err(error) if error.1 || !self.inlining_calcs.is_empty() => {
+                    return Err(error.runtime());
+                }
                 Err(_) => {
                     // The definition is outside the fragment: treat the
                     // feature as free but remember the over-approximation.
@@ -1411,6 +1869,18 @@ impl<'m> Translator<'m> {
         ctx: Option<ScopeRef>,
         display: String,
     ) -> Result<UT, Unsupported> {
+        // Scalar translation must not turn a collection hidden behind a
+        // conditional, calculation or unsupported formula into one value.
+        if self.r.effective_cardinality(elem) != Some((1, Some(1))) {
+            return Err(not_one_value(self.r, elem, &display));
+        }
+        // An own member's qualified reference and receiver navigation denote
+        // the same value. Inherited members retain their distinct usage context.
+        let ctx = ctx.or_else(|| {
+            self.r
+                .owner(elem)
+                .and_then(|owner| self.r.element_scope(owner))
+        });
         if let Some(&i) = self.var_keys.get(&(elem, ctx)) {
             return Ok(UT::plain(Term::Var(i)));
         }
@@ -1672,7 +2142,7 @@ impl<'m> Translator<'m> {
 
     fn demand_var(&mut self, i: usize, d: Demand) -> Result<(), Unsupported> {
         let conflict = || {
-            Unsupported(format!(
+            Unsupported::ordinary(format!(
                 "conflicting type requirements on `{}`",
                 self.displays[i]
             ))
@@ -1889,3 +2359,339 @@ fn sanitize(s: &str) -> String {
     out.truncate(24);
     out
 }
+
+#[cfg(test)]
+mod source_fragment_tests {
+    use super::*;
+    use std::collections::HashMap;
+    use sysmlv2_model::model::Model;
+
+    fn receiver_retry_model() -> ResolvedModel {
+        let mut model = Model::new();
+        let unit = model.add_source(
+            "receiver-retry.kerml",
+            "class Base { feature v[1] = 4; }
+             class Broken specializes Base, missing {
+                 alias chosen for Base::v;
+                 feature probe = chosen;
+             }
+             class Good specializes Base {
+                 alias chosen for Base::v;
+                 feature probe = chosen;
+             }",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn failed_scalar_receiver_proof_does_not_poison_a_later_valid_translation() {
+        let mut resolved = receiver_retry_model();
+        let value = resolved.resolve_qualified("Base::v").unwrap();
+        let broken = resolved.resolve_qualified("Broken").unwrap();
+        let good = resolved.resolve_qualified("Good").unwrap();
+        let broken_scope = resolved.element_scope(broken).unwrap();
+        let good_scope = resolved.element_scope(good).unwrap();
+        let tables = EnumTables::build(&resolved);
+        let mut translator = Translator::new(&mut resolved, &tables);
+        let error = match translator.feature_term_in(
+            value,
+            Some(broken_scope),
+            Some(broken_scope),
+            "v".into(),
+        ) {
+            Err(error) => error,
+            Ok(_) => panic!("incomplete receiver proof must be refused"),
+        };
+        assert!(error.1, "proof rejection must not permit approximation");
+        let translated = translator
+            .feature_term_in(value, Some(good_scope), Some(good_scope), "v".into())
+            .unwrap_or_else(|error| panic!("{}", error.0));
+        assert!(matches!(translated.term, Term::IntLit(4)));
+        assert!(translator.approx.is_empty());
+        assert!(translator.displays.is_empty());
+        assert!(translator.inlining.is_empty());
+        assert_eq!(translator.source, None);
+        assert_eq!(translator.lexical_scope, None);
+    }
+
+    #[test]
+    fn failed_sequence_receiver_proof_does_not_poison_a_later_valid_translation() {
+        let mut resolved = receiver_retry_model();
+        let value = resolved.resolve_qualified("Base::v").unwrap();
+        let broken = resolved.resolve_qualified("Broken::probe").unwrap();
+        let good = resolved.resolve_qualified("Good::probe").unwrap();
+        let (broken_scope, broken_expression) = resolved.value_expr(broken).unwrap();
+        let (good_scope, good_expression) = resolved.value_expr(good).unwrap();
+        for (scope, expression) in [
+            (broken_scope, &broken_expression),
+            (good_scope, &good_expression),
+        ] {
+            let ExprKind::Ref(name) = &expression.kind else {
+                panic!("expected the alias reference");
+            };
+            assert_eq!(resolved.resolve_in(scope, name), Some(value));
+        }
+        let tables = EnumTables::build(&resolved);
+        let mut translator = Translator::new(&mut resolved, &tables);
+        let mut terms = Vec::new();
+        let error = translator
+            .seq_terms(broken_scope, &broken_expression, &mut terms)
+            .expect_err("incomplete receiver proof must be refused");
+        assert!(error.1, "proof rejection must not permit approximation");
+        assert!(terms.is_empty());
+        translator
+            .seq_terms(good_scope, &good_expression, &mut terms)
+            .unwrap_or_else(|error| panic!("{}", error.0));
+        assert_eq!(terms.len(), 1);
+        assert!(matches!(terms[0].term, Term::IntLit(4)));
+        assert!(translator.approx.is_empty());
+        assert!(translator.displays.is_empty());
+        assert!(translator.inlining.is_empty());
+        assert_eq!(translator.source, None);
+        assert_eq!(translator.lexical_scope, None);
+    }
+
+    #[test]
+    fn singleton_chain_keeps_receiver_and_two_links_in_their_original_sources() {
+        const TARGET: &str = "77777777-7777-4777-8777-777777777777";
+        const LINK: &str = "88888888-8888-4888-8888-888888888888";
+        let mut model = Model::new();
+        for package in ["A", "B"] {
+            model.add_source(
+                format!("{package}.sysml"),
+                &format!(
+                    "package {package} {{
+                        part def Def {{
+                            part '{LINK}'[1] {{ attribute leaf = 11; }}
+                            part poison[1] {{ attribute leaf = 99; }}
+                        }}
+                        part Actual[1] : Def;
+                        part '{TARGET}'[1] {{
+                            part '{LINK}'[1] {{ attribute leaf = 22; }}
+                        }}
+                        attribute capture = '{TARGET}';
+                        part p[1] : Def;
+                        attribute links = p.'{LINK}'.leaf;
+                    }}"
+                ),
+            );
+        }
+        assert!(!model.has_errors());
+        let mut resolved = ResolvedModel::build(&model);
+        let actual = resolved.resolve_qualified("A::Actual").unwrap();
+        let poison = resolved.resolve_qualified("A::Def::poison").unwrap();
+        let ordinary_target = resolved
+            .resolve_qualified(&format!("A::'{TARGET}'"))
+            .unwrap();
+        let ordinary_link = resolved
+            .resolve_qualified(&format!("A::Def::'{LINK}'"))
+            .unwrap();
+        let target_sites = resolved.references_to(ordinary_target);
+        let link_sites = resolved.references_to(ordinary_link);
+        assert_eq!(target_sites.len(), 1);
+        assert!(!link_sites.is_empty());
+        let mut hints = HashMap::new();
+        for (sites, identity) in [(&target_sites, TARGET), (&link_sites, LINK)] {
+            for site in sites {
+                hints.insert(
+                    (resolved.element_id(site.owner), site.kind.clone()),
+                    identity.parse().unwrap(),
+                );
+            }
+        }
+        resolved.override_ids(&HashMap::from([
+            (resolved.element_id(actual), TARGET.parse().unwrap()),
+            (resolved.element_id(poison), LINK.parse().unwrap()),
+        ]));
+        let bound = resolved.bind_id_spelled_references_with(&mut hints);
+        assert!(bound.contains(&TARGET.parse().unwrap()));
+        assert!(bound.contains(&LINK.parse().unwrap()));
+
+        let capture = resolved.resolve_qualified("A::capture").unwrap();
+        let a_links = resolved.resolve_qualified("A::links").unwrap();
+        let b_links = resolved.resolve_qualified("B::links").unwrap();
+        let (scope, target) = resolved.value_expr(capture).unwrap();
+        let (_, a_expression) = resolved.value_expr(a_links).unwrap();
+        let (_, expression) = resolved.value_expr(b_links).unwrap();
+        // Equal spans in the two files ensure the wrong origin finds a real
+        // binding, rather than merely failing to resolve a name.
+        assert_eq!(a_expression.span, expression.span);
+        let ExprKind::ChainStep {
+            target: prefix,
+            member: TargetRef::Name(last),
+        } = &expression.kind
+        else {
+            panic!("expected the final chain link");
+        };
+        let ExprKind::ChainStep {
+            member: TargetRef::Name(first),
+            ..
+        } = &prefix.kind
+        else {
+            panic!("expected the intermediate chain link");
+        };
+        let receiver = resolved
+            .with_source(capture, |r| r.evaluate_in(scope, &target))
+            .unwrap();
+        let correct = resolved
+            .with_source(b_links, |r| {
+                r.evaluate_value_chain(receiver.clone(), &[first, last])
+            })
+            .unwrap();
+        assert_eq!(correct, Value::Integer(11));
+        let wrong_links = resolved
+            .with_source(a_links, |r| {
+                r.evaluate_value_chain(receiver, &[first, last])
+            })
+            .unwrap();
+        assert_eq!(wrong_links, Value::Integer(99));
+        let wrong_receiver = resolved
+            .with_source(b_links, |r| r.evaluate_in(scope, &target))
+            .unwrap();
+        let wrong_target = resolved
+            .with_source(b_links, |r| {
+                r.evaluate_value_chain(wrong_receiver, &[first, last])
+            })
+            .unwrap();
+        assert_eq!(wrong_target, Value::Integer(22));
+
+        let parameter = resolved.resolve_qualified("B::p").unwrap();
+        let tables = EnumTables::build(&resolved);
+        let mut translator = Translator::new(&mut resolved, &tables);
+        translator.source = Some(b_links);
+        translator.lexical_scope = translator.r.value_expr(b_links).map(|(s, _)| s);
+        translator.env.push(ParameterValue {
+            parameter,
+            frame: None,
+            binding: Binding::Singleton {
+                feature: actual,
+                scope,
+                target: Box::new(target),
+                source: Some(capture),
+            },
+        });
+        let translated = translator
+            .instance_chain(scope, &expression)
+            .unwrap_or_else(|error| panic!("{}", error.0))
+            .unwrap();
+        assert!(matches!(translated.term, Term::IntLit(11)));
+        assert_eq!(translator.source, Some(b_links));
+    }
+}
+
+#[cfg(test)]
+mod runtime_frame_tests {
+    use super::*;
+    use sysmlv2_model::model::Model;
+
+    fn model() -> ResolvedModel {
+        let mut model = Model::new();
+        model.add_source(
+            "frames.sysml",
+            "calc def Base {in p default 1; attribute value=p;}
+             calc def Other {Base::value}
+             attribute literal=1; attribute listValue=(1,2);",
+        );
+        assert!(!model.has_errors());
+        ResolvedModel::build(&model)
+    }
+
+    #[test]
+    fn nested_declarations_never_reactivate_frames_and_errors_restore_masks() {
+        let mut resolved = model();
+        let base = resolved.resolve_qualified("Base").unwrap();
+        let base_scope = resolved.element_scope(base).unwrap();
+        let other = resolved.resolve_qualified("Other").unwrap();
+        let other_scope = resolved.element_scope(other).unwrap();
+        let tables = EnumTables::build(&resolved);
+        let mut tr = Translator::new(&mut resolved, &tables);
+        tr.source = Some(base);
+        tr.lexical_scope = Some(base_scope);
+        tr.frames = vec![
+            RuntimeFrame::calculation(base, base_scope),
+            RuntimeFrame::lambda(Some(base_scope), base_scope),
+            RuntimeFrame {
+                visible: false,
+                ..RuntimeFrame::calculation(base, base_scope)
+            },
+        ];
+        let result: Result<(), Unsupported> =
+            tr.in_declaration(other, other_scope, other_scope, |tr| {
+                assert!(tr.frames.iter().all(|frame| !frame.visible));
+                tr.in_declaration(base, base_scope, base_scope, |tr| {
+                    assert!(tr.frames.iter().all(|frame| !frame.visible));
+                    bail("test nested declaration failure")
+                })
+            });
+        assert!(result.is_err());
+        assert_eq!(
+            tr.frames
+                .iter()
+                .map(|frame| frame.visible)
+                .collect::<Vec<_>>(),
+            [true, true, false]
+        );
+        assert_eq!(tr.source, Some(base));
+        assert_eq!(tr.lexical_scope, Some(base_scope));
+    }
+
+    #[test]
+    fn a_partially_proved_mask_is_not_applied_on_budget_failure() {
+        let mut resolved = model();
+        let other = resolved.resolve_qualified("Other").unwrap();
+        let scope = resolved.element_scope(other).unwrap();
+        let tables = EnumTables::build(&resolved);
+        let mut tr = Translator::new(&mut resolved, &tables);
+        tr.frames = vec![RuntimeFrame::lambda(None, scope); 2];
+        tr.proof_steps = sysmlv2_model::eval::MAX_STEPS - 1;
+        assert!(tr.mask_frames(scope, scope).is_err());
+        assert!(tr.frames.iter().all(|frame| frame.visible));
+        tr.proof_steps = 0;
+        let hidden = tr
+            .mask_frames(scope, scope)
+            .unwrap_or_else(|e| panic!("{}", e.0));
+        assert!(tr.frames.iter().all(|frame| !frame.visible));
+        tr.restore_frames(hidden);
+        assert!(tr.frames.iter().all(|frame| frame.visible));
+    }
+
+    #[test]
+    fn closed_member_folding_restores_bindings_and_frame_masks() {
+        let mut resolved = model();
+        let base = resolved.resolve_qualified("Base").unwrap();
+        let parameter = resolved.resolve_qualified("Base::p").unwrap();
+        let scope = resolved.element_scope(base).unwrap();
+        let literal = resolved.resolve_qualified("literal").unwrap();
+        let sequence = resolved.resolve_qualified("listValue").unwrap();
+        let (literal_scope, literal) = resolved.value_expr(literal).unwrap();
+        let (sequence_scope, sequence) = resolved.value_expr(sequence).unwrap();
+        let tables = EnumTables::build(&resolved);
+        let mut tr = Translator::new(&mut resolved, &tables);
+        tr.frames.push(RuntimeFrame {
+            visible: false,
+            ..RuntimeFrame::lambda(Some(scope), scope)
+        });
+        tr.env.push(ParameterValue {
+            parameter,
+            frame: Some(0),
+            binding: Binding::Scalar(Term::IntLit(7), None),
+        });
+        assert!(
+            tr.closed_member_term(literal_scope, &literal, "literal")
+                .is_ok()
+        );
+        assert!(
+            tr.closed_member_term(sequence_scope, &sequence, "sequence")
+                .is_err()
+        );
+        assert_eq!(tr.frames.len(), 1);
+        assert!(!tr.frames[0].visible);
+        assert_eq!(tr.env.len(), 1);
+        assert_eq!(tr.env[0].frame, Some(0));
+        assert!(matches!(
+            tr.env[0].binding,
+            Binding::Scalar(Term::IntLit(7), None)
+        ));
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/apollo.rs b/crates/sysmlv2-solve/tests/apollo.rs
index 053e228..0da6328 100644
--- a/crates/sysmlv2-solve/tests/apollo.rs
+++ b/crates/sysmlv2-solve/tests/apollo.rs
@@ -1,7 +1,7 @@
 //! Solving gate over the Airbus Apollo 11 external validation model.
 //! Skips without the submodule or a `z3` binary; the
 //! outcome tuple is a ratchet — `valid`/`unsatisfiable` must stay 0 on
-//! the conforming scaffold, `satisfiable` should only grow.
+//! the conforming scaffold; other changes require semantic adjudication.
 
 use sysmlv2_model::model::Model;
 use sysmlv2_solve::{SolveOutcome, SolverConfig, solve_constraints, z3_version};
@@ -47,10 +47,13 @@ fn apollo_solve_ratchet() {
             Some(other) => panic!("unhandled solve conclusion: {other:?}"),
         }
     }
+    // 31 former witnesses treated quantities explicitly subsetting [*]
+    // library features as scalars. These usages have no implicit singleton
+    // declaration; preserving their inherited bounds leaves them unknown.
     assert_eq!(
         (valid, sat, unsat, unknown),
-        (0, 56, 0, 2),
+        (0, 25, 0, 33),
         "apollo solve ratchet moved — unsatisfiable/valid must stay 0; \
-         satisfiable should only grow via translator improvements"
+         satisfiable/unknown changes require an explained improvement or soundness correction"
     );
 }
diff --git a/crates/sysmlv2-solve/tests/common/collection_identity.rs b/crates/sysmlv2-solve/tests/common/collection_identity.rs
new file mode 100644
index 0000000..55fbc24
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/common/collection_identity.rs
@@ -0,0 +1,217 @@
+// Shared semantic fixtures exercised by both propagation and native solving.
+pub fn contradictions() -> Vec<String> {
+    let mut sources = Vec::new();
+    for (base, declaration) in [
+        ("", "part def A { attribute x : Integer;"),
+        ("", "part def A { attribute x : Integer[1];"),
+        (
+            "part def Base { attribute x : Integer[1]; } part def Middle :> Base { attribute :>> x; }",
+            "part def A :> Middle { attribute :>> x;",
+        ),
+    ] {
+        for target in ["x", "alternate", "P::A::x"] {
+            for quantifier in ["forAll", "exists"] {
+                sources.push(format!(
+                    "package P {{ attribute def Integer; {base} {declaration}
+                        alias alternate for x;
+                        assert constraint c {{ x == 0 & {target}->{quantifier} {{ in x; x == 1 }} }}
+                    }} }}"
+                ));
+            }
+        }
+    }
+    for local in ["", "attribute :>> value;"] {
+        for target in ["p", "alternate", "P::A::p"] {
+            sources.push(format!(
+                "package P {{ attribute def Integer;
+                    part def Item {{ attribute value : Integer; }}
+                    part def A {{ part p : Item[1] {{ {local} }} alias alternate for p;
+                        assert constraint c {{ p.value == 0 & {target}->forAll {{ in p; p.value == 1 }} }}
+                    }}
+                }}"
+            ));
+        }
+    }
+    sources.push(
+        "package P { attribute def Integer;
+        part def Item { attribute value : Integer; }
+        part def A { part p : Item[1] { attribute :>> value; }
+            assert constraint c { P::A::p::value == 0 & p->forAll { in i; i.value == 1 } }
+        }
+    }"
+        .into(),
+    );
+    for size in [1, 2] {
+        for target in ["alternate", "P::A::p"] {
+            sources.push(format!(
+                "package P {{ attribute def Integer;
+                    part def Item {{ attribute value : Integer; }}
+                    part def A {{ part p : Item[{size}]; alias alternate for p;
+                        assert constraint c {{ p->forAll {{ in i; i.value == 0 }} & {target}->exists {{ in i; i.value == 1 }} }}
+                    }}
+                }}"
+            ));
+        }
+    }
+    sources.push(
+        "package P { attribute def Integer;
+            part def Item { attribute x : Integer default = 1; }
+            requirement def R {
+                subject p : Item[1];
+                assert constraint c { p.x == 0 & p->forAll { in i; i.x == 1 } }
+            }
+        }"
+        .into(),
+    );
+    sources.push(
+        "package P { attribute def Integer;
+            part def Item { attribute x : Integer; }
+            part p : Item[1]; part q : Item[1];
+            assert constraint c { p.x == 0 & p->forAll { in x;
+                q->forAll { in x; x.x == 1 } & x.x == 1
+            } }
+        }"
+        .into(),
+    );
+    sources
+}
+
+pub fn distinct_receivers(size: usize) -> String {
+    format!("package P {{ attribute def Integer;
+        part def Item {{ attribute value : Integer; }}
+        part def A {{ part p : Item[{size}]; part q : Item[{size}];
+            assert constraint c {{ p->forAll {{ in i; i.value == 0 }} & q->forAll {{ in i; i.value == 1 }} }}
+        }}
+    }}")
+}
+
+pub fn contextual_formulas() -> Vec<String> {
+    let mut sources = Vec::new();
+    for parameter in ["x", "i"] {
+        for quantifier in ["forAll", "exists"] {
+            sources.push(format!(
+                "package P {{ attribute def Integer;
+                    part def Item {{ attribute x : Integer; attribute y : Integer = x; }}
+                    part p : Item[1];
+                    assert constraint c {{ p.x == 0 & p->{quantifier} {{ in {parameter}; {parameter}.y == 1 }} }}
+                }}"
+            ));
+        }
+    }
+    sources.push(
+        "package P { attribute def Integer;
+            part def Item { attribute x : Integer; attribute y : Integer = x; }
+            part p : Item[2];
+            assert constraint c { p->forAll { in i; i.x == 0 } & p->forAll { in x; x.y == 1 } }
+        }"
+        .into(),
+    );
+    sources.push(
+        "package P { attribute def Integer;
+            part def Item { attribute x : Integer; }
+            part p : Item[1];
+            assert constraint c { p.x == 0 & p->forAll { in x;
+                x->forAll { in y; y.x == 1 }
+            } }
+        }"
+        .into(),
+    );
+    sources.push(
+        "package P { attribute def Integer;
+            attribute n : Integer = 1;
+            part def Item { attribute y : Integer = n; }
+            part p : Item[1];
+            calc def Check { in n : Integer default = 1;
+                return result = p->forAll { in i; i.y == n };
+            }
+            attribute argument[1] : Integer;
+            assert constraint c { argument == 0 & Check(argument) }
+        }"
+        .into(),
+    );
+    sources
+}
+
+pub fn closed_member_formula(size: usize) -> String {
+    format!(
+        "package P {{ attribute def Integer;
+        part def Item {{ attribute x : Integer = 1; attribute y : Integer = x + 1; }}
+        part p : Item[{size}]; attribute choice[1] : Integer;
+        assert constraint c {{ choice == 0 & p->forAll {{ in x; x.y == 2 & x.x == 1 }} }}
+    }}"
+    )
+}
+
+// The Boolean marks declarations whose multiplicity proves scalar arity.
+pub fn scalar_admission() -> Vec<(String, bool)> {
+    let mut cases = Vec::new();
+    for (declarations, scope, scalar) in [
+        ("attribute x : Integer;", "", false),
+        ("attribute x[1] : Integer;", "", true),
+        ("attribute x : Integer;", "part def D {", true),
+        ("ref x : Integer;", "part def D {", false),
+        (
+            "attribute base[1] : Integer; attribute x :> base;",
+            "",
+            true,
+        ),
+        (
+            "attribute base[2] : Integer; attribute x :> base;",
+            "",
+            false,
+        ),
+        (
+            "attribute base[2] : Integer; attribute x[1] :> base;",
+            "",
+            true,
+        ),
+        ("attribute base : Integer; attribute x :> base;", "", false),
+        ("attribute x : Integer :> absent;", "part def D {", false),
+    ] {
+        let close = if scope.is_empty() { "" } else { "}" };
+        cases.push((
+            format!(
+                "package P {{ attribute def Integer; {scope}
+            {declarations} assert constraint c {{ x == 0 & x == 1 }} {close} }}"
+            ),
+            scalar,
+        ));
+    }
+    cases
+}
+
+pub fn body_scalar_admission() -> Vec<(sysmlv2_model::model::Model, bool)> {
+    [
+        ("feature x : Integer { multiplicity [1]; }", true),
+        ("feature x : Integer { multiplicity [2]; }", false),
+        (
+            "multiplicity one[1]; feature x : Integer { multiplicity subsets one; }",
+            true,
+        ),
+        (
+            "multiplicity many[2]; feature x : Integer { multiplicity subsets many; }",
+            false,
+        ),
+        (
+            "multiplicity unknown subsets absent; feature x : Integer { multiplicity subsets unknown; }",
+            false,
+        ),
+    ]
+    .into_iter()
+    .map(|(declaration, scalar)| {
+        let mut model = sysmlv2_model::model::Model::new();
+        let unit = model.add_source(
+            "bounds.kerml",
+            &format!("package P {{ datatype Integer; {declaration} }}"),
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        let unit = model.add_source(
+            "constraint.sysml",
+            "assert constraint c { P::x == 0 & P::x == 1 }",
+        );
+        assert!(unit.diagnostics.is_empty(), "{:?}", unit.diagnostics);
+        assert!(!model.has_errors());
+        (model, scalar)
+    })
+    .collect()
+}
diff --git a/crates/sysmlv2-solve/tests/corpus.rs b/crates/sysmlv2-solve/tests/corpus.rs
index a42bbc8..881b4f5 100644
--- a/crates/sysmlv2-solve/tests/corpus.rs
+++ b/crates/sysmlv2-solve/tests/corpus.rs
@@ -23,7 +23,11 @@ fn corpus_solve_ratchet() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        // Distinct source paths can share a basename; keep their identity seeds distinct.
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let solved = solve_constraints(&model, &cfg).unwrap();
     let (mut valid, mut sat, mut unsat, mut unknown) = (0, 0, 0, 0);
@@ -86,9 +90,23 @@ fn corpus_solve_ratchet() {
     // Example and `generator.generateTorque.torque` in 12b-Allocation-1
     // now stay unknown. Supporting them again requires preserving each
     // receiver path in the solver's variable identity.
+    // 63/29 → 61/32 with effective cardinality and guarded collection
+    // translation: one scenario's inherited unbound samples stop making
+    // its size-dependent quantifier vacuously true (enters unknown).
+    // An unbound componentMasses redefinition inherits [0..*], so it
+    // cannot supply one scalar summand; an autoPort with an unresolved
+    // redefinition likewise cannot supply a known singleton. Both lose
+    // fabricated scalar witnesses. Exact expanded variant instances
+    // still solve, independently of their root collection's multiplicity.
+    // 61/32 → 37/58 with normative defaults and inherited subsettings:
+    // 24 scalar witnesses depended on explicitly subsetted [*] quantities,
+    // generic parameters, non-structural variation usages, or package-owned
+    // receivers whose cardinality is not one. Two formerly static verdicts
+    // likewise become unknown. Requirement/case subjects retain their actual
+    // inherited [1] through complete supported positional redefinitions.
     assert_eq!(
         (valid, sat, unsat, unknown),
-        (1, 63, 0, 29),
+        (1, 37, 0, 58),
         "solve ratchet moved — unsatisfiable must stay 0 on the \
          conforming corpus; satisfiable/unknown changes require an \
          explained translation improvement or soundness correction"
diff --git a/crates/sysmlv2-solve/tests/environment_identity.rs b/crates/sysmlv2-solve/tests/environment_identity.rs
new file mode 100644
index 0000000..7e4ba2e
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/environment_identity.rs
@@ -0,0 +1,794 @@
+//! Runtime arguments retain declaration identity across lexical scopes and replay.
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_model::{
+    check::ConstraintVerdict, json::ResolvedModel, libcache::LibraryCache, model::Model,
+    prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, z3_version,
+};
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+fn native_solve(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &SolverConfig,
+) -> Vec<sysmlv2_solve::SolvedConstraint> {
+    if z3_version(cfg).is_err() {
+        return Vec::new();
+    }
+    solve_constraints_with(r, model, cfg).unwrap()
+}
+fn models(source: &str) -> Vec<Model> {
+    let lib = "package ScalarValues { datatype Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                m.add_source(
+                    format!("{pkg}.sysml"),
+                    &format!("package {pkg} {{ attribute x[1]:ScalarValues::Integer; {source} }}"),
+                );
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+fn run(form: &str) {
+    let cfg = SolverConfig::default();
+    for reverse in [false, true] {
+        let (actual, argument) = if reverse { (2, 1) } else { (1, 5) };
+        let other = if reverse { 1 } else { 2 };
+        let (source, target, site_owner, da, db, sata, satb) = match form {
+            "global" => (
+                format!(
+                    "attribute Actual={actual}; calc def F {{ in '{ID}'; '{ID}' }} attribute direct=F({argument}); assert constraint c {{ F(x)==1 & x=={argument} }}"
+                ),
+                "A::Actual",
+                "A::F",
+                format!("Integer({actual})"),
+                format!("Integer({argument})"),
+                !reverse,
+                reverse,
+            ),
+            "parameter" => (
+                format!(
+                    "calc def F {{ in p; in '{ID}'; '{ID}' }} attribute direct=F({actual},{argument}); assert constraint c {{ F({actual},x)==1 & x=={argument} }}"
+                ),
+                "A::F::p",
+                "A::F",
+                format!("Integer({actual})"),
+                format!("Integer({argument})"),
+                !reverse,
+                reverse,
+            ),
+            "cross_call" => (
+                format!(
+                    "attribute Actual={actual}; attribute '{ID}'={other}; calc def G {{ in p; '{ID}' }} calc def F {{ in '{ID}'; G(0) }} attribute direct=F(5); assert constraint c {{ F(x)==1 & x==5 }}"
+                ),
+                "A::Actual",
+                "A::G",
+                format!("Integer({actual})"),
+                format!("Integer({other})"),
+                !reverse,
+                reverse,
+            ),
+            "lambda_global" => (
+                format!(
+                    "attribute Actual={actual}; calc def F {{ in p; p->forAll {{ in '{ID}':ScalarValues::Integer; '{ID}'==1 }} }} attribute direct=F({argument}); assert constraint c {{ F(x) & x=={argument} }}"
+                ),
+                "A::Actual",
+                "lambda",
+                format!("Boolean({})", !reverse),
+                format!("Boolean({reverse})"),
+                !reverse,
+                reverse,
+            ),
+            "lambda_parameter" => (
+                format!(
+                    "attribute '{ID}'={other}; calc def F {{ in p; p->forAll {{ in memberValue:ScalarValues::Integer; '{ID}'==1 }} }} attribute direct=F({actual}); assert constraint c {{ F(x) & x=={actual} }}"
+                ),
+                "lambda_parameter",
+                "lambda",
+                format!("Boolean({})", !reverse),
+                format!("Boolean({reverse})"),
+                !reverse,
+                reverse,
+            ),
+            _ => unreachable!(),
+        };
+        for (mode, m) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&m);
+            let target = if target == "lambda_parameter" {
+                let f = r.resolve_qualified("A::F").unwrap();
+                let candidates: Vec<_> = r
+                    .elements()
+                    .filter(|e| {
+                        r.element_properties(*e)
+                            .get("declaredName")
+                            .and_then(|v| v.as_str())
+                            == Some("memberValue")
+                    })
+                    .collect();
+                candidates
+                    .into_iter()
+                    .find(|e| {
+                        let mut cur = r.owner(*e);
+                        while let Some(owner) = cur {
+                            if owner == f {
+                                return true;
+                            }
+                            cur = r.owner(owner);
+                        }
+                        false
+                    })
+                    .unwrap()
+            } else {
+                r.resolve_qualified(target).unwrap()
+            };
+            let edge = if site_owner == "lambda" {
+                let candidates: Vec<_> = r
+                    .elements()
+                    .filter(|e| {
+                        r.element_properties(*e)
+                            .get("declaredName")
+                            .and_then(|v| v.as_str())
+                            == Some(ID)
+                    })
+                    .collect();
+                candidates
+                    .into_iter()
+                    .flat_map(|e| r.references_to(e))
+                    .find(|s| m.unit(s.unit).name == "A.sysml")
+                    .unwrap()
+                    .owner
+            } else {
+                let owner = r.resolve_qualified(site_owner).unwrap();
+                let expr = r.members_via(owner, "ResultExpressionMembership")[0];
+                r.owned_relationships(expr)
+                    .into_iter()
+                    .find(|e| r.element_type(*e) == "Membership")
+                    .unwrap()
+            };
+            r.override_ids(&HashMap::from([(
+                r.element_id(target),
+                ID.parse().unwrap(),
+            )]));
+            let mut hints = HashMap::from([(
+                (r.element_id(edge), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                for (pkg, expected) in [("B", &db), ("A", &da)] {
+                    let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                    assert_eq!(
+                        format!("{:?}", r.evaluate(e).unwrap()),
+                        *expected,
+                        "{form} reverse={reverse} mode={mode} {pkg}"
+                    );
+                }
+                for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                    let sat = if m.unit(c.unit).name == "A.sysml" {
+                        sata
+                    } else {
+                        satb
+                    };
+                    let got = match c.verdict {
+                        ConstraintVerdict::Satisfied => true,
+                        ConstraintVerdict::Violated => false,
+                        _ => match c.propagate {
+                            Some(PropagateOutcome::Satisfied) => true,
+                            Some(PropagateOutcome::Unsatisfiable)
+                            | Some(PropagateOutcome::Violated) => false,
+                            _ => panic!("unexpected {c:?}"),
+                        },
+                    };
+                    assert_eq!(got, sat, "{form} mode{mode}");
+                }
+                for c in native_solve(&mut r, &m, &cfg) {
+                    let sat = if m.unit(c.unit).name == "A.sysml" {
+                        sata
+                    } else {
+                        satb
+                    };
+                    let got = match c.verdict {
+                        ConstraintVerdict::Satisfied => true,
+                        ConstraintVerdict::Violated => false,
+                        _ => match c.solve {
+                            Some(SolveOutcome::Satisfiable(_)) | Some(SolveOutcome::Valid) => true,
+                            Some(SolveOutcome::Unsatisfiable) => false,
+                            _ => panic!("unexpected {c:?}"),
+                        },
+                    };
+                    assert_eq!(got, sat, "{form} mode{mode}");
+                }
+            }
+            if mode == 3 {
+                assert_eq!(m.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+#[test]
+fn exact_global_beats_unrelated_same_named_parameter() {
+    run("global")
+}
+#[test]
+fn exact_parameter_identity_reads_its_runtime_argument() {
+    run("parameter")
+}
+#[test]
+fn a_separate_callee_cannot_capture_callers_parameter() {
+    run("cross_call")
+}
+#[test]
+fn exact_global_beats_typed_lambda_parameter_spelling() {
+    run("lambda_global")
+}
+#[test]
+fn exact_typed_lambda_parameter_identity_reads_runtime_member() {
+    run("lambda_parameter")
+}
+
+#[test]
+fn lexical_nested_calculation_and_lambda_capture_remains_supported() {
+    for source in [
+        "calc def F { in p; calc def G { p } G() }",
+        "calc def F { in p; (1,2)->forAll { in q; q>0 & p==5 } }",
+    ] {
+        let condition = if source.contains("G()") {
+            "F(x)==x & x==5"
+        } else {
+            "F(x) & x==5"
+        };
+        for (mode, m) in models(&format!(
+            "{source} attribute direct=F(5); assert constraint c {{ {condition} }}"
+        ))
+        .into_iter()
+        .enumerate()
+        {
+            let mut r = ResolvedModel::build(&m);
+            for _ in 0..2 {
+                for pkg in ["B", "A"] {
+                    let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                    let v = format!("{:?}", r.evaluate(e).unwrap());
+                    assert_eq!(
+                        v,
+                        if source.contains("G()") {
+                            "Integer(5)"
+                        } else {
+                            "Boolean(true)"
+                        },
+                        "mode{mode}"
+                    );
+                }
+                for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                    assert_eq!(
+                        c.propagate,
+                        Some(PropagateOutcome::Satisfied),
+                        "{source}: {c:?}"
+                    );
+                }
+                for c in native_solve(&mut r, &m, &Default::default()) {
+                    assert!(
+                        matches!(c.solve, Some(SolveOutcome::Satisfiable(_))),
+                        "{source}: {c:?}"
+                    );
+                }
+            }
+            if mode == 3 {
+                assert_eq!(m.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn exact_callee_identity_bypasses_unrelated_noncallable_parameter() {
+    let source = format!(
+        "calc def Actual {{ in p; p+1 }} calc def F {{ in '{ID}'; in n; '{ID}'(n) }} attribute direct=F(5,0); assert constraint c {{ F(5,x)==1 & x==0 }}"
+    );
+    let cfg = SolverConfig::default();
+    for (mode, m) in models(&source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&m);
+        let actual = r.resolve_qualified("A::Actual").unwrap();
+        let f = r.resolve_qualified("A::F").unwrap();
+        let expr = r.members_via(f, "ResultExpressionMembership")[0];
+        let edge = r
+            .owned_relationships(expr)
+            .into_iter()
+            .find(|e| r.element_type(*e) == "Membership")
+            .unwrap();
+        r.override_ids(&HashMap::from([(
+            r.element_id(actual),
+            ID.parse().unwrap(),
+        )]));
+        let mut hints = HashMap::from([(
+            (r.element_id(edge), "memberElement".into()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let a = r.resolve_qualified("A::direct").unwrap();
+            let b = r.resolve_qualified("B::direct").unwrap();
+            assert_eq!(
+                format!("{:?}", r.evaluate(a).unwrap()),
+                "Integer(1)",
+                "mode{mode}"
+            );
+            assert!(r.evaluate(b).is_err());
+            for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                if m.unit(c.unit).name == "A.sysml" {
+                    assert_eq!(c.propagate, Some(PropagateOutcome::Satisfied));
+                } else {
+                    assert!(matches!(
+                        c.propagate,
+                        Some(PropagateOutcome::Unsupported(_))
+                    ));
+                }
+            }
+            for c in native_solve(&mut r, &m, &cfg) {
+                if m.unit(c.unit).name == "A.sysml" {
+                    assert!(matches!(c.solve, Some(SolveOutcome::Satisfiable(_))));
+                } else {
+                    assert!(matches!(c.solve, Some(SolveOutcome::Unknown(_))));
+                }
+            }
+        }
+        if mode == 3 {
+            assert_eq!(m.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn qualified_enclosing_parameters_and_recursive_defaults_keep_separate_frames() {
+    use sysmlv2_model::eval::Value;
+    let source = "calc def Outer { in x; calc def Inner { in x; x + Outer::x } Inner(2) }
+        calc def Recur { in n; in x default 2; if n > 0 ? Recur(n - 1) else x }
+        calc def Required { in n; in x; if n > 0 ? Required(n - 1) else x }
+        attribute direct = Outer(5);
+        attribute recursiveDefault = Recur(1,9);
+        attribute recursiveMissing = Required(1,9);
+        attribute recovery = Recur(0,8);
+        assert constraint c { Outer(x)==7 & x==5 }";
+    for (mode, m) in models(source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&m);
+        for _ in 0..2 {
+            for pkg in ["A", "B"] {
+                for (name, expected) in [("direct", 7), ("recursiveDefault", 2), ("recovery", 8)] {
+                    let e = r.resolve_qualified(&format!("{pkg}::{name}")).unwrap();
+                    assert_eq!(
+                        r.evaluate(e),
+                        Ok(Value::Integer(expected)),
+                        "{pkg}::{name} mode{mode}"
+                    );
+                }
+                let e = r
+                    .resolve_qualified(&format!("{pkg}::recursiveMissing"))
+                    .unwrap();
+                assert!(r.evaluate(e).is_err());
+            }
+            for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                assert_eq!(c.propagate, Some(PropagateOutcome::Satisfied));
+            }
+            for c in native_solve(&mut r, &m, &Default::default()) {
+                assert!(matches!(c.solve, Some(SolveOutcome::Satisfiable(_))));
+            }
+        }
+        if mode == 3 {
+            assert_eq!(m.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn inherited_parameter_dependencies_use_the_active_call_argument() {
+    use sysmlv2_model::eval::Value;
+    for (name, body) in [
+        ("p", "v"),
+        ("q", "v"),
+        ("q", "sum(v)"),
+        ("p", "Base::p"),
+        ("q", "Base::p"),
+        ("q", "alias old for Base::p; old"),
+        ("q", "calc def Nested { Base::p } Nested()"),
+    ] {
+        let source = format!(
+            "calc def Base {{ in p default 1; attribute v=p; }}
+            calc def Child :>Base {{ in {name} :>> Base::p default 2; {body} }}
+            attribute direct=Child(7); attribute defaulted=Child();
+            assert constraint c {{ Child(x)==7 & x==7 }}"
+        );
+        for (mode, m) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&m);
+            for _ in 0..2 {
+                for pkg in ["A", "B"] {
+                    for (member, value) in [("direct", 7), ("defaulted", 2)] {
+                        let e = r.resolve_qualified(&format!("{pkg}::{member}")).unwrap();
+                        assert_eq!(
+                            r.evaluate(e),
+                            Ok(Value::Integer(value)),
+                            "name={name} body={body} mode={mode} {member}"
+                        );
+                    }
+                }
+                for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                    assert_eq!(
+                        c.propagate,
+                        Some(PropagateOutcome::Satisfied),
+                        "name={name} body={body} mode={mode}"
+                    );
+                }
+                for c in native_solve(&mut r, &m, &Default::default()) {
+                    assert!(
+                        matches!(c.solve, Some(SolveOutcome::Satisfiable(_))),
+                        "name={name} body={body} mode={mode}"
+                    );
+                }
+            }
+            if mode == 3 {
+                assert_eq!(m.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn unrelated_declarations_do_not_capture_specialized_arguments() {
+    use sysmlv2_model::eval::Value;
+    let source = "calc def Base {in p default 1;}
+        attribute packageValue = Base::p;
+        calc def Other { Base::p }
+        calc def Child :>Base { in q :>>Base::p; Other()+packageValue }
+        attribute direct=Child(7);
+        assert constraint c {Child(x)==2 & x==7}";
+    for m in models(source) {
+        let mut r = ResolvedModel::build(&m);
+        for pkg in ["A", "B"] {
+            let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+            assert_eq!(r.evaluate(e), Ok(Value::Integer(2)));
+        }
+        for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+            assert_eq!(c.propagate, Some(PropagateOutcome::Satisfied));
+        }
+        for c in native_solve(&mut r, &m, &Default::default()) {
+            assert!(matches!(c.solve, Some(SolveOutcome::Satisfiable(_))));
+        }
+    }
+}
+
+#[test]
+fn root_and_package_values_keep_lexical_dependencies_in_calls() {
+    use sysmlv2_model::eval::Value;
+    for root in [false, true] {
+        for body in ["v", "sum(v)"] {
+            for expected in [1, 2] {
+                let globals = if root {
+                    "attribute p=1; attribute v=p;"
+                } else {
+                    "package Values { attribute p=1; attribute v=p; }
+                     private import Values::*;"
+                };
+                let source = format!(
+                    "{globals} calc def Child {{ in p default 2; {body} }}
+                     attribute direct=Child(7);
+                     assert constraint c {{Child(x)=={expected} & x==7}}"
+                );
+                let fixtures = if root { models("") } else { models(&source) };
+                for (mode, mut model) in fixtures.into_iter().enumerate() {
+                    if root {
+                        model.add_source(
+                            "root.sysml",
+                            &format!("attribute x[1]:ScalarValues::Integer; {source}"),
+                        );
+                        assert!(!model.has_errors());
+                    }
+                    let mut resolved = ResolvedModel::build(&model);
+                    for _ in 0..2 {
+                        for name in if root {
+                            &["direct"][..]
+                        } else {
+                            &["A::direct", "B::direct"][..]
+                        } {
+                            let value = resolved.resolve_qualified(name).unwrap();
+                            assert_eq!(
+                                resolved.evaluate(value),
+                                Ok(Value::Integer(1)),
+                                "root={root} body={body} expected={expected} mode={mode}",
+                            );
+                        }
+                        for constraint in
+                            propagate_constraints_with(&mut resolved, &model, &Default::default())
+                                .constraints
+                        {
+                            if expected == 1 {
+                                assert_eq!(constraint.propagate, Some(PropagateOutcome::Satisfied));
+                            } else {
+                                assert!(matches!(
+                                    constraint.propagate,
+                                    Some(
+                                        PropagateOutcome::Unsatisfiable
+                                            | PropagateOutcome::Violated
+                                    )
+                                ));
+                            }
+                        }
+                        for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                            if expected == 1 {
+                                assert!(matches!(
+                                    constraint.solve,
+                                    Some(SolveOutcome::Satisfiable(_))
+                                ));
+                            } else {
+                                assert!(
+                                    constraint.verdict == ConstraintVerdict::Violated
+                                        || constraint.solve == Some(SolveOutcome::Unsatisfiable)
+                                );
+                            }
+                        }
+                    }
+                    if mode == 3 {
+                        assert_eq!(model.loaded_library_unit_count(), 0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn exact_parameter_identity_requires_lexical_frame_visibility() {
+    use sysmlv2_model::eval::Value;
+    for (source, expected) in [
+        (
+            "calc def Other { Base::p }
+             calc def Base { in p default 1; Other() }",
+            1,
+        ),
+        (
+            "attribute bridge=Base::p;
+             calc def Base { in p default 1; bridge }",
+            1,
+        ),
+        (
+            "calc def Base { in p default 1;
+                 calc def Nested { Base::p } Nested() }",
+            7,
+        ),
+    ] {
+        for (mode, model) in models(&format!(
+            "{source} attribute direct=Base(7);
+             assert constraint c {{ Base(x)=={expected} & x==7 }}"
+        ))
+        .into_iter()
+        .enumerate()
+        {
+            let mut resolved = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                for name in ["A::direct", "B::direct"] {
+                    let element = resolved.resolve_qualified(name).unwrap();
+                    assert_eq!(
+                        resolved.evaluate(element),
+                        Ok(Value::Integer(expected)),
+                        "mode={mode} source={source}",
+                    );
+                }
+                for constraint in
+                    propagate_constraints_with(&mut resolved, &model, &Default::default())
+                        .constraints
+                {
+                    assert_eq!(constraint.propagate, Some(PropagateOutcome::Satisfied));
+                }
+                for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                    assert!(matches!(
+                        constraint.solve,
+                        Some(SolveOutcome::Satisfiable(_))
+                    ));
+                }
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn unrelated_type_values_cannot_fall_back_to_same_named_inputs() {
+    for body in ["v", "sum(v)"] {
+        for lexical_parameter in ["attribute p=1;", ""] {
+            for (mode, model) in models(&format!(
+                "part def Box {{{lexical_parameter} attribute v=p;}}
+             calc def Child {{in p default 2; alias v for Box::v; {body}}}
+             attribute direct=Child(7);
+             attribute wrapped[1]:ScalarValues::Integer=Child(x);
+             assert constraint c {{Child(x)==2 & x==7}}
+             assert constraint wrappedConstraint {{wrapped==2 & x==7}}"
+            ))
+            .into_iter()
+            .enumerate()
+            {
+                let mut resolved = ResolvedModel::build(&model);
+                for _ in 0..2 {
+                    for name in ["A::direct", "B::direct", "A::wrapped", "B::wrapped"] {
+                        let element = resolved.resolve_qualified(name).unwrap();
+                        let value = resolved.evaluate(element);
+                        if lexical_parameter.is_empty() {
+                            assert!(value.is_err());
+                        } else {
+                            assert_eq!(
+                                value,
+                                Ok(sysmlv2_model::eval::Value::Integer(1)),
+                                "mode={mode} body={body} name={name}"
+                            );
+                        }
+                    }
+                    for constraint in
+                        propagate_constraints_with(&mut resolved, &model, &Default::default())
+                            .constraints
+                    {
+                        assert!(
+                            if lexical_parameter.is_empty() {
+                                matches!(
+                                    constraint.propagate,
+                                    Some(PropagateOutcome::Unsupported(_))
+                                )
+                            } else {
+                                matches!(
+                                    constraint.propagate,
+                                    Some(
+                                        PropagateOutcome::Unsatisfiable
+                                            | PropagateOutcome::Violated
+                                    )
+                                )
+                            },
+                            "mode={mode} body={body} lexical={lexical_parameter}: {constraint:?}",
+                        );
+                    }
+                    for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                        assert!(
+                            if lexical_parameter.is_empty() {
+                                matches!(constraint.solve, Some(SolveOutcome::Unknown(_)))
+                            } else {
+                                constraint.solve == Some(SolveOutcome::Unsatisfiable)
+                                    || constraint.verdict == ConstraintVerdict::Violated
+                            },
+                            "mode={mode} body={body} lexical={lexical_parameter}: {constraint:?}",
+                        );
+                    }
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn ambiguous_or_incomplete_runtime_parameter_redefinitions_never_use_a_base_default() {
+    for parameters in [
+        "in p :>>Base::p; in q :>>Base::p;",
+        "in q :>>Base::p; in p :>>Base::p;",
+        "in p :>>Missing; in q;",
+        "in p :>>q; in q :>>p;",
+    ] {
+        for m in models(&format!(
+            "calc def Base {{in p default 1;}} calc def Child :>Base {{ {parameters} Base::p }} attribute direct=Child(7,8); assert constraint c {{Child(x,8)==1 & x==7}}"
+        )) {
+            let mut r = ResolvedModel::build(&m);
+            for pkg in ["A", "B"] {
+                let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                assert!(r.evaluate(e).is_err(), "{parameters}");
+            }
+            for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                assert!(
+                    matches!(c.propagate, Some(PropagateOutcome::Unsupported(_))),
+                    "{parameters}: {c:?}"
+                );
+            }
+            for c in native_solve(&mut r, &m, &Default::default()) {
+                assert!(
+                    matches!(c.solve, Some(SolveOutcome::Unknown(_))),
+                    "{parameters}: {c:?}"
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn exact_general_parameter_identity_uses_the_supported_contextual_slot() {
+    use sysmlv2_model::eval::Value;
+    for reverse in [false, true] {
+        let (argument, ordinary) = if reverse { (9, 7) } else { (7, 9) };
+        let source = format!(
+            "calc def Base {{in p default 1;}} calc def Child :>Base {{in q :>>Base::p; attribute '{ID}'={ordinary}; '{ID}'}} attribute direct=Child({argument}); assert constraint c {{Child(x)==7 & x=={argument}}}"
+        );
+        for (mode, m) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&m);
+            let target = r.resolve_qualified("A::Base::p").unwrap();
+            let child = r.resolve_qualified("A::Child").unwrap();
+            let result = r.members_via(child, "ResultExpressionMembership")[0];
+            let edge = r
+                .owned_relationships(result)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Membership")
+                .unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(target),
+                ID.parse().unwrap(),
+            )]));
+            let mut hints = HashMap::from([(
+                (r.element_id(edge), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                for (pkg, value) in [("A", argument), ("B", ordinary)] {
+                    let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                    assert_eq!(
+                        r.evaluate(e),
+                        Ok(Value::Integer(value)),
+                        "reverse={reverse} mode={mode} {pkg}"
+                    );
+                }
+                for c in propagate_constraints_with(&mut r, &m, &Default::default()).constraints {
+                    let sat = (m.unit(c.unit).name == "A.sysml") != reverse;
+                    assert_eq!(
+                        c.propagate,
+                        Some(if sat {
+                            PropagateOutcome::Satisfied
+                        } else if m.unit(c.unit).name == "B.sysml" {
+                            PropagateOutcome::Violated
+                        } else {
+                            PropagateOutcome::Unsatisfiable
+                        })
+                    );
+                }
+                for c in native_solve(&mut r, &m, &Default::default()) {
+                    let sat = (m.unit(c.unit).name == "A.sysml") != reverse;
+                    assert!(if sat {
+                        matches!(c.solve, Some(SolveOutcome::Satisfiable(_)))
+                    } else {
+                        matches!(c.solve, Some(SolveOutcome::Unsatisfiable))
+                    });
+                }
+            }
+            if mode == 3 {
+                assert_eq!(m.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/propagate.rs b/crates/sysmlv2-solve/tests/propagate.rs
index 6fa498a..1f20ee6 100644
--- a/crates/sysmlv2-solve/tests/propagate.rs
+++ b/crates/sysmlv2-solve/tests/propagate.rs
@@ -89,10 +89,10 @@ fn unknown_receiver_formulas_and_aliases_do_not_decide_propagation() {
         let p = prop(&format!(
             "package P {{
                 attribute def Boolean;
-                part def Child {{ attribute enabled : Boolean default = false; }}
+                part def Child {{ attribute enabled[1] : Boolean default = false; }}
                 part def Device {{
-                    attribute enabled : Boolean default = false;
-                    attribute computed : Boolean = enabled;
+                    attribute enabled[1] : Boolean default = false;
+                    attribute computed[1] : Boolean = enabled;
                     part child : Child;
                 }}
                 requirement def R {{
@@ -117,7 +117,7 @@ fn nested_unknown_receivers_do_not_share_solver_variables() {
     let p = prop(
         "package P {
             attribute def Real;
-            part def Child { attribute value : Real default = 0; }
+            part def Child { attribute value[1] : Real default = 0; }
             part def Parent { part child : Child; }
             requirement def R {
                 subject leftUnit : Parent;
@@ -142,7 +142,7 @@ fn lower_bound_narrows_to_half_line() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute wingSpan : Real;
+            attribute wingSpan[1] : Real;
             assert constraint c { wingSpan >= 10 }
         }",
     );
@@ -153,6 +153,24 @@ fn lower_bound_narrows_to_half_line() {
     assert_eq!(sole_outcome(&p), PropagateOutcome::Satisfied);
 }
 
+/// An invocation of a calculation that declares no result propagates
+/// through the nearest result its heritage declares.
+#[test]
+fn ranges_narrow_through_an_inherited_result() {
+    let p = prop(
+        "package P {
+            attribute def Real;
+            calc def Diff { in a; in b; return r = a - b; }
+            calc def D3 :> Diff { in x; }
+            attribute wingSpan[1] : Real;
+            assert constraint c { D3(wingSpan, 3) >= 7 }
+        }",
+    );
+    let r = range_of(&p, "wingSpan");
+    assert_eq!(r.range, "[10, +∞]");
+    assert!(r.narrowed);
+}
+
 #[test]
 fn lower_bound_tightens_twice() {
     // A half-line's finite side keeps moving under a second, stronger
@@ -161,7 +179,7 @@ fn lower_bound_tightens_twice() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
+            attribute x[1] : Real;
             assert constraint open { x > 0 }
             assert constraint strong { x >= 1000 }
             assert constraint weak { x >= 500 }
@@ -178,7 +196,7 @@ fn two_constraints_narrow_jointly() {
     let p = prop(
         "package Tank {
             attribute def Real;
-            attribute level : Real;
+            attribute level[1] : Real;
             assert constraint lo { level >= 5 }
             assert constraint hi { level <= 8 }
         }",
@@ -199,8 +217,8 @@ fn product_backsolves_the_other_factor() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
-            attribute y : Real;
+            attribute x[1] : Real;
+            attribute y[1] : Real;
             assert constraint fix { x == 2 }
             assert constraint prod { x * y == 6 }
         }",
@@ -225,7 +243,7 @@ fn contradiction_is_unsatisfiable() {
     let p = prop(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x > 5 & x < 4 }
         }",
     );
@@ -238,7 +256,7 @@ fn joint_contradiction_across_constraints_is_unsatisfiable() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute t : Real;
+            attribute t[1] : Real;
             assert constraint lo { t >= 9 }
             assert constraint hi { t <= 3 }
         }",
@@ -260,8 +278,8 @@ fn division_by_a_zero_straddling_divisor_stays_wide() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
-            attribute y : Real;
+            attribute x[1] : Real;
+            attribute y[1] : Real;
             assert constraint yb1 { y >= -1 }
             assert constraint yb2 { y <= 1 }
             assert constraint q { x == 6 / y }
@@ -292,8 +310,8 @@ fn remainder_by_a_possibly_zero_divisor_stays_undecided() {
     let p = prop(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
-            attribute y : Integer;
+            attribute x[1] : Integer;
+            attribute y[1] : Integer;
             assert constraint yb1 { y >= 0 }
             assert constraint yb2 { y <= 5 }
             assert constraint m { x % y == 100 }
@@ -313,8 +331,8 @@ fn division_by_an_exactly_zero_divisor_constrains_nothing() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
-            attribute y : Real;
+            attribute x[1] : Real;
+            attribute y[1] : Real;
             assert constraint yz { y == 0 }
             assert constraint q { x == 6 / y }
             assert constraint xb { x >= 5 }
@@ -333,8 +351,8 @@ fn backward_division_keeps_zero_in_the_divisor() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
-            attribute y : Real;
+            attribute x[1] : Real;
+            attribute y[1] : Real;
             assert constraint xf { x == 4 }
             assert constraint q { x / y == 2 }
         }",
@@ -363,9 +381,9 @@ fn ranges_narrow_through_a_sum_fold() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute x : Real;
-            attribute a : Real;
-            attribute b : Real;
+            attribute x[1] : Real;
+            attribute a[1] : Real;
+            attribute b[1] : Real;
             attribute ps : Real[0..*] = (a, b);
             assert constraint xs { x == sum(ps) }
             assert constraint af { a == 2 }
@@ -394,9 +412,9 @@ fn max_fold_pins_the_result() {
     let p = prop(
         "package P {
             attribute def Integer;
-            attribute hi : Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute hi[1] : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             assert constraint m { hi == max((a, b)) }
             assert constraint af { a == 2 }
             assert constraint bf { b == 7 }
@@ -429,8 +447,8 @@ fn max_over_forty_items_stays_linear() {
     let p = prop(&format!(
         "package P {{
             attribute def Integer;
-            attribute x : Integer;
-            attribute y : Integer;
+            attribute x[1] : Integer;
+            attribute y[1] : Integer;
             assert constraint m {{ x == max(({}, y)) }}
             assert constraint yf {{ y == 45 }}
         }}",
@@ -458,7 +476,7 @@ fn separate_units_each_see_their_own_enumerations() {
             "a.sysml",
             "package A {
                 enum def Phase { init; run; halt; }
-                attribute p : Phase;
+                attribute p[1] : Phase;
                 assert constraint ap { p == Phase::halt }
             }",
         ),
@@ -466,7 +484,7 @@ fn separate_units_each_see_their_own_enumerations() {
             "b.sysml",
             "package B {
                 enum def Colour { red; green; blue; }
-                attribute c : Colour;
+                attribute c[1] : Colour;
                 assert constraint bc { c != Colour::red }
             }",
         ),
@@ -496,7 +514,7 @@ fn ranges_narrow_through_a_skolemized_forall() {
         "package P {
             attribute def Real;
             part def W {
-                attribute r : Real;
+                attribute r[1] : Real;
             }
             part ws : W[2];
             assert constraint c { ws->forAll {in w; w.r >= 3 & w.r <= 5} }
@@ -515,7 +533,7 @@ fn inequality_removes_one_enum_literal() {
     let p = prop(
         "package P {
             enum def Phase { halt; mid; init; }
-            attribute c : Phase;
+            attribute c[1] : Phase;
             assert constraint c1 { c != Phase::mid }
         }",
     );
@@ -533,7 +551,7 @@ fn enum_literals_past_position_128_stay_distinct() {
     let p = prop(&format!(
         "package P {{
             enum def Wide {{ {lits} }}
-            attribute c : Wide;
+            attribute c[1] : Wide;
             assert constraint pin {{ c == Wide::l130 }}
             assert constraint apart {{ c != Wide::l2 }}
         }}"
@@ -554,9 +572,9 @@ fn conjunction_degrades_per_conjunct() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute u; attribute v;
-            attribute margin : Real;
-            attribute mix : Real;
+            attribute u[1]; attribute v[1];
+            attribute margin[1] : Real;
+            attribute mix[1] : Real;
             assert constraint c { margin >= 2100 and mix + 1 ['u'] > 1 ['v'] }
         }",
     );
@@ -571,6 +589,68 @@ fn conjunction_degrades_per_conjunct() {
     }
 }
 
+/// A package-owned attribute written without a multiplicity is a
+/// collection of any size by the implicit default; the bail reason names
+/// the feature and the one-line fix.
+#[test]
+fn implicit_collection_names_the_multiplicity_fix() {
+    let p = prop(
+        "package P {
+            attribute def Real;
+            attribute airframeKg : Real;
+            assert constraint c { airframeKg >= 0.8 }
+        }",
+    );
+    match sole_outcome(&p) {
+        PropagateOutcome::Unsupported(m) => assert_eq!(
+            m,
+            "`airframeKg` declares no multiplicity, so it is a collection of any size; declare `[1]` for one value"
+        ),
+        o => panic!("expected the bail reason, got {o:?}"),
+    }
+}
+
+/// An explicitly open multiplicity is a choice, not an omission: the
+/// reason stays the cardinality itself, with no `[1]` advice.
+#[test]
+fn explicit_open_multiplicity_reports_the_cardinality() {
+    let p = prop(
+        "package P {
+            attribute def Real;
+            attribute masses : Real[0..*];
+            assert constraint c { masses >= 0.8 }
+        }",
+    );
+    match sole_outcome(&p) {
+        PropagateOutcome::Unsupported(m) => {
+            assert_eq!(m, "non-scalar or unknown cardinality of `masses`")
+        }
+        o => panic!("expected the bail reason, got {o:?}"),
+    }
+}
+
+/// A chain through a package-owned part names the part, since `[1]`
+/// belongs on the receiver, not on the member the chain reads.
+#[test]
+fn chain_through_implicit_collection_names_the_receiver() {
+    let p = prop(
+        "package P {
+            attribute def Real;
+            part avionics {
+                attribute massKg : Real = 0.28;
+            }
+            assert constraint c { avionics.massKg <= 0.3 }
+        }",
+    );
+    match sole_outcome(&p) {
+        PropagateOutcome::Unsupported(m) => assert_eq!(
+            m,
+            "a chain through `avionics`, which declares no multiplicity and so is a collection of any size; declare `[1]` on it for one value"
+        ),
+        o => panic!("expected the bail reason, got {o:?}"),
+    }
+}
+
 #[test]
 fn partial_conjunction_still_refutes() {
     // Translated conjuncts that contradict each other (an empty joint
@@ -579,9 +659,9 @@ fn partial_conjunction_still_refutes() {
     let p = prop(
         "package P {
             attribute def Real;
-            attribute u; attribute v;
-            attribute margin : Real;
-            attribute mix : Real;
+            attribute u[1]; attribute v[1];
+            attribute margin[1] : Real;
+            attribute mix[1] : Real;
             assert constraint c {
                 margin >= 5 and margin <= 4 and mix + 1 ['u'] > 1 ['v']
             }
@@ -604,7 +684,10 @@ fn corpus_no_false_violations() {
         .unwrap();
     for f in sysmlv2_testkit::user_files() {
         let src = std::fs::read_to_string(&f).unwrap();
-        model.add_source(f.file_name().unwrap().to_string_lossy().into_owned(), &src);
+        model.add_source(
+            sysmlv2_testkit::relative_source_name(&sysmlv2_testkit::corpus_root(), f.as_path()),
+            &src,
+        );
     }
     let p = propagate_constraints(&model, &PropagateConfig::default());
     for c in &p.constraints {
@@ -630,8 +713,8 @@ fn decimal_bounds_stay_exact() {
     let p = prop(
         "package Mass {
             attribute def Real;
-            attribute airframeKg : Real;
-            attribute batteryKg : Real;
+            attribute airframeKg[1] : Real;
+            attribute batteryKg[1] : Real;
             assert constraint airframeRange { airframeKg >= 0.8 and airframeKg <= 1.1 }
             assert constraint batteryRange { batteryKg >= 0.2 and batteryKg <= 0.3 }
         }",
@@ -649,7 +732,7 @@ fn non_terminating_bounds_print_as_fractions_and_hint_as_decimals() {
     let p = prop(
         "package Ratio {
             attribute def Real;
-            attribute share : Real;
+            attribute share[1] : Real;
             assert constraint c { share >= 1 / 3 and share <= 2 / 3 }
         }",
     );
@@ -657,3 +740,286 @@ fn non_terminating_bounds_print_as_fractions_and_hint_as_decimals() {
     assert_eq!(r.range, "[1/3, 2/3]");
     assert_eq!(r.range_approx, "[≈0.3333333333333333, ≈0.6666666666666666]");
 }
+
+#[test]
+fn named_user_calculations_are_not_symbolic_intrinsics() {
+    for call in ["sum(a)", "P::sum(a)"] {
+        let p = prop(&format!(
+            "package P {{
+            attribute def Integer;
+            attribute x[1] : Integer;
+            attribute a[1] : Integer;
+            calc def sum {{ in v; return r = v + 99; }}
+            assert constraint value {{ x == {call} }}
+            assert constraint input {{ a == 1 }}
+        }}"
+        ));
+        assert_eq!(range_of(&p, "x").range, "[100, 100]", "{call}");
+    }
+}
+
+#[test]
+fn unknown_qualified_intrinsic_names_do_not_constrain_values() {
+    let p = prop(
+        "package P {
+        attribute def Integer;
+        attribute x[1] : Integer;
+        attribute a[1] : Integer;
+        assert constraint value { x == Missing::sum(a) }
+    }",
+    );
+    assert!(matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)));
+}
+
+#[test]
+fn symbolic_lambda_bindings_do_not_call_outer_calculations() {
+    let p = prop(
+        "package P {
+        attribute def Integer;
+        attribute a[1] : Integer;
+        attribute b[1] : Integer;
+        calc def sum { in x; return r = x + 99; }
+        assert constraint value { (a, b)->forAll { in sum; sum(a) == 100 } }
+    }",
+    );
+    assert!(matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)));
+}
+
+#[test]
+fn unbound_collection_rollups_cannot_be_proved_from_one_default() {
+    for expression in [
+        "sum(rack.motors.mass)",
+        "sum((rack.motors,).mass)",
+        "sum((rack.motors as Motor).mass)",
+        "sum(rack.motors->collect { in m; m.mass })",
+    ] {
+        let p = prop(&format!(
+            "package P {{
+            attribute def Real;
+            part def Motor {{ attribute mass[1] : Real = 0.55; }}
+            part def Rack {{ part motors : Motor[4]; }}
+            part def Middle :> Rack {{ part :>> motors; }}
+            part rack : Middle {{ part :>> motors; }}
+            attribute total[1] : Real = {expression};
+            assert constraint direct {{ {expression} < 1 }}
+            assert constraint indirect {{ total < 1 }}
+        }}"
+        ));
+        for c in &p.constraints {
+            assert!(
+                matches!(c.verdict, ConstraintVerdict::Undecided(_)),
+                "{expression}: {c:?}"
+            );
+            assert!(
+                matches!(
+                    c.propagate,
+                    Some(PropagateOutcome::Undecided | PropagateOutcome::Unsupported(_))
+                ),
+                "{expression}: {c:?}"
+            );
+        }
+        assert_eq!(p.constraints.len(), 2);
+    }
+}
+
+#[test]
+fn inherited_collection_quantifiers_expand_exact_counts_only() {
+    let p = prop(
+        "package P {
+        attribute def Real;
+        part def Item { attribute value[1] : Real; }
+        part def Base { part items : Item[2]; }
+        part def Middle :> Base { part :>> items; }
+        part def Final :> Middle {
+            part :>> items : Item;
+            assert constraint c { items->forAll { in x; x.value >= 3 & x.value <= 5 } }
+        }
+    }",
+    );
+    for feature in ["items#1.value", "items#2.value"] {
+        assert_eq!(range_of(&p, feature).range, "[3, 5]");
+    }
+    for bound in ["0..1", "0..*", "count", "9007199254740993"] {
+        let p = prop(&format!(
+            "package P {{
+            attribute def Real;
+            attribute count[1];
+            part def Item {{ attribute value[1] : Real; }}
+            part items : Item[{bound}];
+            assert constraint c {{ items->forAll {{ in x; x.value > 0 }} }}
+        }}"
+        ));
+        assert!(
+            matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)),
+            "{bound}: {p:?}"
+        );
+        assert!(p.ranges.is_empty(), "{bound}: {p:?}");
+    }
+}
+
+#[test]
+fn collection_wrappers_do_not_become_scalar_solver_variables() {
+    for collection in [
+        "xs",
+        "if choose ? xs else xs",
+        "ReturnItems()",
+        "if choose ? copied else copied",
+    ] {
+        let p = prop(&format!(
+            "package P {{
+            attribute def Integer; attribute def Boolean;
+            attribute xs : Integer[4]; attribute choose[1] : Boolean;
+            attribute copied[1] : Integer = xs;
+            calc def ReturnItems {{ return result : Integer[4] = xs; }}
+            assert constraint c {{ size({collection}) == 1 }}
+        }}"
+        ));
+        if matches!(collection, "xs" | "ReturnItems()") {
+            assert!(matches!(
+                p.constraints[0].verdict,
+                ConstraintVerdict::Violated
+            ));
+        } else {
+            assert!(
+                matches!(
+                    sole_outcome(&p),
+                    PropagateOutcome::Undecided | PropagateOutcome::Unsupported(_)
+                ),
+                "{collection}: {p:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn approximate_collection_arguments_cannot_prove_parameter_arity() {
+    let p = prop(
+        "package P {
+        attribute def Integer; attribute def Boolean;
+        attribute xs : Integer[4]; attribute choose[1] : Boolean;
+        attribute copied[1] : Integer = xs;
+        calc def Count { in things; return n = size(things); }
+        assert constraint c { Count(if choose ? copied else copied) == 1 }
+    }",
+    );
+    assert!(
+        matches!(
+            sole_outcome(&p),
+            PropagateOutcome::Undecided | PropagateOutcome::Unsupported(_)
+        ),
+        "{p:?}"
+    );
+}
+
+#[test]
+fn quantified_items_do_not_scalarize_nested_collections() {
+    for expression in [
+        "size(x.motors.mass) == 1",
+        "size(x.values) == 1",
+        "sum(x.motors.mass) < 1",
+    ] {
+        let p = prop(&format!(
+            "package P {{
+            attribute def Integer; attribute def Real;
+            part def Motor {{ attribute mass[1] : Real = 0.55; }}
+            part def Item {{ part motors : Motor[4]; attribute values : Integer[4]; }}
+            part items : Item[2];
+            assert constraint c {{ items->forAll {{ in x; {expression} }} }}
+        }}"
+        ));
+        assert!(
+            matches!(
+                sole_outcome(&p),
+                PropagateOutcome::Undecided | PropagateOutcome::Unsupported(_)
+            ),
+            "{expression}: {p:?}"
+        );
+    }
+}
+
+#[test]
+fn quantified_scalar_instances_do_not_inherit_root_collection_arity() {
+    let p = prop(
+        "package P {
+        attribute def Integer;
+        attribute values : Integer[2];
+        assert constraint c { values->forAll { in x; x >= 3 & x <= 5 } }
+    }",
+    );
+    for feature in ["values#1", "values#2"] {
+        assert_eq!(range_of(&p, feature).range, "[3, 5]");
+    }
+}
+
+#[path = "common/collection_identity.rs"]
+mod collection_identity;
+
+#[test]
+fn contextual_member_formulas_do_not_capture_quantifier_bindings() {
+    for source in collection_identity::contextual_formulas() {
+        let p = prop(&source);
+        assert!(
+            matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)),
+            "{source}: {p:?}"
+        );
+    }
+    for size in [1, 2] {
+        let p = prop(&collection_identity::closed_member_formula(size));
+        assert_eq!(sole_outcome(&p), PropagateOutcome::Satisfied, "{p:?}");
+    }
+}
+
+#[test]
+fn quantified_members_preserve_reference_identity() {
+    for source in collection_identity::contradictions() {
+        let p = prop(&source);
+        assert_eq!(
+            sole_outcome(&p),
+            PropagateOutcome::Unsatisfiable,
+            "{source}: {p:?}"
+        );
+    }
+    for size in [1, 2] {
+        let source = collection_identity::distinct_receivers(size);
+        let p = prop(&source);
+        assert_eq!(
+            sole_outcome(&p),
+            PropagateOutcome::Satisfied,
+            "{source}: {p:?}"
+        );
+    }
+}
+
+#[test]
+fn scalar_admission_respects_defaults_and_subsetting() {
+    for (source, scalar) in collection_identity::scalar_admission() {
+        let p = prop(&source);
+        if scalar {
+            assert_eq!(
+                sole_outcome(&p),
+                PropagateOutcome::Unsatisfiable,
+                "{source}: {p:?}"
+            );
+        } else {
+            assert!(
+                matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)),
+                "{source}: {p:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn scalar_admission_respects_body_and_named_multiplicity() {
+    for (model, scalar) in collection_identity::body_scalar_admission() {
+        let p = propagate_constraints(&model, &PropagateConfig::default());
+        if scalar {
+            assert_eq!(sole_outcome(&p), PropagateOutcome::Unsatisfiable, "{p:?}");
+        } else {
+            assert!(
+                matches!(sole_outcome(&p), PropagateOutcome::Unsupported(_)),
+                "{p:?}"
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/propagation_approximation.rs b/crates/sysmlv2-solve/tests/propagation_approximation.rs
new file mode 100644
index 0000000..7955fac
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/propagation_approximation.rs
@@ -0,0 +1,339 @@
+//! Approximate definitions cannot become definitive satisfaction through contraction.
+use std::sync::Arc;
+use sysmlv2_model::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, verify_constraints_with, z3_version,
+};
+fn models(source: &str) -> Vec<Model> {
+    let lib = "package ScalarValues { datatype Integer; datatype Natural specializes Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                m.add_source(
+                    format!("{pkg}.sysml"),
+                    &format!("package {pkg} {{ attribute x[1]:ScalarValues::Integer; {source} }}"),
+                );
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+
+fn is_open(outcome: &Option<PropagateOutcome>) -> bool {
+    matches!(
+        outcome,
+        Some(PropagateOutcome::Undecided | PropagateOutcome::Unsupported(_))
+    )
+}
+fn source(constraints: &str) -> String {
+    format!("attribute y[1]:ScalarValues::Integer=(x,0)#(1); {constraints}")
+}
+fn assert_no_hydration(mode: usize, model: &Model, loaded: usize) {
+    assert_eq!(model.loaded_library_unit_count(), loaded);
+    if mode == 3 {
+        assert_eq!(loaded, 0);
+    }
+}
+fn assert_approximation_stays_open(constraints: &str, expected_ranges: &[(&str, &str)]) {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for (mode, model) in models(&source(constraints)).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let propagation = propagate_constraints_with(&mut r, &model, &Default::default());
+            assert_eq!(propagation.constraints.len(), 2);
+            assert!(
+                propagation
+                    .constraints
+                    .iter()
+                    .all(|c| is_open(&c.propagate)),
+                "mode={mode}: {propagation:?}"
+            );
+            for &(feature, expected) in expected_ranges {
+                let ranges: Vec<_> = propagation
+                    .ranges
+                    .iter()
+                    .filter(|r| r.feature == feature)
+                    .collect();
+                assert_eq!(ranges.len(), 2);
+                assert!(
+                    ranges.iter().all(|r| r.range == expected),
+                    "{propagation:?}"
+                );
+            }
+            let report = verify_constraints_with(
+                &mut r,
+                &model,
+                native.then_some(&cfg),
+                &Default::default(),
+            )
+            .unwrap();
+            assert_eq!(report.constraints.len(), 2);
+            for c in report.constraints {
+                assert!(is_open(&c.propagate), "mode={mode}: {c:?}");
+                if native {
+                    assert!(
+                        matches!(c.solve, Some(SolveOutcome::Unknown(_))),
+                        "verification must reach native fallback: {c:?}"
+                    );
+                } else {
+                    assert_eq!(c.solve, None);
+                }
+            }
+            if native {
+                for c in solve_constraints_with(&mut r, &model, &cfg).unwrap() {
+                    assert!(
+                        matches!(c.solve, Some(SolveOutcome::Unknown(_))),
+                        "mode={mode}: {c:?}"
+                    );
+                }
+            }
+        }
+        assert_no_hydration(mode, &model, loaded);
+    }
+}
+
+#[test]
+fn approximate_definition_cannot_prove_its_own_asserted_value() {
+    assert_approximation_stays_open("assert constraint c {y==1}", &[("y", "[1, 1]")]);
+}
+
+#[test]
+fn dropped_scalar_index_identity_cannot_manufacture_a_satisfied_constraint() {
+    // The unsupported symbolic index means y=x. This assertion has no model
+    // witness, even though independently invented x/y variables satisfy it.
+    assert_approximation_stays_open(
+        "assert constraint c {y==1 & x==0}",
+        &[("y", "[1, 1]"), ("x", "[0, 0]")],
+    );
+}
+
+#[test]
+fn approximate_facts_cannot_settle_an_exact_shared_variable_sibling() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for reverse in [false, true] {
+        let approximate = "assert constraint approximation {y==1 & x==0}";
+        let exact = "assert constraint sibling {x==0}";
+        let constraints = if reverse {
+            format!("{exact} {approximate}")
+        } else {
+            format!("{approximate} {exact}")
+        };
+        for (mode, model) in models(&source(&constraints)).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                let p = propagate_constraints_with(&mut r, &model, &Default::default());
+                assert_eq!(p.constraints.len(), 4);
+                assert!(
+                    p.constraints.iter().all(|c| is_open(&c.propagate)),
+                    "mode={mode} reverse={reverse}: {p:?}"
+                );
+                let report = verify_constraints_with(
+                    &mut r,
+                    &model,
+                    native.then_some(&cfg),
+                    &Default::default(),
+                )
+                .unwrap();
+                for c in report.constraints {
+                    assert!(is_open(&c.propagate), "{c:?}");
+                    if native {
+                        if c.name.as_deref() == Some("sibling") {
+                            assert!(
+                                matches!(c.solve, Some(SolveOutcome::Satisfiable(_))),
+                                "{c:?}"
+                            );
+                        } else {
+                            assert!(matches!(c.solve, Some(SolveOutcome::Unknown(_))), "{c:?}");
+                        }
+                    }
+                }
+            }
+            assert_no_hydration(mode, &model, loaded);
+        }
+    }
+}
+
+#[test]
+fn contradictory_approximate_bounds_still_prove_unsatisfiability() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for (mode, model) in models(&source("assert constraint c {y==1 & y==2}"))
+        .into_iter()
+        .enumerate()
+    {
+        let loaded = model.loaded_library_unit_count();
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let p = propagate_constraints_with(&mut r, &model, &Default::default());
+            assert_eq!(p.constraints.len(), 2);
+            assert!(
+                p.constraints
+                    .iter()
+                    .all(|c| c.propagate == Some(PropagateOutcome::Unsatisfiable)),
+                "{p:?}"
+            );
+            let report = verify_constraints_with(
+                &mut r,
+                &model,
+                native.then_some(&cfg),
+                &Default::default(),
+            )
+            .unwrap();
+            for c in report.constraints {
+                assert_eq!(c.propagate, Some(PropagateOutcome::Unsatisfiable));
+                assert_eq!(
+                    c.solve, None,
+                    "sound refutation should avoid an unnecessary native call"
+                );
+            }
+            if native {
+                for c in solve_constraints_with(&mut r, &model, &cfg).unwrap() {
+                    assert_eq!(c.solve, Some(SolveOutcome::Unsatisfiable));
+                }
+            }
+        }
+        assert_no_hydration(mode, &model, loaded);
+    }
+}
+
+#[test]
+fn native_universal_proof_remains_valid_for_approximate_definitions() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for (mode, model) in models(&source("assert constraint c {y==y}"))
+        .into_iter()
+        .enumerate()
+    {
+        let loaded = model.loaded_library_unit_count();
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let report = verify_constraints_with(
+                &mut r,
+                &model,
+                native.then_some(&cfg),
+                &Default::default(),
+            )
+            .unwrap();
+            for c in report.constraints {
+                if native && c.propagate != Some(PropagateOutcome::Satisfied) {
+                    assert_eq!(c.solve, Some(SolveOutcome::Valid), "{c:?}");
+                }
+            }
+            if native {
+                for c in solve_constraints_with(&mut r, &model, &cfg).unwrap() {
+                    assert_eq!(c.solve, Some(SolveOutcome::Valid));
+                }
+            }
+        }
+        assert_no_hydration(mode, &model, loaded);
+    }
+}
+
+#[test]
+fn declaration_only_proofs_survive_unrelated_approximations() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    let constraints = "attribute n[1]:ScalarValues::Natural; assert constraint approximation {y==1} assert constraint baseline {n>=0}";
+    for (mode, model) in models(&source(constraints)).into_iter().enumerate() {
+        let loaded = model.loaded_library_unit_count();
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            let report = verify_constraints_with(
+                &mut r,
+                &model,
+                native.then_some(&cfg),
+                &Default::default(),
+            )
+            .unwrap();
+            assert_eq!(report.constraints.len(), 4);
+            for c in report.constraints {
+                if c.name.as_deref() == Some("baseline") {
+                    assert_eq!(c.propagate, Some(PropagateOutcome::Satisfied), "{c:?}");
+                    assert_eq!(c.solve, None);
+                } else {
+                    assert!(is_open(&c.propagate), "{c:?}");
+                    if native {
+                        assert!(matches!(c.solve, Some(SolveOutcome::Unknown(_))), "{c:?}");
+                    }
+                }
+            }
+        }
+        assert_no_hydration(mode, &model, loaded);
+    }
+}
+
+#[test]
+fn negated_assertion_cannot_certify_an_approximated_value() {
+    assert_approximation_stays_open("assert not constraint c {y!=1}", &[("y", "[1, 1]")]);
+}
+
+#[test]
+fn partial_conjunctions_with_approximate_terms_can_refute_but_not_prove() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for contradiction in [false, true] {
+        let expression = if contradiction {
+            "y==1 & y==2 & Missing()"
+        } else {
+            "y==1 & Missing()"
+        };
+        let declaration = source(&format!("assert constraint c {{{expression}}}"));
+        for (mode, model) in models(&declaration).into_iter().enumerate() {
+            let loaded = model.loaded_library_unit_count();
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                let report = verify_constraints_with(
+                    &mut r,
+                    &model,
+                    native.then_some(&cfg),
+                    &Default::default(),
+                )
+                .unwrap();
+                assert_eq!(report.constraints.len(), 2);
+                for c in report.constraints {
+                    if contradiction {
+                        assert_eq!(c.propagate, Some(PropagateOutcome::Unsatisfiable), "{c:?}");
+                        assert_eq!(c.solve, None);
+                    } else {
+                        assert!(
+                            matches!(c.propagate, Some(PropagateOutcome::Unsupported(_))),
+                            "{c:?}"
+                        );
+                        if native {
+                            assert!(matches!(c.solve, Some(SolveOutcome::Unknown(_))), "{c:?}");
+                        }
+                    }
+                }
+            }
+            assert_no_hydration(mode, &model, loaded);
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/runtime_frame_visibility.rs b/crates/sysmlv2-solve/tests/runtime_frame_visibility.rs
new file mode 100644
index 0000000..13c0863
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/runtime_frame_visibility.rs
@@ -0,0 +1,470 @@
+//! Runtime frame visibility cannot reactivate through a declaration read.
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_model::{
+    check::ConstraintVerdict, json::ResolvedModel, libcache::LibraryCache, model::Model,
+    prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, z3_version,
+};
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+fn native_solve(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &SolverConfig,
+) -> Vec<sysmlv2_solve::SolvedConstraint> {
+    if z3_version(cfg).is_err() {
+        return Vec::new();
+    }
+    solve_constraints_with(r, model, cfg).unwrap()
+}
+fn models(source: &str) -> Vec<Model> {
+    let lib = "package ScalarValues { datatype Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                m.add_source(
+                    format!("{pkg}.sysml"),
+                    &format!("package {pkg} {{ attribute x[1]:ScalarValues::Integer; {source} }}"),
+                );
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+
+fn assert_solver_truth(r: &mut ResolvedModel, model: &Model, satisfiable: bool, label: &str) {
+    let propagated = propagate_constraints_with(r, model, &Default::default());
+    assert_eq!(propagated.constraints.len(), 2, "{label}");
+    for c in propagated.constraints {
+        if satisfiable {
+            assert_eq!(
+                c.propagate,
+                Some(PropagateOutcome::Satisfied),
+                "{label}: {c:?}"
+            );
+        } else {
+            assert!(
+                matches!(
+                    c.propagate,
+                    Some(PropagateOutcome::Unsatisfiable | PropagateOutcome::Violated)
+                ),
+                "{label}: {c:?}"
+            );
+        }
+    }
+    for c in native_solve(r, model, &Default::default()) {
+        if satisfiable {
+            assert!(
+                matches!(
+                    c.solve,
+                    Some(SolveOutcome::Satisfiable(_) | SolveOutcome::Valid)
+                ) || c.verdict == ConstraintVerdict::Satisfied,
+                "{label}: {c:?}"
+            );
+        } else {
+            assert!(
+                c.solve == Some(SolveOutcome::Unsatisfiable)
+                    || c.verdict == ConstraintVerdict::Violated,
+                "{label}: {c:?}"
+            );
+        }
+    }
+}
+
+fn check_transitive_case(label: &str, declarations: &str, expected: i128, wrong: i128) {
+    for asserted in [expected, wrong] {
+        let source = format!(
+            "{declarations} attribute direct=Base(7); assert constraint c {{Base(x)=={asserted} & x==7}}"
+        );
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                for pkg in ["B", "A"] {
+                    let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                    assert_eq!(
+                        r.evaluate(value),
+                        Ok(sysmlv2_model::eval::Value::Integer(expected)),
+                        "{label} mode={mode} {pkg}"
+                    );
+                }
+                assert_solver_truth(
+                    &mut r,
+                    &model,
+                    asserted == expected,
+                    &format!("{label} mode={mode}"),
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn transitive_unrelated_calculation() {
+    check_transitive_case(
+        "unrelated calculation",
+        "calc def G { Base::p } calc def Base { in q default 1; attribute p=q; G() }",
+        1,
+        7,
+    );
+}
+
+#[test]
+fn transitive_package_bridge() {
+    check_transitive_case(
+        "package bridge",
+        "package P { attribute bridge=Base::p; } calc def Base { in q default 1; attribute p=q; P::bridge }",
+        1,
+        7,
+    );
+}
+
+#[test]
+fn transitive_two_unrelated_calculations() {
+    check_transitive_case(
+        "two unrelated calculations",
+        "calc def H { Base::p } calc def G { H() } calc def Base { in q default 1; attribute p=q; G() }",
+        1,
+        7,
+    );
+}
+
+#[test]
+fn transitive_restore_after_calculation() {
+    check_transitive_case(
+        "restore after calculation",
+        "calc def G { Base::p } calc def Base { in q default 1; attribute p=q; G()+p }",
+        8,
+        14,
+    );
+}
+
+#[test]
+fn transitive_restore_after_package() {
+    check_transitive_case(
+        "restore after package",
+        "package P { attribute bridge=Base::p; } calc def Base { in q default 1; attribute p=q; P::bridge+p }",
+        8,
+        14,
+    );
+}
+
+#[test]
+fn transitive_nested_lexical_capture() {
+    check_transitive_case(
+        "nested lexical capture",
+        "calc def Base { in q default 1; attribute p=q; calc def G { Base::p } G() }",
+        7,
+        1,
+    );
+}
+
+#[test]
+fn transitive_forward_actual_before_masking() {
+    check_transitive_case(
+        "forward actual before masking",
+        "calc def G { in explicitArg; explicitArg } calc def Base { in q default 1; attribute p=q; G(p) }",
+        7,
+        1,
+    );
+}
+
+#[test]
+fn transitive_forward_actual_plus_hidden_read() {
+    check_transitive_case(
+        "forward actual plus hidden read",
+        "calc def G { in explicitArg; explicitArg+Base::p } calc def Base { in q default 1; attribute p=q; G(p) }",
+        8,
+        14,
+    );
+}
+
+#[test]
+fn a_fresh_recursive_activation_gets_its_own_visible_arguments() {
+    // The evaluator supports bounded recursive execution. Symbolic recursion
+    // remains outside the solver fragment, so this is an evaluator control.
+    let source = "calc def G { Base(3) } calc def Base { in q default 1; attribute p=q; if q==7 ? G()+p else p } attribute direct=Base(7);";
+    for (mode, model) in models(source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            for pkg in ["B", "A"] {
+                let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                assert_eq!(
+                    r.evaluate(value),
+                    Ok(sysmlv2_model::eval::Value::Integer(10)),
+                    "mode={mode} {pkg}"
+                );
+            }
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn lowered_lambda_default_reads_cannot_reactivate_hidden_parameter_bindings() {
+    let source = format!(
+        "calc def G {{ '{ID}' }} attribute direct=(7,9)->reduce {{ in q default 1; in p default q; G() }};"
+    );
+    for (mode, model) in models(&source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        // Bind the reference by exact identity rather than an invented name for
+        // the anonymous expression. Both source sites intentionally target A.
+        let direct = r.resolve_qualified("A::direct").unwrap();
+        let candidates: Vec<_> = r
+            .elements()
+            .filter(|&element| {
+                r.element_properties(element)
+                    .get("declaredName")
+                    .and_then(|v| v.as_str())
+                    == Some("p")
+            })
+            .collect();
+        let parameter = candidates
+            .into_iter()
+            .find(|&element| {
+                let mut owner = r.owner(element);
+                while let Some(at) = owner {
+                    if at == direct {
+                        return true;
+                    }
+                    owner = r.owner(at);
+                }
+                false
+            })
+            .unwrap();
+        r.override_ids(&HashMap::from([(
+            r.element_id(parameter),
+            ID.parse().unwrap(),
+        )]));
+        assert!(
+            r.bind_id_spelled_references()
+                .contains(&ID.parse().unwrap())
+        );
+        for _ in 0..2 {
+            for pkg in ["B", "A"] {
+                let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                assert_eq!(
+                    r.evaluate(value),
+                    Ok(sysmlv2_model::eval::Value::Integer(1)),
+                    "mode={mode} {pkg}"
+                );
+            }
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn query_lambda_bindings_restore_and_do_not_enter_unrelated_model_formulas() {
+    use sysmlv2_syntax::parser::parse_expression;
+    let source = "calc def Base {in q default 1; attribute p=q; p} calc def G {Base::p}";
+    for (mode, model) in models(source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            for (expression, expected) in [
+                ("(7,9)->reduce { in q; in p; A::G() }", 1),
+                ("(7,9)->reduce { in q; in p; A::G()+q+p }", 17),
+                ("(7,9)->reduce { in q; in p; A::Base(q)+p }", 16),
+                (
+                    "(7,9)->reduce { in q; in p; (1,2)->reduce { in a; in b; q+p+a+b } }",
+                    19,
+                ),
+            ] {
+                let parsed = parse_expression(expression);
+                assert!(
+                    parsed.diagnostics.is_empty(),
+                    "{expression}: {:?}",
+                    parsed.diagnostics
+                );
+                let root = r.root_scope();
+                assert_eq!(
+                    r.query(root, &parsed.expr.unwrap()),
+                    Ok(sysmlv2_model::eval::Value::Integer(expected)),
+                    "mode={mode} {expression}"
+                );
+            }
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn lowered_quantifiers_preserve_lexical_capture_without_reactivating_hidden_frames() {
+    for body in [
+        "(1,2)->forAll {in memberValue; G()==1}",
+        "(1,2)->forAll {in memberValue; G()==1 & q==7 & memberValue>0}",
+    ] {
+        for asserted in [true, false] {
+            let source = format!(
+                "calc def G {{Base::p}} calc def Base {{in q default 1; attribute p=q; {body}}} attribute direct=Base(7); assert constraint c {{Base(x)=={asserted} & x==7}}"
+            );
+            for (mode, model) in models(&source).into_iter().enumerate() {
+                let mut r = ResolvedModel::build(&model);
+                for _ in 0..2 {
+                    for pkg in ["B", "A"] {
+                        let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                        assert_eq!(
+                            r.evaluate(value),
+                            Ok(sysmlv2_model::eval::Value::Boolean(true)),
+                            "mode={mode} body={body} {pkg}"
+                        );
+                    }
+                    assert_solver_truth(
+                        &mut r,
+                        &model,
+                        asserted,
+                        &format!("mode={mode} body={body}"),
+                    );
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn inherited_signature_actual_stays_visible_in_the_specializing_calculation() {
+    check_transitive_case(
+        "inherited signature actual",
+        "calc def Ancestor {in q default 1; attribute p=q;} calc def Base :> Ancestor {p}",
+        7,
+        1,
+    );
+}
+
+#[test]
+fn inherited_signature_actual_stays_hidden_after_an_unrelated_bridge() {
+    check_transitive_case(
+        "inherited signature bridge and restore",
+        "calc def Ancestor {in q default 1; attribute p=q;} calc def G {Ancestor::p} calc def Base :> Ancestor {G()+p}",
+        8,
+        14,
+    );
+}
+
+#[test]
+fn inherited_omitted_parameter_default_retains_the_active_signature_context() {
+    for body in ["Base::p", "sum(Base::p)"] {
+        for asserted in [7, 2] {
+            let source = format!(
+                "calc def Base {{in p default 1;}}
+                 calc def Child :>Base {{in q :>>Base::p default r; in r default 1;}}
+                 calc def Grand :>Child {{{body}}}
+                 attribute direct=Grand(r=7);
+                 assert constraint c {{Grand(r=x)=={asserted} & x==7}}"
+            );
+            for (mode, model) in models(&source).into_iter().enumerate() {
+                let mut r = ResolvedModel::build(&model);
+                for _ in 0..2 {
+                    for pkg in ["B", "A"] {
+                        let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                        assert_eq!(
+                            r.evaluate(value),
+                            Ok(sysmlv2_model::eval::Value::Integer(7)),
+                            "mode={mode} body={body} {pkg}"
+                        );
+                    }
+                    assert_solver_truth(
+                        &mut r,
+                        &model,
+                        asserted == 7,
+                        &format!("inherited omitted default mode={mode} body={body}"),
+                    );
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn swallowed_inherited_default_error_restores_the_callers_visible_arguments() {
+    // Inherited defaults retain the established best-effort fallback. The
+    // unrelated declaration and failed nested call must restore visibility
+    // before the caller evaluates its next operand.
+    let source = "part def General {attribute bad[0] default G();}
+        part child[1]:General {attribute :>>bad;}
+        calc def G {1/0}
+        calc def Base {in q default 1; attribute p=q; size(child.bad)+p}
+        attribute direct=Base(7);";
+    for (mode, model) in models(source).into_iter().enumerate() {
+        let mut r = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            for pkg in ["B", "A"] {
+                let value = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                assert_eq!(
+                    r.evaluate(value),
+                    Ok(sysmlv2_model::eval::Value::Integer(7)),
+                    "mode={mode} {pkg}"
+                );
+            }
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn empty_argument_environment_does_not_erase_active_default_selection() {
+    // No explicit actuals means the translator's argument environment is
+    // empty, but its activation still selects Child::q for Base::p. The free
+    // x prevents folding the entire calculation before symbolic translation.
+    for asserted in [3, 2] {
+        let source = format!(
+            "calc def Base {{in p default 1;}}
+             calc def Child :>Base {{in q :>>Base::p default 2;}}
+             calc def Grand :>Child {{Base::p+x}}
+             assert constraint c {{Grand()=={asserted} & x==1}}"
+        );
+        for (mode, model) in models(&source).into_iter().enumerate() {
+            let mut r = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                assert_solver_truth(
+                    &mut r,
+                    &model,
+                    asserted == 3,
+                    &format!("empty argument environment mode={mode} asserted={asserted}"),
+                );
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/solve.rs b/crates/sysmlv2-solve/tests/solve.rs
index 80db6bc..f7c0f8d 100644
--- a/crates/sysmlv2-solve/tests/solve.rs
+++ b/crates/sysmlv2-solve/tests/solve.rs
@@ -44,7 +44,7 @@ fn integer_witness() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x > 3 & x < 5 }
         }",
     ) else {
@@ -61,7 +61,7 @@ fn integer_unsatisfiable() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x > 5 & x < 4 }
         }",
     ) else {
@@ -77,7 +77,7 @@ fn parity_scaling_unsatisfiable_over_integers() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x * 2 == 5 }
         }",
     ) else {
@@ -92,7 +92,7 @@ fn real_witness_by_default_sort() {
     // still satisfiable.
     let Some(out) = outcome(
         "package P {
-            attribute x;
+            attribute x[1];
             assert constraint c { x > 3 & x < 4 }
         }",
     ) else {
@@ -116,7 +116,7 @@ fn boolean_tautology_is_valid() {
     let Some(out) = outcome(
         "package P {
             attribute def Boolean;
-            attribute b : Boolean;
+            attribute b[1] : Boolean;
             assert constraint c { b or not b }
         }",
     ) else {
@@ -130,7 +130,7 @@ fn negated_assert_flips_the_goal() {
     // `assert not` of a contradiction holds for every x.
     let Some(out) = outcome(
         "package P {
-            attribute x;
+            attribute x[1];
             assert not constraint c { x != x }
         }",
     ) else {
@@ -144,7 +144,7 @@ fn enum_witness_and_unsat() {
     let Some(solved) = solve(
         "package P {
             enum def Phase { halt; mid; init; }
-            attribute c : Phase;
+            attribute c[1] : Phase;
             assert constraint pick { c != Phase::halt & c != Phase::mid }
             assert constraint clash { c == Phase::halt & c == Phase::mid }
         }",
@@ -173,7 +173,7 @@ fn variant_values_solve_as_finite_sorts() {
                 variant part engine4Cyl;
                 variant part engine6Cyl;
             }
-            part engine : Engine;
+            part engine[1] : Engine;
             assert constraint pick { engine != Engine::engine4Cyl }
             assert constraint clash {
                 engine == Engine::engine4Cyl & engine == Engine::engine6Cyl
@@ -202,7 +202,7 @@ fn calculation_bodies_inline() {
         "package P {
             attribute def Integer;
             calc def Double { in x; x * 2 }
-            attribute y : Integer;
+            attribute y[1] : Integer;
             assert constraint c { Double(y) == 14 }
             assert constraint t { Double(y) == y * 2 }
         }",
@@ -219,6 +219,32 @@ fn calculation_bodies_inline() {
     assert_eq!(outs[1], SolveOutcome::Valid);
 }
 
+/// A calculation that declares no result inlines the nearest one its
+/// heritage declares, its own parameters standing for those they redefine.
+#[test]
+fn inherited_calculation_bodies_inline() {
+    let Some(solved) = solve(
+        "package P {
+            attribute def Integer;
+            calc def Diff { in a; in b; return r = a - b; }
+            calc def D3 :> Diff { in x; }
+            attribute y[1] : Integer;
+            assert constraint c { D3(y, 3) == 4 }
+        }",
+    ) else {
+        return;
+    };
+    let outs: Vec<_> = solved.iter().filter_map(|s| s.solve.clone()).collect();
+    assert_eq!(
+        outs,
+        [SolveOutcome::Satisfiable(vec![(
+            "y".to_string(),
+            WitnessValue::Int(7)
+        )])],
+        "{solved:?}"
+    );
+}
+
 /// Same-dimension quantities in different units convert through their
 /// measurement references: `x <= 2 [min]` and `x >= 90 [s]` constrain
 /// one variable, and the witness stays in the first unit seen.
@@ -227,14 +253,14 @@ fn units_convert_across_scales() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute s; attribute m;
+            attribute s[1]; attribute m[1];
             attribute min {
                 attribute unitConversion {
                     attribute referenceUnit = s;
                     attribute conversionFactor = 60;
                 }
             }
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x * 1 [min] <= 2 [min] & x * 1 [min] >= 90 [s] }
         }",
     ) else {
@@ -254,7 +280,7 @@ fn null_coalescing_translates() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { (x ?? 99) == 7 }
         }",
     ) else {
@@ -268,7 +294,7 @@ fn null_coalescing_translates() {
         "package P {
             attribute def Integer;
             attribute a = null;
-            attribute y : Integer;
+            attribute y[1] : Integer;
             assert constraint c { (a ?? y) == 3 }
         }",
     ) else {
@@ -287,8 +313,8 @@ fn chained_definitions_inline() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
-            attribute y : Integer = x * x;
+            attribute x[1] : Integer;
+            attribute y[1] : Integer = x * x;
             assert constraint c { y == 49 & x < 0 }
         }",
     ) else {
@@ -308,7 +334,7 @@ fn natural_lower_bound_side_constraint() {
     let Some(out) = outcome(
         "package P {
             attribute def Natural;
-            attribute n : Natural;
+            attribute n[1] : Natural;
             assert constraint c { n < 0 }
         }",
     ) else {
@@ -322,7 +348,7 @@ fn int_real_mixing_coerces() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x + 0.5 > 2.4 & x < 3 }
         }",
     ) else {
@@ -340,9 +366,9 @@ fn independent_units_solve_with_tagged_witnesses() {
     // variable lives in one unit — witnesses carry the inferred unit.
     let Some(out) = outcome(
         "package P {
-            attribute d; attribute kB;
-            attribute duration;
-            attribute volume;
+            attribute d[1]; attribute kB[1];
+            attribute duration[1];
+            attribute volume[1];
             assert constraint c { duration >= 30 [d] & volume >= 100 [kB] }
         }",
     ) else {
@@ -363,8 +389,8 @@ fn one_variable_in_two_unrelated_units_is_unknown() {
     // `variable_converts_across_same_dimension_units`.)
     let Some(out) = outcome(
         "package P {
-            attribute h; attribute min;
-            attribute duration;
+            attribute h[1]; attribute min[1];
+            attribute duration[1];
             assert constraint c { duration <= 2 [h] & duration >= 30 [min] }
         }",
     ) else {
@@ -385,7 +411,7 @@ fn one_variable_in_two_unrelated_units_is_unknown() {
 fn variable_converts_across_same_dimension_units() {
     let Some(out) = outcome(
         "package P {
-            attribute s;
+            attribute s[1];
             attribute beat {
                 attribute unitConversion {
                     attribute referenceUnit = s;
@@ -398,7 +424,7 @@ fn variable_converts_across_same_dimension_units() {
                     attribute conversionFactor = 16;
                 }
             }
-            attribute x; attribute y;
+            attribute x[1]; attribute y[1];
             assert constraint c { x >= 8 [beat] & x + y == 5 [bar] & y == 0 [bar] }
         }",
     ) else {
@@ -427,8 +453,8 @@ fn unit_propagates_through_addition_and_linked_vars() {
     // `c >= 30 [min]` must then conflict.
     let Some(out) = outcome(
         "package P {
-            attribute h; attribute min;
-            attribute a; attribute b; attribute c;
+            attribute h[1]; attribute min[1];
+            attribute a[1]; attribute b[1]; attribute c[1];
             assert constraint k { a + b <= 5 [h] & b == c & c >= 1 [min] }
         }",
     ) else {
@@ -444,8 +470,8 @@ fn unit_propagates_through_addition_and_linked_vars() {
 fn scalar_scaling_keeps_the_unit() {
     let Some(out) = outcome(
         "package P {
-            attribute mm;
-            attribute width;
+            attribute mm[1];
+            attribute width[1];
             assert constraint c { 2 * width <= 10 [mm] & width >= 4 [mm] }
         }",
     ) else {
@@ -474,7 +500,7 @@ fn unsupported_construct_is_unknown() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { (1..x)->size() == 2 }
         }",
     ) else {
@@ -547,7 +573,7 @@ fn modulo_truncated_semantics() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x > -10 & x < 0 & x % 3 == -1 }
         }",
     ) else {
@@ -573,7 +599,7 @@ fn modulo_unsatisfiable_range() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x == -1 & x % 3 == 2 }
         }",
     ) else {
@@ -590,7 +616,7 @@ fn string_equality_witness() {
     let Some(out) = outcome(
         "package P {
             attribute def String;
-            attribute s : String;
+            attribute s[1] : String;
             assert constraint c { s == \"on\" }
         }",
     ) else {
@@ -612,7 +638,7 @@ fn string_disequality_unsatisfiable() {
     let Some(out) = outcome(
         "package P {
             attribute def String;
-            attribute s : String;
+            attribute s[1] : String;
             assert constraint c { s == \"on\" & s != \"on\" }
         }",
     ) else {
@@ -634,14 +660,14 @@ fn bracket_over_unbound_magnitude() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute s;
+            attribute s[1];
             attribute min {
                 attribute unitConversion {
                     attribute referenceUnit = s;
                     attribute conversionFactor = 60;
                 }
             }
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x [min] <= 2 [min] & x [min] >= 90 [s] }
         }",
     ) else {
@@ -660,8 +686,8 @@ fn bracket_over_compound_magnitude() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute s;
-            attribute x : Integer;
+            attribute s[1];
+            attribute x[1] : Integer;
             assert constraint c { (x + 1) [s] == 3 [s] }
         }",
     ) else {
@@ -680,8 +706,8 @@ fn bracket_units_mismatch_is_unknown() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute kg; attribute s;
-            attribute x : Integer;
+            attribute kg[1]; attribute s[1];
+            attribute x[1] : Integer;
             assert constraint c { x [kg] > 2 [s] }
         }",
     ) else {
@@ -703,14 +729,14 @@ fn bracket_dimensionless_scale_folds() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute m;
+            attribute m[1];
             attribute km {
                 attribute unitConversion {
                     attribute referenceUnit = m;
                     attribute conversionFactor = 1000;
                 }
             }
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x [km/m] == 5000 & x > 0 }
         }",
     ) else {
@@ -731,9 +757,9 @@ fn sum_over_bound_sequence() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute total : Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute total[1] : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             attribute ps : Integer[0..*] = (a, b);
             assert constraint c { total == sum(ps) & a == 2 & b == 3 }
         }",
@@ -756,10 +782,10 @@ fn size_flattens_nested_sequences() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute n : Integer;
-            attribute a : Integer;
-            attribute b : Integer;
-            attribute c : Integer;
+            attribute n[1] : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
+            attribute c[1] : Integer;
             attribute ps : Integer[0..*] = (a, (b, c));
             assert constraint k { n == size(ps) & notEmpty(ps) }
         }",
@@ -779,10 +805,10 @@ fn max_min_fold_to_ite_chains() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute hi : Integer;
-            attribute lo : Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute hi[1] : Integer;
+            attribute lo[1] : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             assert constraint c {
                 hi == max((a, b)) & lo == min(a, b) & a == 2 & b == 7
             }
@@ -815,12 +841,12 @@ fn product_abs_head_last_fold() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute p : Integer;
-            attribute y : Integer;
-            attribute h : Integer;
-            attribute l : Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute p[1] : Integer;
+            attribute y[1] : Integer;
+            attribute h[1] : Integer;
+            attribute l[1] : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             assert constraint c {
                 p == product((a, b)) & y == abs(0 - a) &
                 h == head((a, b)) & l == last((a, b)) &
@@ -858,14 +884,14 @@ fn sum_converts_units_across_scales() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute s; attribute m;
+            attribute s[1]; attribute m[1];
             attribute min {
                 attribute unitConversion {
                     attribute referenceUnit = s;
                     attribute conversionFactor = 60;
                 }
             }
-            attribute x : Integer;
+            attribute x[1] : Integer;
             assert constraint c { x [s] == sum((1 [min], 30 [s])) }
         }",
     ) else {
@@ -884,7 +910,7 @@ fn sum_over_valueless_collection_bails_with_arity_reason() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute total : Integer;
+            attribute total[1] : Integer;
             attribute ps : Integer[0..*];
             assert constraint c { total == sum(ps) }
         }",
@@ -907,8 +933,8 @@ fn forall_over_bound_sequence_conjunction() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             attribute ps : Integer[0..*] = (a, b);
             assert constraint c { ps->forAll {in v; v > 0} & b == 0 - 3 }
         }",
@@ -925,8 +951,8 @@ fn exists_over_bound_sequence_disjunction() {
     let Some(out) = outcome(
         "package P {
             attribute def Integer;
-            attribute a : Integer;
-            attribute b : Integer;
+            attribute a[1] : Integer;
+            attribute b[1] : Integer;
             assert constraint c {
                 (a, b)->exists {in v; v == 7} & a == 1 & b == 2
             }
@@ -945,8 +971,8 @@ fn forall_skolemizes_bounded_multiplicity() {
         "package P {
             attribute def Real;
             part def W {
-                attribute r : Real;
-                attribute d : Real;
+                attribute r[1] : Real;
+                attribute d[1] : Real;
             }
             part ws : W[4];
             assert constraint c { ws->forAll {in w; 2 * w.r < w.d} }
@@ -971,7 +997,7 @@ fn quantifiers_share_skolem_instances() {
         "package P {
             attribute def Real;
             part def W {
-                attribute r : Real;
+                attribute r[1] : Real;
             }
             part ws : W[2];
             assert constraint c {
@@ -991,7 +1017,7 @@ fn skolemization_respects_the_cap() {
         "package P {
             attribute def Real;
             part def W {
-                attribute r : Real;
+                attribute r[1] : Real;
             }
             part ws : W[64];
             assert constraint c { ws->forAll {in w; w.r > 0} }
@@ -1004,3 +1030,122 @@ fn skolemization_respects_the_cap() {
     };
     assert!(reason.contains("expansion cap"), "{reason}");
 }
+
+#[test]
+fn collection_cardinality_is_not_recovered_from_scalar_approximations() {
+    for expression in [
+        "sum(rack.motors.mass) < 1",
+        "total < 1",
+        "size(if choose ? xs else xs) == 1",
+        "size(if choose ? copied else copied) == 1",
+        "Count(if choose ? copied else copied) == 1",
+    ] {
+        let Some(out) = outcome(&format!(
+            "package P {{
+            attribute def Real; attribute def Integer; attribute def Boolean;
+            part def Motor {{ attribute mass[1] : Real = 0.55; }}
+            part def Rack {{ part motors : Motor[4]; }}
+            part rack : Rack {{ part :>> motors; }}
+            attribute total[1] : Real = sum(rack.motors.mass);
+            attribute xs : Integer[4]; attribute choose[1] : Boolean;
+            attribute copied[1] : Integer = xs;
+            calc def Count {{ in things; return n = size(things); }}
+            assert constraint c {{ {expression} }}
+        }}"
+        )) else {
+            return;
+        };
+        assert!(
+            matches!(out, SolveOutcome::Unknown(_)),
+            "{expression}: {out:?}"
+        );
+    }
+}
+
+#[test]
+fn quantified_nested_collections_do_not_prove_singleton_size() {
+    for expression in [
+        "size(x.motors.mass) == 1",
+        "size(x.values) == 1",
+        "sum(x.motors.mass) < 1",
+    ] {
+        let Some(out) = outcome(&format!(
+            "package P {{
+            attribute def Integer; attribute def Real;
+            part def Motor {{ attribute mass[1] : Real = 0.55; }}
+            part def Item {{ part motors : Motor[4]; attribute values : Integer[4]; }}
+            part items : Item[2];
+            assert constraint c {{ items->forAll {{ in x; {expression} }} }}
+        }}"
+        )) else {
+            return;
+        };
+        assert!(
+            matches!(out, SolveOutcome::Unknown(_)),
+            "{expression}: {out:?}"
+        );
+    }
+}
+
+#[path = "common/collection_identity.rs"]
+mod collection_identity;
+
+#[test]
+fn contextual_member_formulas_do_not_capture_quantifier_bindings() {
+    for source in collection_identity::contextual_formulas() {
+        let Some(out) = outcome(&source) else { return };
+        assert!(matches!(out, SolveOutcome::Unknown(_)), "{source}: {out:?}");
+    }
+    for size in [1, 2] {
+        let Some(out) = outcome(&collection_identity::closed_member_formula(size)) else {
+            return;
+        };
+        assert!(matches!(out, SolveOutcome::Satisfiable(_)), "{out:?}");
+    }
+}
+
+#[test]
+fn quantified_members_preserve_reference_identity() {
+    for source in collection_identity::contradictions() {
+        let Some(out) = outcome(&source) else { return };
+        assert_eq!(out, SolveOutcome::Unsatisfiable, "{source}");
+    }
+    for size in [1, 2] {
+        let source = collection_identity::distinct_receivers(size);
+        let Some(out) = outcome(&source) else { return };
+        assert!(
+            matches!(out, SolveOutcome::Satisfiable(_)),
+            "{source}: {out:?}"
+        );
+    }
+}
+
+#[test]
+fn scalar_admission_respects_defaults_and_subsetting() {
+    for (source, scalar) in collection_identity::scalar_admission() {
+        let Some(out) = outcome(&source) else { return };
+        if scalar {
+            assert_eq!(out, SolveOutcome::Unsatisfiable, "{source}");
+        } else {
+            assert!(matches!(out, SolveOutcome::Unknown(_)), "{source}: {out:?}");
+        }
+    }
+}
+
+#[test]
+fn scalar_admission_respects_body_and_named_multiplicity() {
+    let cfg = SolverConfig::default();
+    if z3_version(&cfg).is_err() {
+        return;
+    }
+    for (model, scalar) in collection_identity::body_scalar_admission() {
+        let solved = solve_constraints(&model, &cfg).unwrap();
+        assert_eq!(solved.len(), 1);
+        let out = solved[0].solve.as_ref().unwrap();
+        if scalar {
+            assert_eq!(*out, SolveOutcome::Unsatisfiable);
+        } else {
+            assert!(matches!(out, SolveOutcome::Unknown(_)), "{out:?}");
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/source_identity.rs b/crates/sysmlv2-solve/tests/source_identity.rs
new file mode 100644
index 0000000..5bb661d
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/source_identity.rs
@@ -0,0 +1,187 @@
+//! Symbolic translation must agree with the graph's source-bound identities.
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_model::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, verify_constraints_with, z3_version,
+};
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+fn models(source: &str, use_expr: Option<&str>) -> Vec<Model> {
+    let lib = "package ScalarValues { datatype Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                m.add_source(
+                    format!("{pkg}.sysml"),
+                    &format!("package {pkg} {{ attribute x[1]:ScalarValues::Integer; {source} }}"),
+                );
+            }
+            if let Some(expr) = use_expr {
+                for pkg in ["A", "B"] {
+                    m.add_source(
+                        format!("use{pkg}.sysml"),
+                        &format!(
+                            "package Use{pkg} {{ assert constraint c {{ {} }} }}",
+                            expr.replace("PKG", pkg)
+                        ),
+                    );
+                }
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+fn bind(r: &mut ResolvedModel) {
+    let actual = r.resolve_qualified("A::Actual").unwrap();
+    let ordinary = r.resolve_qualified(&format!("A::'{ID}'")).unwrap();
+    let sites = r.references_to(ordinary);
+    assert_eq!(sites.len(), 1, "{sites:?}");
+    r.override_ids(&HashMap::from([(
+        r.element_id(actual),
+        ID.parse().unwrap(),
+    )]));
+    let mut hints = HashMap::from([(
+        (r.element_id(sites[0].owner), sites[0].kind.clone()),
+        ID.parse().unwrap(),
+    )]);
+    assert!(
+        r.bind_id_spelled_references_with(&mut hints)
+            .contains(&ID.parse().unwrap())
+    );
+}
+#[test]
+fn symbolic_roots_and_nested_declarations_preserve_source_across_replay() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for form in ["root", "feature", "calc", "default", "sequence", "callee"] {
+        for reverse in [false, true] {
+            let (actual, spelled) = if reverse { (2, 1) } else { (1, 2) };
+            let prefix = format!("attribute Actual={actual}; attribute '{ID}'={spelled};");
+            let (source, caller) = match form {
+                "root" => (
+                    format!("{prefix} assert constraint c {{ x=='{ID}' & x==1 }}"),
+                    None,
+                ),
+                "feature" => (
+                    format!("{prefix} attribute bridge=x+'{ID}';"),
+                    Some("PKG::bridge==1 & PKG::x==0"),
+                ),
+                "calc" => (
+                    format!("{prefix} calc def F {{ in p; p+'{ID}' }}"),
+                    Some("PKG::F(PKG::x)==1 & PKG::x==0"),
+                ),
+                "default" => (
+                    format!("{prefix} calc def F {{ in p; in q default '{ID}'; p+q }}"),
+                    Some("PKG::F(PKG::x)==1 & PKG::x==0"),
+                ),
+                "sequence" => (
+                    format!("{prefix} attribute xs=(x,'{ID}');"),
+                    Some("sum(PKG::xs)==1 & PKG::x==0"),
+                ),
+                _ => (
+                    format!(
+                        "calc def Actual {{ in p; p+{actual} }} calc def '{ID}' {{ in p; p+{spelled} }} calc def F {{ in p; '{ID}'(p) }}"
+                    ),
+                    Some("PKG::F(PKG::x)==1 & PKG::x==0"),
+                ),
+            };
+            for (mode, model) in models(&source, caller).into_iter().enumerate() {
+                let mut r = ResolvedModel::build(&model);
+                bind(&mut r);
+                for _ in 0..2 {
+                    let result = propagate_constraints_with(&mut r, &model, &Default::default());
+                    assert_eq!(result.constraints.len(), 2);
+                    for c in result.constraints {
+                        let name = &model.unit(c.unit).name;
+                        let a = name
+                            == if caller.is_some() {
+                                "useA.sysml"
+                            } else {
+                                "A.sysml"
+                            };
+                        let sat = a != reverse;
+                        assert_eq!(
+                            c.propagate,
+                            Some(if sat {
+                                PropagateOutcome::Satisfied
+                            } else {
+                                PropagateOutcome::Unsatisfiable
+                            }),
+                            "{form} reverse={reverse} mode={mode} {name}"
+                        );
+                    }
+                }
+                if native {
+                    let result = solve_constraints_with(&mut r, &model, &cfg).unwrap();
+                    assert_eq!(result.len(), 2);
+                    for c in result {
+                        let name = &model.unit(c.unit).name;
+                        let a = name
+                            == if caller.is_some() {
+                                "useA.sysml"
+                            } else {
+                                "A.sysml"
+                            };
+                        let sat = a != reverse;
+                        assert!(
+                            if sat {
+                                matches!(c.solve, Some(SolveOutcome::Satisfiable(_)))
+                            } else {
+                                matches!(c.solve, Some(SolveOutcome::Unsatisfiable))
+                            },
+                            "{form} reverse={reverse} mode={mode} {name}: {:?}",
+                            c.solve
+                        );
+                    }
+                }
+                let result =
+                    verify_constraints_with(&mut r, &model, None, &Default::default()).unwrap();
+                assert_eq!(result.constraints.len(), 2);
+                for c in result.constraints {
+                    let name = &model.unit(c.unit).name;
+                    let a = name
+                        == if caller.is_some() {
+                            "useA.sysml"
+                        } else {
+                            "A.sysml"
+                        };
+                    assert_eq!(
+                        c.propagate,
+                        Some(if a != reverse {
+                            PropagateOutcome::Satisfied
+                        } else {
+                            PropagateOutcome::Unsatisfiable
+                        }),
+                        "verify {form} reverse={reverse} mode={mode} {name}"
+                    );
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/source_identity_chains.rs b/crates/sysmlv2-solve/tests/source_identity_chains.rs
new file mode 100644
index 0000000..c73daea
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/source_identity_chains.rs
@@ -0,0 +1,190 @@
+//! Two-link singleton navigation retains source-bound member identities.
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_model::{
+    json::ResolvedModel, libcache::LibraryCache, model::Model, prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, z3_version,
+};
+const ID: &str = "88888888-8888-4888-8888-888888888888";
+
+#[test]
+fn singleton_two_link_member_identity_crosses_units_without_capturing_equal_spans() {
+    let lib = "package ScalarValues { datatype Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for reverse in [false, true] {
+        for mode in 0..4 {
+            let mut model = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut model).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut model).unwrap(),
+                _ => {
+                    model.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        model.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                let alias = if reverse { "Actual" } else { "Other" };
+                model.add_source(format!("{pkg}.sysml"), &format!("package {pkg} {{ part def Leaf {{ attribute value:ScalarValues::Integer; }} part def Node {{ part Actual:Leaf[1]; part Other:Leaf[1]; alias '{ID}' for {alias}; }} part p:Node[1]; }}"));
+            }
+            for pkg in ["A", "B"] {
+                model.add_source(format!("use{pkg}.sysml"), &format!("package Use{pkg} {{ assert constraint c {{ {pkg}::p.Actual.value == 0 & {pkg}::p->forAll {{ in i:{pkg}::Node; i.'{ID}'.value == 1 }} }} }}"));
+            }
+            assert!(!model.has_errors());
+            let mut r = ResolvedModel::build(&model);
+            let target = r
+                .resolve_qualified(if reverse {
+                    "A::Node::Other"
+                } else {
+                    "A::Node::Actual"
+                })
+                .unwrap();
+            let ordinary = r.resolve_qualified(&format!("A::Node::'{ID}'")).unwrap();
+            let a_site = r
+                .references_to(ordinary)
+                .into_iter()
+                .find(|s| {
+                    model.unit(s.unit).name == "useA.sysml"
+                        && s.name_span.end - s.name_span.start == 38
+                })
+                .unwrap();
+            let b_ordinary = r.resolve_qualified(&format!("B::Node::'{ID}'")).unwrap();
+            let b_site = r
+                .references_to(b_ordinary)
+                .into_iter()
+                .find(|s| {
+                    model.unit(s.unit).name == "useB.sysml"
+                        && s.name_span.end - s.name_span.start == 38
+                })
+                .unwrap();
+            assert_eq!(
+                a_site.name_span, b_site.name_span,
+                "intentional cross-unit source-span collision"
+            );
+            r.override_ids(&HashMap::from([(
+                r.element_id(target),
+                ID.parse().unwrap(),
+            )]));
+            let mut hints = HashMap::from([(
+                (r.element_id(a_site.owner), a_site.kind),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                let result = propagate_constraints_with(&mut r, &model, &Default::default());
+                assert_eq!(result.constraints.len(), 2);
+                for c in result.constraints {
+                    let a = model.unit(c.unit).name == "useA.sysml";
+                    let unsat = a != reverse;
+                    assert_eq!(
+                        c.propagate,
+                        Some(if unsat {
+                            PropagateOutcome::Unsatisfiable
+                        } else {
+                            PropagateOutcome::Satisfied
+                        }),
+                        "reverse={reverse} mode={mode} A={a}"
+                    );
+                }
+            }
+            if native {
+                for c in solve_constraints_with(&mut r, &model, &cfg).unwrap() {
+                    let a = model.unit(c.unit).name == "useA.sysml";
+                    let unsat = a != reverse;
+                    assert!(
+                        if unsat {
+                            matches!(c.solve, Some(SolveOutcome::Unsatisfiable))
+                        } else {
+                            matches!(c.solve, Some(SolveOutcome::Satisfiable(_)))
+                        },
+                        "reverse={reverse} mode={mode} A={a}: {:?}",
+                        c.solve
+                    );
+                }
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn null_coalescing_reads_bound_identity_before_selecting_a_symbolic_branch() {
+    let cfg = SolverConfig::default();
+    let native = z3_version(&cfg).is_ok();
+    for reverse in [false, true] {
+        let (actual, ordinary) = if reverse {
+            ("0", "null")
+        } else {
+            ("null", "0")
+        };
+        let mut model = Model::new();
+        for pkg in ["A", "B"] {
+            model.add_source(format!("{pkg}.sysml"),&format!("package {pkg} {{ attribute def Integer; attribute x[1]:Integer; attribute Actual={actual}; attribute '{ID}'={ordinary}; assert constraint c {{ ('{ID}' ?? x)+x == 1 & x == 1 }} }}"));
+        }
+        assert!(!model.has_errors());
+        let mut r = ResolvedModel::build(&model);
+        let target = r.resolve_qualified("A::Actual").unwrap();
+        let ordinary = r.resolve_qualified(&format!("A::'{ID}'")).unwrap();
+        let sites = r.references_to(ordinary);
+        assert_eq!(sites.len(), 1);
+        r.override_ids(&HashMap::from([(
+            r.element_id(target),
+            ID.parse().unwrap(),
+        )]));
+        let mut hints = HashMap::from([(
+            (r.element_id(sites[0].owner), sites[0].kind.clone()),
+            ID.parse().unwrap(),
+        )]);
+        assert!(
+            r.bind_id_spelled_references_with(&mut hints)
+                .contains(&ID.parse().unwrap())
+        );
+        for _ in 0..2 {
+            let result = propagate_constraints_with(&mut r, &model, &Default::default());
+            assert_eq!(result.constraints.len(), 2);
+            for c in result.constraints {
+                let unsat = (model.unit(c.unit).name == "A.sysml") != reverse;
+                assert_eq!(
+                    c.propagate,
+                    Some(if unsat {
+                        PropagateOutcome::Unsatisfiable
+                    } else {
+                        PropagateOutcome::Satisfied
+                    }),
+                    "reverse={reverse}: {c:?}"
+                );
+            }
+        }
+        if native {
+            for c in solve_constraints_with(&mut r, &model, &cfg).unwrap() {
+                let unsat = (model.unit(c.unit).name == "A.sysml") != reverse;
+                assert!(
+                    if unsat {
+                        matches!(c.solve, Some(SolveOutcome::Unsatisfiable))
+                    } else {
+                        matches!(c.solve, Some(SolveOutcome::Satisfiable(_)))
+                    },
+                    "reverse={reverse}: {c:?}"
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-solve/tests/value_receiver_identity.rs b/crates/sysmlv2-solve/tests/value_receiver_identity.rs
new file mode 100644
index 0000000..ef05e33
--- /dev/null
+++ b/crates/sysmlv2-solve/tests/value_receiver_identity.rs
@@ -0,0 +1,442 @@
+//! Receiver admission preserves lexical values and supported specializing contexts.
+use std::{collections::HashMap, sync::Arc};
+use sysmlv2_model::{
+    check::ConstraintVerdict, json::ResolvedModel, libcache::LibraryCache, model::Model,
+    prepared::PreparedLibrary,
+};
+use sysmlv2_solve::{
+    PropagateOutcome, SolveOutcome, SolverConfig, propagate_constraints_with,
+    solve_constraints_with, z3_version,
+};
+fn native_solve(
+    r: &mut ResolvedModel,
+    model: &Model,
+    cfg: &SolverConfig,
+) -> Vec<sysmlv2_solve::SolvedConstraint> {
+    if z3_version(cfg).is_err() {
+        return Vec::new();
+    }
+    solve_constraints_with(r, model, cfg).unwrap()
+}
+fn models(source: &str) -> Vec<Model> {
+    let lib = "package ScalarValues { datatype Integer; }";
+    let mut base = Model::new();
+    base.add_library_source("lib.kerml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(43).unwrap(), 43).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("lib.kerml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            }
+            for pkg in ["A", "B"] {
+                m.add_source(
+                    format!("{pkg}.sysml"),
+                    &format!("package {pkg} {{ attribute x[1]:ScalarValues::Integer; {source} }}"),
+                );
+            }
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+fn check_known(source: &str, expected_value: i128, satisfiable: bool, label: &str) {
+    use sysmlv2_model::eval::Value;
+    for (mode, model) in models(source).into_iter().enumerate() {
+        let mut resolved = ResolvedModel::build(&model);
+        for _ in 0..2 {
+            for name in ["A::direct", "B::direct"] {
+                let element = resolved.resolve_qualified(name).unwrap();
+                assert_eq!(
+                    resolved.evaluate(element),
+                    Ok(Value::Integer(expected_value)),
+                    "{label} mode={mode} {name}"
+                );
+            }
+            let propagated = propagate_constraints_with(&mut resolved, &model, &Default::default());
+            assert_eq!(propagated.constraints.len(), 2, "{label} mode={mode}");
+            for constraint in propagated.constraints {
+                if satisfiable {
+                    assert_eq!(
+                        constraint.propagate,
+                        Some(PropagateOutcome::Satisfied),
+                        "{label} mode={mode}: {constraint:?}"
+                    );
+                } else {
+                    assert!(
+                        matches!(
+                            constraint.propagate,
+                            Some(PropagateOutcome::Unsatisfiable | PropagateOutcome::Violated)
+                        ),
+                        "{label} mode={mode}: {constraint:?}"
+                    );
+                }
+            }
+            for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                if satisfiable {
+                    assert!(
+                        matches!(
+                            constraint.solve,
+                            Some(SolveOutcome::Satisfiable(_) | SolveOutcome::Valid)
+                        ) || constraint.verdict == ConstraintVerdict::Satisfied,
+                        "{label} mode={mode}: {constraint:?}"
+                    );
+                } else {
+                    assert!(
+                        constraint.verdict == ConstraintVerdict::Violated
+                            || constraint.solve == Some(SolveOutcome::Unsatisfiable),
+                        "{label} mode={mode}: {constraint:?}"
+                    );
+                }
+            }
+        }
+        if mode == 3 {
+            assert_eq!(model.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn unrelated_type_values_keep_their_own_lexical_scope() {
+    for inputs in ["in p default 2;", "in unused; attribute p=2;"] {
+        for body in ["v", "sum(v)"] {
+            for expected in [1, 2] {
+                let source = format!(
+                    "part def Box {{ attribute p=1; attribute v=p; }}
+                     calc def Child {{ {inputs} alias v for Box::v; {body} }}
+                     attribute direct=Child(7);
+                     assert constraint c {{Child(x)=={expected} & x==7}}"
+                );
+                check_known(
+                    &source,
+                    1,
+                    expected == 1,
+                    &format!("inputs={inputs} body={body} expected={expected}"),
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn valid_receiver_contexts_keep_specialized_values() {
+    for (declarations, value, open_value) in [
+        (
+            "calc def Base {in p default 1; attribute v=p;}
+             calc def Child :> Base {in q :>>Base::p; v}",
+            "Child(7)",
+            "Child(x)",
+        ),
+        (
+            "part def Base {attribute p=1; attribute v=p;}
+             part child[1]:Base {attribute :>>p=7;}",
+            "child.v",
+            "child.v",
+        ),
+        (
+            "part def Base {attribute p=1; attribute v default p;}
+             part child[1]:Base {attribute :>>p=7; attribute :>>v;}",
+            "child.v",
+            "child.v",
+        ),
+        (
+            "part def Base {attribute p=1; attribute v=p;}
+             part child[1]:Base {attribute :>>p=7; attribute nested=v+0;}",
+            "child.nested",
+            "child.nested",
+        ),
+        (
+            "calc def Outer {in p; calc def Nested {attribute v=p; v} Nested()}",
+            "Outer(7)",
+            "Outer(x)",
+        ),
+    ] {
+        for expected in [7, 2] {
+            let source = format!(
+                "{declarations} attribute direct={value}; assert constraint c {{{open_value}=={expected} & x==7}}"
+            );
+            check_known(
+                &source,
+                7,
+                expected == 7,
+                &format!("{value} expected={expected}"),
+            );
+        }
+    }
+}
+
+#[test]
+fn incomplete_receiver_relationships_do_not_establish_value_context() {
+    for heritage in [
+        "calc def Child :> Missing",
+        "calc def Loop :> Loop; calc def Child :> Loop",
+        "calc def Left :> Right; calc def Right :> Left; calc def Child :> Left",
+    ] {
+        for body in ["v", "sum(v)"] {
+            let source = format!(
+                "part def Box {{attribute p=1; attribute v=p;}}
+                 {heritage} {{in p default 2; alias v for Box::v; {body}}}
+                 attribute direct=Child(7);
+                 attribute wrapped[1]:ScalarValues::Integer=Child(x);
+                 assert constraint c {{wrapped==2 & x==7}}"
+            );
+            for (mode, model) in models(&source).into_iter().enumerate() {
+                let mut resolved = ResolvedModel::build(&model);
+                for _ in 0..2 {
+                    for name in ["A::direct", "B::direct", "A::wrapped", "B::wrapped"] {
+                        let element = resolved.resolve_qualified(name).unwrap();
+                        assert!(
+                            resolved.evaluate(element).is_err(),
+                            "heritage={heritage} body={body} mode={mode} {name}"
+                        );
+                    }
+                    let propagated =
+                        propagate_constraints_with(&mut resolved, &model, &Default::default());
+                    assert_eq!(propagated.constraints.len(), 2);
+                    for constraint in propagated.constraints {
+                        assert!(
+                            matches!(constraint.propagate, Some(PropagateOutcome::Unsupported(_))),
+                            "heritage={heritage} body={body} mode={mode}: {constraint:?}"
+                        );
+                    }
+                    for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                        assert!(
+                            matches!(constraint.solve, Some(SolveOutcome::Unknown(_))),
+                            "heritage={heritage} body={body} mode={mode}: {constraint:?}"
+                        );
+                    }
+                }
+                if mode == 3 {
+                    assert_eq!(model.loaded_library_unit_count(), 0);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn absent_lexical_dependency_stays_unsupported_after_receiver_proof() {
+    for body in ["v", "sum(v)"] {
+        for (mode, model) in models(&format!(
+            "part def Box {{attribute v=p;}}
+             calc def Child {{in p default 2; alias v for Box::v; {body}}}
+             attribute direct=Child(7);
+             assert constraint c {{Child(x)==2 & x==7}}"
+        ))
+        .into_iter()
+        .enumerate()
+        {
+            let mut resolved = ResolvedModel::build(&model);
+            for _ in 0..2 {
+                for name in ["A::direct", "B::direct"] {
+                    let element = resolved.resolve_qualified(name).unwrap();
+                    assert!(
+                        resolved.evaluate(element).is_err(),
+                        "body={body} mode={mode}"
+                    );
+                }
+                for constraint in
+                    propagate_constraints_with(&mut resolved, &model, &Default::default())
+                        .constraints
+                {
+                    assert!(
+                        matches!(constraint.propagate, Some(PropagateOutcome::Unsupported(_))),
+                        "body={body} mode={mode}: {constraint:?}"
+                    );
+                }
+                for constraint in native_solve(&mut resolved, &model, &Default::default()) {
+                    assert!(
+                        matches!(constraint.solve, Some(SolveOutcome::Unknown(_))),
+                        "body={body} mode={mode}: {constraint:?}"
+                    );
+                }
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+#[test]
+fn exact_foreign_value_identity_keeps_source_and_lexical_owner() {
+    use sysmlv2_model::eval::Value;
+    const ID: &str = "88888888-8888-4888-8888-888888888888";
+    for reverse in [false, true] {
+        let (actual, ordinary) = if reverse { (9, 1) } else { (1, 9) };
+        for (mode, model) in models(&format!(
+            "part def Box {{attribute p={actual}; attribute v=p;}}
+             calc def Child {{in q; attribute p=2; attribute '{ID}'={ordinary}; '{ID}'}}
+             attribute direct=Child(7);
+             assert constraint c {{Child(x)==1 & x==7}}"
+        ))
+        .into_iter()
+        .enumerate()
+        {
+            let mut r = ResolvedModel::build(&model);
+            let target = r.resolve_qualified("A::Box::v").unwrap();
+            let child = r.resolve_qualified("A::Child").unwrap();
+            let result = r.members_via(child, "ResultExpressionMembership")[0];
+            let edge = r
+                .owned_relationships(result)
+                .into_iter()
+                .find(|e| r.element_type(*e) == "Membership")
+                .unwrap();
+            r.override_ids(&HashMap::from([(
+                r.element_id(target),
+                ID.parse().unwrap(),
+            )]));
+            let mut hints = HashMap::from([(
+                (r.element_id(edge), "memberElement".into()),
+                ID.parse().unwrap(),
+            )]);
+            assert!(
+                r.bind_id_spelled_references_with(&mut hints)
+                    .contains(&ID.parse().unwrap())
+            );
+            for _ in 0..2 {
+                for (pkg, value) in [("A", actual), ("B", ordinary)] {
+                    let e = r.resolve_qualified(&format!("{pkg}::direct")).unwrap();
+                    assert_eq!(
+                        r.evaluate(e),
+                        Ok(Value::Integer(value)),
+                        "mode={mode} reverse={reverse} {pkg}"
+                    );
+                }
+                for c in propagate_constraints_with(&mut r, &model, &Default::default()).constraints
+                {
+                    let sat = (model.unit(c.unit).name == "A.sysml") != reverse;
+                    let got = match c.verdict {
+                        ConstraintVerdict::Satisfied => true,
+                        ConstraintVerdict::Violated => false,
+                        _ => match c.propagate {
+                            Some(PropagateOutcome::Satisfied) => true,
+                            Some(PropagateOutcome::Unsatisfiable | PropagateOutcome::Violated) => {
+                                false
+                            }
+                            _ => panic!("{c:?}"),
+                        },
+                    };
+                    assert_eq!(got, sat, "mode={mode} reverse={reverse}");
+                }
+                for c in native_solve(&mut r, &model, &Default::default()) {
+                    let sat = (model.unit(c.unit).name == "A.sysml") != reverse;
+                    let got = match c.verdict {
+                        ConstraintVerdict::Satisfied => true,
+                        ConstraintVerdict::Violated => false,
+                        _ => match c.solve {
+                            Some(SolveOutcome::Satisfiable(_) | SolveOutcome::Valid) => true,
+                            Some(SolveOutcome::Unsatisfiable) => false,
+                            _ => panic!("{c:?}"),
+                        },
+                    };
+                    assert_eq!(got, sat, "mode={mode} reverse={reverse}");
+                }
+            }
+            if mode == 3 {
+                assert_eq!(model.loaded_library_unit_count(), 0);
+            }
+        }
+    }
+}
+
+fn custom_models(lib: &str, filename: &str, source: &str) -> Vec<Model> {
+    let mut base = Model::new();
+    base.add_library_source("parts.sysml", lib);
+    base.record_library_cache();
+    ResolvedModel::build(&base);
+    let cache =
+        LibraryCache::from_bytes(&base.take_recorded_library_cache().unwrap().to_bytes()).unwrap();
+    let prepared = base.prepare_library().unwrap();
+    let decoded =
+        Arc::new(PreparedLibrary::from_bytes(&prepared.to_bytes(46).unwrap(), 46).unwrap());
+    (0..4)
+        .map(|mode| {
+            let mut m = Model::new();
+            match mode {
+                2 => Arc::clone(&prepared).install(&mut m).unwrap(),
+                3 => Arc::clone(&decoded).install(&mut m).unwrap(),
+                _ => {
+                    m.add_library_source("parts.sysml", lib);
+                    if mode == 1 {
+                        m.set_library_cache(cache.clone());
+                    }
+                }
+            };
+            m.add_source(filename, source);
+            assert!(!m.has_errors());
+            m
+        })
+        .collect()
+}
+
+#[test]
+fn inherited_library_base_and_typed_receiver_keep_overrides() {
+    use sysmlv2_model::{eval::Value, json::ValueScopeDecision};
+    let lib =
+        "standard library package Parts {part def Part {attribute p=1;attribute v=p;} part parts;}";
+    let src = "part def Child {attribute :>>p=7;} part child[1]:Child; attribute direct=child.v;";
+    for (mode, m) in custom_models(lib, "user.sysml", src)
+        .into_iter()
+        .enumerate()
+    {
+        let mut r = ResolvedModel::build(&m);
+        let v = r.resolve_qualified("Parts::Part::v").unwrap();
+        for _ in 0..2 {
+            for name in ["Child", "child"] {
+                let elem = r.resolve_qualified(name).unwrap();
+                let scope = r.element_scope(elem).unwrap();
+                assert_eq!(
+                    r.value_scope_decision_with_steps(v, Some(scope), &mut 0),
+                    ValueScopeDecision::Receiver(scope),
+                    "mode={mode} {name}"
+                );
+            }
+            let value = r.resolve_qualified("direct").unwrap();
+            assert_eq!(r.evaluate(value), Ok(Value::Integer(7)), "mode={mode}");
+        }
+        if mode == 3 {
+            assert_eq!(m.loaded_library_unit_count(), 0);
+        }
+    }
+}
+
+#[test]
+fn conjugated_receiver_uses_original_type_values() {
+    use sysmlv2_model::{eval::Value, json::ValueScopeDecision};
+    let src = "classifier A {feature p=1;feature v=p;} classifier C conjugates A {feature redefines p=7;} feature direct=C.v;";
+    for (mode, m) in custom_models("package Empty;", "conjugation.kerml", src)
+        .into_iter()
+        .enumerate()
+    {
+        let mut r = ResolvedModel::build(&m);
+        let v = r.resolve_qualified("A::v").unwrap();
+        let conjugated = r.resolve_qualified("C").unwrap();
+        let scope = r.element_scope(conjugated).unwrap();
+        for _ in 0..2 {
+            assert_eq!(
+                r.value_scope_decision_with_steps(v, Some(scope), &mut 0),
+                ValueScopeDecision::Receiver(scope),
+                "mode={mode}"
+            );
+            let e = r.resolve_qualified("direct").unwrap();
+            assert_eq!(r.evaluate(e), Ok(Value::Integer(7)), "mode={mode}");
+        }
+        if mode == 3 {
+            assert_eq!(m.loaded_library_unit_count(), 0);
+        }
+    }
+}
diff --git a/crates/sysmlv2-syntax/src/ast.rs b/crates/sysmlv2-syntax/src/ast.rs
index bfff1a8..f2fcc26 100644
--- a/crates/sysmlv2-syntax/src/ast.rs
+++ b/crates/sysmlv2-syntax/src/ast.rs
@@ -1061,9 +1061,6 @@ pub enum ExprKind {
     Body {
         members: Vec<Member>,
     },
-    /// The non-braced SysML `ExpressionBody` alternative, inherited from a
-    /// semicolon-bodied `CalculationBody`.
-    BodyTerminator,
     /// `(a, b, c)` — sequence.
     Sequence(Vec<Expr>),
     /// `x.metadata` — metadata access.
diff --git a/crates/sysmlv2-syntax/src/check.rs b/crates/sysmlv2-syntax/src/check.rs
index 7db72f0..8aba5c9 100644
--- a/crates/sysmlv2-syntax/src/check.rs
+++ b/crates/sysmlv2-syntax/src/check.rs
@@ -133,6 +133,74 @@ impl Ctx {
             Ctx::KRoot | Ctx::KPackage | Ctx::KType | Ctx::KFunction
         )
     }
+
+    /// Does a body of this context end in a result expression (and take
+    /// a `return` parameter): the calculation, case, and function bodies.
+    fn takes_result(self) -> bool {
+        matches!(self, Ctx::Calculation | Ctx::Case | Ctx::KFunction)
+    }
+}
+
+/// Body context of a definition's body in `dialect`, per its kind.
+fn def_body_ctx(dialect: Dialect, k: DefKind) -> Ctx {
+    use DefKind::*;
+    if dialect == Dialect::Kerml {
+        return match k {
+            Function | Predicate => Ctx::KFunction,
+            _ => Ctx::KType,
+        };
+    }
+    match k {
+        Enum => Ctx::Enumeration,
+        Interface => Ctx::Interface,
+        Action => Ctx::Action,
+        State => Ctx::State,
+        Calc | Constraint => Ctx::Calculation,
+        Requirement | Concern | Viewpoint => Ctx::Requirement,
+        Case | Analysis | Verification | UseCase => Ctx::Case,
+        View => Ctx::ViewDef,
+        // KerML kinds are unreachable in a SysML parse.
+        _ => Ctx::Definition,
+    }
+}
+
+/// Body context of a usage's body in `dialect`, per its kind.
+fn usage_body_ctx(dialect: Dialect, k: UsageKind) -> Ctx {
+    use UsageKind::*;
+    if dialect == Dialect::Kerml {
+        return match k {
+            Expr | BoolExpr | Invariant => Ctx::KFunction,
+            Metadata => Ctx::Metadata,
+            _ => Ctx::KType,
+        };
+    }
+    match k {
+        Interface => Ctx::Interface,
+        Action | Perform | Accept | Send | Assign | Terminate | IfNode | WhileLoop | ForLoop
+        | Merge | Decide | Join | Fork | Transition => Ctx::Action,
+        State | Exhibit => Ctx::State,
+        Calc | Constraint | AssertConstraint => Ctx::Calculation,
+        Requirement | Concern | Viewpoint | Satisfy => Ctx::Requirement,
+        Case | Analysis | Verification | UseCase | Include => Ctx::Case,
+        View => Ctx::View,
+        Metadata => Ctx::Metadata,
+        Expr | BoolExpr | Invariant => Ctx::KFunction,
+        Feature | Step | Connector => Ctx::KType,
+        _ => Ctx::Definition,
+    }
+}
+
+/// Does the body of a `k` definition in `dialect` end in a result
+/// expression? Asked by the parser, so that it reads a body's last
+/// member by the same table as the body-context check.
+pub(crate) fn definition_body_takes_result(dialect: Dialect, k: DefKind) -> bool {
+    def_body_ctx(dialect, k).takes_result()
+}
+
+/// Does the body of a `k` usage in `dialect` end in a result expression?
+/// (See [`definition_body_takes_result`].)
+pub(crate) fn usage_body_takes_result(dialect: Dialect, k: UsageKind) -> bool {
+    usage_body_ctx(dialect, k).takes_result()
 }
 
 /// Grammar category of a SysML usage member (`NonOccurrenceUsageElement`,
@@ -483,51 +551,12 @@ struct Validator {
 impl Validator {
     /// Body context of a definition's body, per its kind.
     fn ctx_for_def(&self, k: DefKind) -> Ctx {
-        use DefKind::*;
-        if self.dialect == Dialect::Kerml {
-            return match k {
-                Function | Predicate => Ctx::KFunction,
-                _ => Ctx::KType,
-            };
-        }
-        match k {
-            Enum => Ctx::Enumeration,
-            Interface => Ctx::Interface,
-            Action => Ctx::Action,
-            State => Ctx::State,
-            Calc | Constraint => Ctx::Calculation,
-            Requirement | Concern | Viewpoint => Ctx::Requirement,
-            Case | Analysis | Verification | UseCase => Ctx::Case,
-            View => Ctx::ViewDef,
-            // KerML kinds are unreachable in a SysML parse.
-            _ => Ctx::Definition,
-        }
+        def_body_ctx(self.dialect, k)
     }
 
     /// Body context of a usage's body, per its kind.
     fn ctx_for_usage(&self, k: UsageKind) -> Ctx {
-        use UsageKind::*;
-        if self.dialect == Dialect::Kerml {
-            return match k {
-                Expr | BoolExpr | Invariant => Ctx::KFunction,
-                Metadata => Ctx::Metadata,
-                _ => Ctx::KType,
-            };
-        }
-        match k {
-            Interface => Ctx::Interface,
-            Action | Perform | Accept | Send | Assign | Terminate | IfNode | WhileLoop
-            | ForLoop | Merge | Decide | Join | Fork | Transition => Ctx::Action,
-            State | Exhibit => Ctx::State,
-            Calc | Constraint | AssertConstraint => Ctx::Calculation,
-            Requirement | Concern | Viewpoint | Satisfy => Ctx::Requirement,
-            Case | Analysis | Verification | UseCase | Include => Ctx::Case,
-            View => Ctx::View,
-            Metadata => Ctx::Metadata,
-            Expr | BoolExpr | Invariant => Ctx::KFunction,
-            Feature | Step | Connector => Ctx::KType,
-            _ => Ctx::Definition,
-        }
+        usage_body_ctx(self.dialect, k)
     }
 
     /// Context for members of a `{ … }` expression body.
@@ -841,9 +870,7 @@ impl Validator {
             MemberKind::StateSubaction { .. } => ctx == Ctx::State,
             MemberKind::Expose(_) => ctx == Ctx::View,
             MemberKind::Render(_) => matches!(ctx, Ctx::ViewDef | Ctx::View),
-            MemberKind::Return(_) | MemberKind::Result(_) => {
-                matches!(ctx, Ctx::Calculation | Ctx::Case | Ctx::KFunction)
-            }
+            MemberKind::Return(_) | MemberKind::Result(_) => ctx.takes_result(),
             MemberKind::Usage(u) => self.usage_ok(ctx, u),
         };
         if !ok {
@@ -1157,7 +1184,6 @@ impl Validator {
         match &e.kind {
             ExprKind::Literal(_)
             | ExprKind::Null
-            | ExprKind::BodyTerminator
             | ExprKind::Ref(_)
             | ExprKind::MetadataAccess { .. }
             | ExprKind::Extent { .. } => {}
diff --git a/crates/sysmlv2-syntax/src/parser.rs b/crates/sysmlv2-syntax/src/parser.rs
index 505dc9e..64990f9 100644
--- a/crates/sysmlv2-syntax/src/parser.rs
+++ b/crates/sysmlv2-syntax/src/parser.rs
@@ -263,6 +263,14 @@ where
 /// ships against.
 pub const MAX_EXPR_OPERATORS: u32 = 1024;
 
+/// The error reported at a `;` written after the result expression of a
+/// body that takes one — a calculation, constraint, case, or function
+/// body (`calc def F { in x : Real; x * 2; }`): the result expression is
+/// the body's last member and ends at the closing `}`. The parser keeps
+/// the expression as the body's result, so the `;` is all there is to
+/// fix — which is what a consumer offering the fix can key on.
+pub const RESULT_EXPRESSION_TERMINATOR: &str = "a result expression takes no terminating `;`";
+
 thread_local! {
     static ACCEPT_LOOKAHEAD_TOKENS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
 }
@@ -896,6 +904,14 @@ impl<'s> Parser<'s> {
     }
 
     fn parse_body_members(&mut self) -> Vec<Member> {
+        self.parse_body_members_taking(false)
+    }
+
+    /// The members of a body; `takes_result`: the body may end in a
+    /// result expression — a calculation, case, or function body — after
+    /// which a `;` is reported for what it is (see
+    /// [`Self::stray_result_terminators`]).
+    fn parse_body_members_taking(&mut self, takes_result: bool) -> Vec<Member> {
         if self.depth >= MAX_NESTING {
             self.error_here(format!(
                 "nesting is too deep (more than {MAX_NESTING} levels of bodies and expressions)"
@@ -904,7 +920,7 @@ impl<'s> Parser<'s> {
             return Vec::new();
         }
         self.depth += 1;
-        let members = self.parse_body_members_inner();
+        let members = self.parse_body_members_inner(takes_result);
         self.depth -= 1;
         members
     }
@@ -929,7 +945,7 @@ impl<'s> Parser<'s> {
         }
     }
 
-    fn parse_body_members_inner(&mut self) -> Vec<Member> {
+    fn parse_body_members_inner(&mut self, takes_result: bool) -> Vec<Member> {
         let mut members = Vec::new();
         // Members of a body are siblings: each spells a chain of its own
         // rather than continuing the one its predecessor spelled, and the
@@ -941,7 +957,16 @@ impl<'s> Parser<'s> {
             let before = self.pos;
             let diags_before = self.diags.len();
             match self.parse_member() {
-                Some(m) => members.push(m),
+                Some(m) => {
+                    // A conditional result (`if c ? a else b`) parses as
+                    // a member of its own; a `;` after it is reported as
+                    // after any result.
+                    let result = matches!(m.kind, MemberKind::Result(_));
+                    members.push(m);
+                    if result && takes_result {
+                        self.stray_result_terminators();
+                    }
+                }
                 None => {
                     // The member parse failed. Before recovering, try the
                     // trailing-result-expression form (calc/case/constraint
@@ -966,8 +991,16 @@ impl<'s> Parser<'s> {
                     };
                     let expr_diags_before = self.diags.len();
                     if let Some(expr) = self.parse_expr() {
-                        if self.at(TokenKind::RBrace) && self.diags.len() == expr_diags_before {
-                            let span = start.join(self.prev_end_span());
+                        // Terminated like a statement (`x * 2; }`) in a
+                        // body that takes a result, the expression is still
+                        // the body's result: the error is the `;`, not the
+                        // operator the member parse tripped over. The
+                        // member's span ends with the expression.
+                        let span = start.join(self.prev_end_span());
+                        if self.diags.len() == expr_diags_before
+                            && (self.at(TokenKind::RBrace)
+                                || (takes_result && self.stray_result_terminators()))
+                        {
                             members.push(Member {
                                 visibility,
                                 leading_then: false,
@@ -1023,6 +1056,29 @@ impl<'s> Parser<'s> {
         members
     }
 
+    /// The `;` tokens between a body's result expression and the body's
+    /// closing `}` — the result terminated like a statement — each
+    /// reported at its own span and consumed, so the result stands and
+    /// the body closes. `false`, consuming nothing, unless nothing but
+    /// `;` stands between the cursor and a `}`.
+    fn stray_result_terminators(&mut self) -> bool {
+        let mut n = 0;
+        while self.nth(n).kind == TokenKind::Semi {
+            n += 1;
+        }
+        if n == 0 || self.nth(n).kind != TokenKind::RBrace {
+            return false;
+        }
+        for _ in 0..n {
+            let semi = self.bump();
+            self.diags.push(Diagnostic::error(
+                semi.span,
+                RESULT_EXPRESSION_TERMINATOR.to_string(),
+            ));
+        }
+        true
+    }
+
     fn parse_member(&mut self) -> Option<Member> {
         let start = self.cur().span;
         let visibility = if self.eat_kw("public") {
@@ -1391,7 +1447,7 @@ impl<'s> Parser<'s> {
             self.parse_feature_specializations(&mut declaration);
         }
         let value = self.parse_value_part();
-        let body = self.parse_body_or_semi()?;
+        let body = self.parse_usage_body_or_semi(kind)?;
         Some(Usage {
             prefix,
             kind,
@@ -3691,9 +3747,10 @@ impl<'s> Parser<'s> {
         }
         let is_parallel = kind == DefKind::State && self.eat_kw("parallel");
         let body = if kind == DefKind::Enum {
-            self.parse_body_or_semi_ctx(false, true)?
+            self.parse_body_or_semi_ctx(false, true, false)?
         } else {
-            self.parse_body_or_semi()?
+            let takes_result = crate::check::definition_body_takes_result(self.dialect, kind);
+            self.parse_body_or_semi_ctx(false, false, takes_result)?
         };
         Some(Definition {
             prefix,
@@ -3715,19 +3772,27 @@ impl<'s> Parser<'s> {
     /// Like [`Parser::parse_brace_body`] but distinguishes `None` (a `;`
     /// body) from a parse failure.
     fn parse_body_or_semi(&mut self) -> Option<Option<Vec<Member>>> {
-        self.parse_body_or_semi_ctx(false, false)
+        self.parse_body_or_semi_ctx(false, false, false)
+    }
+
+    /// The body of a `kind` usage: [`Parser::parse_body_or_semi`], ending
+    /// in a result expression where the kind's body takes one.
+    fn parse_usage_body_or_semi(&mut self, kind: UsageKind) -> Option<Option<Vec<Member>>> {
+        let takes_result = crate::check::usage_body_takes_result(self.dialect, kind);
+        self.parse_body_or_semi_ctx(false, false, takes_result)
     }
 
     /// `MetadataBody`: same surface shape, but members parse in metadata
     /// context (implicit qualified-name redefinitions).
     fn parse_metadata_body_or_semi(&mut self) -> Option<Option<Vec<Member>>> {
-        self.parse_body_or_semi_ctx(true, false)
+        self.parse_body_or_semi_ctx(true, false, false)
     }
 
     fn parse_body_or_semi_ctx(
         &mut self,
         meta: bool,
         enum_body: bool,
+        takes_result: bool,
     ) -> Option<Option<Vec<Member>>> {
         if self.eat(TokenKind::Semi) {
             return Some(None);
@@ -3737,7 +3802,7 @@ impl<'s> Parser<'s> {
             let saved_enum = self.enum_body;
             self.meta_body = meta;
             self.enum_body = enum_body;
-            let members = self.parse_body_members();
+            let members = self.parse_body_members_taking(takes_result);
             self.meta_body = saved;
             self.enum_body = saved_enum;
             self.expect(TokenKind::RBrace, "`}` closing body");
@@ -3851,7 +3916,7 @@ impl<'s> Parser<'s> {
         }
 
         let is_parallel = kind == UsageKind::State && self.eat_kw("parallel");
-        let body = self.parse_body_or_semi()?;
+        let body = self.parse_usage_body_or_semi(kind)?;
         Some(Usage {
             prefix,
             kind,
@@ -3874,7 +3939,7 @@ impl<'s> Parser<'s> {
         let value = self.parse_value_part();
         let is_parallel =
             matches!(kind, UsageKind::State | UsageKind::Exhibit) && self.eat_kw("parallel");
-        let body = self.parse_body_or_semi()?;
+        let body = self.parse_usage_body_or_semi(kind)?;
         Some(Usage {
             prefix,
             kind,
@@ -5232,7 +5297,7 @@ impl<'s> Parser<'s> {
                 // otherwise a feature-chain step.
                 self.charge_chain(1)?;
                 match self.nth(1).kind {
-                    TokenKind::LBrace | TokenKind::Semi => {
+                    TokenKind::LBrace => {
                         self.bump();
                         let body = self.branch(Self::parse_body_expr)?;
                         let span = expr.span.join(body.span);
@@ -5325,9 +5390,7 @@ impl<'s> Parser<'s> {
                 self.charge_chain(1)?;
                 self.bump();
                 let ty = self.parse_target_ref()?;
-                let args = if self.at(TokenKind::LBrace)
-                    || (self.dialect == Dialect::Sysml && self.at(TokenKind::Semi))
-                {
+                let args = if self.at(TokenKind::LBrace) {
                     ArrowArgs::Body(Box::new(self.branch(Self::parse_body_expr)?))
                 } else if self.at(TokenKind::LParen) {
                     ArrowArgs::List(self.branch(Self::parse_argument_list)?)
@@ -5422,11 +5485,13 @@ impl<'s> Parser<'s> {
             });
         }
 
-        // SysML redefines ExpressionBody to CalculationBody, whose
-        // non-braced alternative is a single semicolon.
-        if self.at(TokenKind::LBrace)
-            || (self.dialect == Dialect::Sysml && self.at(TokenKind::Semi))
-        {
+        // SysML redefines ExpressionBody to CalculationBody, whose other
+        // alternative is a bare `;`. That is not read as an expression: a
+        // `;` where one belongs is the terminator of the declaration
+        // around it, the expression missing (`attribute x = ;`), so it
+        // falls through to the error below — reported at the `;` and left
+        // for the declaration to end with, as in KerML.
+        if self.at(TokenKind::LBrace) {
             return self.parse_body_expr();
         }
 
@@ -5525,19 +5590,14 @@ impl<'s> Parser<'s> {
         })
     }
 
-    /// Expression body. SysML overrides these to full calculation bodies,
-    /// including both the braced member form and a bare `;` alternative.
+    /// Expression body. SysML overrides these to full calculation bodies;
+    /// only the braced member form is read (the bare `;` alternative is
+    /// not an expression — see [`Self::parse_base`]).
     fn parse_body_expr(&mut self) -> Option<Expr> {
         let start = self.cur().span;
-        if self.dialect == Dialect::Sysml && self.eat(TokenKind::Semi) {
-            return Some(Expr {
-                kind: ExprKind::BodyTerminator,
-                span: start,
-            });
-        }
         self.expect(TokenKind::LBrace, "`{`")?;
         let saved = std::mem::take(&mut self.meta_body);
-        let members = self.parse_body_members();
+        let members = self.parse_body_members_taking(true);
         self.meta_body = saved;
         let end = self.cur().span;
         self.expect(TokenKind::RBrace, "`}` closing expression body");
diff --git a/crates/sysmlv2-syntax/src/print.rs b/crates/sysmlv2-syntax/src/print.rs
index a98cb88..2717988 100644
--- a/crates/sysmlv2-syntax/src/print.rs
+++ b/crates/sysmlv2-syntax/src/print.rs
@@ -2249,7 +2249,6 @@ impl Printer {
                 self.print_args(args);
             }
             ExprKind::Body { members } => self.print_expr_body(members, e.span),
-            ExprKind::BodyTerminator => self.w(";"),
             ExprKind::Sequence(items) => {
                 self.w("(");
                 for (i, item) in items.iter().enumerate() {
diff --git a/crates/sysmlv2-syntax/src/visit.rs b/crates/sysmlv2-syntax/src/visit.rs
index 39ae125..e510197 100644
--- a/crates/sysmlv2-syntax/src/visit.rs
+++ b/crates/sysmlv2-syntax/src/visit.rs
@@ -399,7 +399,7 @@ pub fn walk_target_ref<'a, V: Visit<'a> + ?Sized>(v: &mut V, n: &'a TargetRef) {
 
 pub fn walk_expr<'a, V: Visit<'a> + ?Sized>(v: &mut V, n: &'a Expr) {
     match &n.kind {
-        ExprKind::Literal(_) | ExprKind::Null | ExprKind::BodyTerminator => {}
+        ExprKind::Literal(_) | ExprKind::Null => {}
         ExprKind::Ref(qn) | ExprKind::MetadataAccess { target: qn } => v.visit_qualified_name(qn),
         ExprKind::Conditional {
             cond,
diff --git a/crates/sysmlv2-testkit/src/lib.rs b/crates/sysmlv2-testkit/src/lib.rs
index e8ab70b..ba2759a 100644
--- a/crates/sysmlv2-testkit/src/lib.rs
+++ b/crates/sysmlv2-testkit/src/lib.rs
@@ -46,6 +46,35 @@ pub fn corpus_root() -> PathBuf {
     root
 }
 
+/// A stable source-unit name relative to a chosen corpus root.
+///
+/// Source names seed user document identities. Preserve the directory components
+/// so files with the same basename remain distinct, and omit checkout-specific
+/// prefixes so moving the checkout preserves those identities. The returned
+/// separator is `/` on every platform. This helper does no filesystem I/O.
+///
+/// Panics if `path` is not below `root`, contains a parent traversal, or has a
+/// non-UTF-8 component; lossy conversion would not preserve distinct names.
+pub fn relative_source_name(root: &Path, path: &Path) -> String {
+    let relative = path
+        .strip_prefix(root)
+        .expect("source lies below corpus root");
+    let segments: Vec<_> = relative
+        .components()
+        .map(|component| match component {
+            std::path::Component::Normal(name) => {
+                name.to_str().expect("corpus source names are UTF-8")
+            }
+            _ => panic!("source path must have only normal relative components"),
+        })
+        .collect();
+    assert!(
+        !segments.is_empty(),
+        "source path names a file below the root"
+    );
+    segments.join("/")
+}
+
 /// The OMG standard library directory within the corpus.
 pub fn library_dir() -> PathBuf {
     corpus_root().join("sysml.library")
@@ -124,3 +153,46 @@ pub fn apollo_files() -> Option<Vec<PathBuf>> {
     assert!(files.len() >= 28, "expected the full Apollo checkout");
     Some(files)
 }
+
+#[cfg(test)]
+mod source_identity_tests {
+    use super::relative_source_name;
+    use std::path::Path;
+
+    #[test]
+    fn relative_source_names_preserve_directories_and_ignore_checkout_location() {
+        let first = relative_source_name(
+            Path::new("checkout-a"),
+            Path::new("checkout-a/examples/model.sysml"),
+        );
+        let second = relative_source_name(
+            Path::new("checkout-a"),
+            Path::new("checkout-a/validation/model.sysml"),
+        );
+        assert_eq!(first, "examples/model.sysml");
+        assert_eq!(second, "validation/model.sysml");
+        assert_ne!(first, second);
+        assert_eq!(
+            first,
+            relative_source_name(
+                Path::new("checkout-b"),
+                Path::new("checkout-b/examples/model.sysml")
+            )
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "source lies below corpus root")]
+    fn unrelated_paths_do_not_fall_back_to_a_basename() {
+        relative_source_name(Path::new("checkout-a"), Path::new("checkout-b/model.sysml"));
+    }
+
+    #[test]
+    #[should_panic(expected = "normal relative components")]
+    fn parent_traversal_is_not_a_relative_identity() {
+        relative_source_name(
+            Path::new("checkout-a"),
+            Path::new("checkout-a/../model.sysml"),
+        );
+    }
+}
diff --git a/crates/sysmlv2-transform/Cargo.toml b/crates/sysmlv2-transform/Cargo.toml
index b4649a5..1f18471 100644
--- a/crates/sysmlv2-transform/Cargo.toml
+++ b/crates/sysmlv2-transform/Cargo.toml
@@ -12,9 +12,9 @@ repository.workspace = true
 include = ["src/**", "Cargo.toml"]
 
 [dependencies]
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
-sysmlv2-cbor = { path = "../sysmlv2-cbor", version = "0.9.1" }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
+sysmlv2-cbor = { path = "../sysmlv2-cbor", version = "0.10.0" }
 uuid.workspace = true
 serde_json.workspace = true
 
diff --git a/crates/sysmlv2-transform/examples/sessionbench.rs b/crates/sysmlv2-transform/examples/sessionbench.rs
new file mode 100644
index 0000000..cd223c3
--- /dev/null
+++ b/crates/sysmlv2-transform/examples/sessionbench.rs
@@ -0,0 +1,298 @@
+//! Session build timings: the language server's completion/navigation
+//! session over a workspace plus the standard library.
+//!
+//!     sessionbench <LIB_DIR> <CORPUS_DIR> [reps] [only=<case,...>]
+//!
+//! Wall and thread-CPU milliseconds per case (min / median over reps).
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+use sysmlv2_model::json::ResolvedModel;
+use sysmlv2_model::model::Model;
+use sysmlv2_transform::{Library, Session};
+
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+#[repr(C)]
+struct Timespec {
+    sec: i64,
+    nsec: i64,
+}
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+extern "C" {
+    fn clock_gettime(clock: u32, tp: *mut Timespec) -> i32;
+}
+/// The calling thread's CPU time in milliseconds: what a build costs
+/// regardless of what else the machine is running.
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+fn cpu_ms() -> f64 {
+    // CLOCK_THREAD_CPUTIME_ID: 16 on macOS, 3 on Linux.
+    let id = if cfg!(target_os = "macos") { 16 } else { 3 };
+    let mut ts = Timespec { sec: 0, nsec: 0 };
+    // SAFETY: `ts` is a valid, writable timespec for the call's duration.
+    unsafe { clock_gettime(id, &mut ts) };
+    ts.sec as f64 * 1e3 + ts.nsec as f64 / 1e6
+}
+/// Elsewhere the wall clock stands in.
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+fn cpu_ms() -> f64 {
+    thread_local! { static START: Instant = Instant::now(); }
+    START.with(|start| start.elapsed().as_secs_f64() * 1e3)
+}
+
+const VEHICLE: &str = r#"package VehicleModel {
+    private import ISQ::*;
+    private import SI::*;
+    private import ScalarValues::*;
+    part def Engine {
+        attribute mass : MassValue;
+        attribute power : PowerValue;
+        port fuelIn : FuelPort;
+    }
+    port def FuelPort { in item fuel : Fuel; }
+    item def Fuel;
+    part def Wheel { attribute diameter : LengthValue; }
+    part def Vehicle {
+        attribute mass : MassValue = engine.mass + 4 * wheel.diameter * 0 [kg/m];
+        attribute name : String;
+        part engine : Engine;
+        part wheel : Wheel[4];
+    }
+    part car : Vehicle {
+        attribute :>> name = "car";
+        part :>> engine { attribute :>> mass = 150 [kg]; }
+    }
+}
+"#;
+
+fn collect(dir: &Path, out: &mut Vec<PathBuf>) {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return;
+    };
+    for e in entries.flatten() {
+        let p = e.path();
+        if p.is_dir() {
+            collect(&p, out);
+        } else if matches!(
+            p.extension().and_then(|e| e.to_str()),
+            Some("sysml" | "kerml")
+        ) {
+            out.push(p);
+        }
+    }
+}
+
+fn read_units(dir: &Path, relative: bool) -> Vec<(String, String)> {
+    let mut files = Vec::new();
+    collect(dir, &mut files);
+    files.sort();
+    files
+        .iter()
+        .map(|p| {
+            let name = if relative {
+                p.strip_prefix(dir)
+                    .unwrap()
+                    .components()
+                    .map(|c| c.as_os_str().to_string_lossy())
+                    .collect::<Vec<_>>()
+                    .join("/")
+            } else {
+                p.display().to_string()
+            };
+            (name, std::fs::read_to_string(p).unwrap())
+        })
+        .collect()
+}
+
+fn stats(xs: &mut [f64]) -> (f64, f64) {
+    xs.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    (xs[0], xs[xs.len() / 2])
+}
+
+/// Time `f` over `reps` after one untimed warm-up (disk caches, allocator).
+/// What `f` returns is dropped after the next timing, not within it, as a
+/// server drops the session it held while building the next.
+fn case<T>(
+    name: &str,
+    reps: usize,
+    only: &Option<Vec<String>>,
+    units: usize,
+    mut f: impl FnMut() -> T,
+) {
+    if let Some(only) = only {
+        if !only.iter().any(|o| o == name) {
+            return;
+        }
+    }
+    let mut previous = Some(f());
+    let mut wall = Vec::new();
+    let mut cpu = Vec::new();
+    for _ in 0..reps {
+        let c0 = cpu_ms();
+        let t0 = Instant::now();
+        let result = std::hint::black_box(f());
+        wall.push(t0.elapsed().as_secs_f64() * 1e3);
+        cpu.push(cpu_ms() - c0);
+        previous = Some(result);
+    }
+    drop(previous);
+    let (wmin, wmed) = stats(&mut wall);
+    let (cmin, cmed) = stats(&mut cpu);
+    println!(
+        "{name:<14} cpu min {cmin:8.1} med {cmed:8.1} | wall min {wmin:8.1} med {wmed:8.1} ms  (units {units})"
+    );
+}
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let lib_dir = PathBuf::from(args.next().expect("LIB_DIR"));
+    let corpus_dir = PathBuf::from(args.next().expect("CORPUS_DIR"));
+    let mut reps = 5;
+    let mut only: Option<Vec<String>> = None;
+    let mut exclude: Vec<String> = Vec::new();
+    for a in args {
+        if let Some(pat) = a.strip_prefix("exclude=") {
+            exclude.push(pat.to_string());
+        } else if let Some(list) = a.strip_prefix("only=") {
+            only = Some(list.split(',').map(str::to_string).collect());
+        } else {
+            reps = a.parse().unwrap();
+        }
+    }
+    let mut ws = read_units(&corpus_dir, false);
+    ws.retain(|(name, _)| !exclude.iter().any(|pat| name.contains(pat.as_str())));
+    ws.push(("vehicle.sysml".to_string(), VEHICLE.to_string()));
+    let one = vec![("vehicle.sysml".to_string(), VEHICLE.to_string())];
+    eprintln!("workspace {} units", ws.len());
+
+    // In-memory library in bundle order: sorted library files, then the
+    // ambient units, as the browser bundle lays them out.
+    let mut lib_units = read_units(&lib_dir, true);
+    lib_units.extend(sysmlv2_model::ambient::units());
+    let snapshot = {
+        let mut model = Model::new();
+        for (name, src) in &lib_units {
+            model.add_library_source(name.clone(), src);
+        }
+        model.record_library_cache();
+        let _ = ResolvedModel::build(&model);
+        model.take_recorded_library_cache().unwrap().to_bytes()
+    };
+    eprintln!(
+        "library {} units; snapshot {} bytes",
+        lib_units.len(),
+        snapshot.len()
+    );
+
+    let dir = Library::dir(&lib_dir);
+    // The previous session outlives the next build, as it does in a
+    // server, so the in-process prepared library stays shared.
+    let build = |sources: &Vec<(String, String)>, lib: &Library| {
+        Session::from_sources_with_library(sources.clone(), Some(lib.clone())).unwrap()
+    };
+    case("dir-ws", reps, &only, ws.len(), || build(&ws, &dir));
+    case("dir-one", reps, &only, one.len(), || build(&one, &dir));
+    let snap = Library::sources_with_snapshot(lib_units.clone(), snapshot.clone());
+    case("snap-one", reps, &only, one.len(), || build(&one, &snap));
+    case("snap-ws", reps, &only, ws.len(), || build(&ws, &snap));
+    let src = Library::sources(lib_units.clone());
+    case("src-one", reps, &only, one.len(), || build(&one, &src));
+    let prepared = Library::prepared_sources(lib_units.clone(), Some(snapshot.clone())).unwrap();
+    case("prep-one", reps, &only, one.len(), || {
+        build(&one, &prepared)
+    });
+    case("prep-ws", reps, &only, ws.len(), || build(&ws, &prepared));
+
+    // Sessions started from the outcomes the previous one settled on, as
+    // the language server starts them: the same units; a comment appended
+    // to the first unit on alternate builds; the last unit's `name`
+    // retyped on alternate builds, which changes one outcome.
+    let retyped = VEHICLE.replace("attribute name : String;", "attribute name : Real;");
+    assert_ne!(retyped, VEHICLE);
+    for (label, edit) in [("warm-same", 0), ("warm-comment", 1), ("warm-retype", 2)] {
+        let mut settled = Session::from_sources_with_library(ws.clone(), Some(prepared.clone()))
+            .unwrap()
+            .settled_outcomes();
+        let mut flip = false;
+        case(label, reps, &only, ws.len(), || {
+            let mut sources = ws.clone();
+            flip = !flip;
+            match edit {
+                1 if flip => sources[0].1.push_str("\n// edited\n"),
+                2 if flip => sources.last_mut().unwrap().1 = retyped.clone(),
+                _ => {}
+            }
+            let session =
+                Session::from_sources_settled(sources, Some(prepared.clone()), settled.clone())
+                    .unwrap();
+            settled = session.settled_outcomes();
+            session
+        });
+    }
+
+    // Post-build semantic queries a unit completion issues: quantity
+    // dimensions of every attribute definition, on a fresh session.
+    for (label, lib, sources) in [
+        ("dims-dir-one", &dir, &one),
+        ("dims-snap-one", &snap, &one),
+        ("dims-prep-one", &prepared, &one),
+    ] {
+        if only.as_ref().is_some_and(|o| !o.iter().any(|s| s == label)) {
+            continue;
+        }
+        let mut firsts = Vec::new();
+        let mut seconds = Vec::new();
+        for _ in 0..reps.max(1) {
+            let mut s =
+                Session::from_sources_with_library(sources.clone(), Some(lib.clone())).unwrap();
+            let r = s.resolved();
+            let defs = r.elements_of_metaclass("AttributeDefinition");
+            let c0 = cpu_ms();
+            let mut known = 0;
+            for &d in &defs {
+                known += r.quantity_dims_of_type(d).is_some() as usize;
+            }
+            let c1 = cpu_ms();
+            for &d in &defs {
+                std::hint::black_box(r.quantity_dims_of_type(d));
+            }
+            let c2 = cpu_ms();
+            firsts.push(c1 - c0);
+            seconds.push(c2 - c1);
+            if firsts.len() == 1 {
+                eprintln!(
+                    "{label}: {} attribute definitions, {known} with dimensions",
+                    defs.len()
+                );
+            }
+        }
+        let (f, _) = stats(&mut firsts);
+        let (g, _) = stats(&mut seconds);
+        println!("{label:<14} cpu min first {f:8.1} repeat {g:8.1} ms");
+    }
+
+    // Stage breakdown of the directory path over the workspace.
+    if only
+        .as_ref()
+        .is_none_or(|o| o.iter().any(|s| s == "stages"))
+    {
+        for _ in 0..3 {
+            let c0 = cpu_ms();
+            let mut model = Model::new();
+            let load =
+                sysmlv2_model::prepared::load_library_with_cache(&mut model, &lib_dir).unwrap();
+            let c1 = cpu_ms();
+            for (name, src) in &ws {
+                model.add_source(name.clone(), src);
+            }
+            let c2 = cpu_ms();
+            let resolved = ResolvedModel::build(&model);
+            let c3 = cpu_ms();
+            std::hint::black_box((&resolved, &load.recording_path));
+            println!(
+                "stages(dir-ws) cpu: library {:.1}  user parse {:.1}  resolve {:.1} ms",
+                c1 - c0,
+                c2 - c1,
+                c3 - c2
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-transform/src/lib.rs b/crates/sysmlv2-transform/src/lib.rs
index 4875ecb..39b9be3 100644
--- a/crates/sysmlv2-transform/src/lib.rs
+++ b/crates/sysmlv2-transform/src/lib.rs
@@ -22,8 +22,9 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt;
 use std::path::{Path, PathBuf};
 
+pub use sysmlv2_model::json::settled::SettledOutcomes;
 pub use sysmlv2_model::json::{ElementRef, RefSite, ResolvedModel, UnresolvedReference};
-pub use sysmlv2_model::model::Model as ModelHandle;
+pub use sysmlv2_model::model::{GraphFormat, Model as ModelHandle};
 
 use sysmlv2_model::libcache;
 use sysmlv2_model::model::Model;
@@ -584,6 +585,9 @@ pub struct Session {
     /// (RefSite/unit indices include them).
     unit_offset: usize,
     model: Model,
+    // Explicit format-aware entry points enforce JSON shape as well as headers.
+    // Historical legacy entry points retain their foreign-payload recovery.
+    enforce_graph_format: bool,
     resolved: ResolvedModel,
     /// Non-fatal problems from lifting interchange JSON (unknown
     /// constructs, unresolvable references) — empty for text sessions.
@@ -600,6 +604,11 @@ pub struct Session {
     /// Whether the loaded document carried references the lift could only
     /// spell as ids, so emissions must bind them.
     binds_ids: bool,
+    /// New library-name fallback binds only payload-proven sites, never an
+    /// unrelated authored UUID-shaped lexical name.
+    strict_id_bindings: bool,
+    id_reference_values: sysmlv2_model::loader::IdReferenceBindings,
+    id_reference_bindings: sysmlv2_model::loader::IdReferenceBindings,
 }
 
 /// Where a session's standard library comes from: a directory on disk
@@ -631,15 +640,109 @@ impl Library {
         units: Vec<(String, String)>,
         snapshot: Option<Vec<u8>>,
     ) -> Result<Library, SessionError> {
-        let source = Library::Sources {
-            units: std::sync::Arc::new(units),
-            snapshot: snapshot.map(std::sync::Arc::new),
-        };
-        let mut model = Model::new();
-        load_library_into(&mut model, &source)?;
+        Self::prepared_sources_with_format(units, snapshot, GraphFormat::LegacyV2)
+    }
+
+    /// Prepare library sources under the selected lowering/identity contract.
+    pub fn prepared_sources_with_format(
+        units: Vec<(String, String)>,
+        snapshot: Option<Vec<u8>>,
+        format: GraphFormat,
+    ) -> Result<Library, SessionError> {
+        let mut model = Model::with_graph_format(format);
+        for (name, src) in &units {
+            model.add_library_source(name.clone(), src);
+        }
+        // The prepared library keeps the recording it was prepared with, so a
+        // build that must resolve the library together with user units
+        // replays it. Without a usable snapshot (one that decodes for this
+        // graph format; one the preparing build rejects as stale is replaced
+        // the same way), preparing records one.
+        match snapshot
+            .as_deref()
+            .and_then(libcache::LibraryCache::from_bytes)
+            .filter(|cache| cache.graph_format() == format)
+        {
+            Some(cache) => model.set_library_cache(cache),
+            None => model.record_library_cache(),
+        }
         Ok(Library::Prepared(model.prepare_library()?))
     }
 
+    /// A library decoded from a prepared snapshot
+    /// ([`sysmlv2_model::prepared::PreparedLibrary::to_bytes`]) of exactly
+    /// `units`, in this order: the snapshot is keyed by their content, and one
+    /// made by another toolkit build or from other units is refused, so the
+    /// caller can fall back to [`Self::prepared_sources`]. Decoding skips the
+    /// resolve and keeps no syntax trees. The optional `recording` (the sealed
+    /// resolution snapshot) stays encoded, for the builds that must resolve
+    /// the library together with user units after all.
+    pub fn prepared_snapshot(
+        units: Vec<(String, String)>,
+        snapshot: &[u8],
+        recording: Option<Vec<u8>>,
+    ) -> Result<Library, SessionError> {
+        Self::prepared_snapshot_with_format(units, snapshot, recording, GraphFormat::LegacyV2)
+    }
+
+    /// [`Self::prepared_snapshot`] over a snapshot fed in chunks
+    /// ([`sysmlv2_model::prepared::PreparedLibrary::from_chunks`]): `fill`
+    /// copies the next bytes of the `len`-byte snapshot into the buffer it is
+    /// given, so a host that holds the snapshot elsewhere never copies it
+    /// here whole.
+    pub fn prepared_snapshot_chunks<F: FnMut(&mut [u8]) -> usize>(
+        units: Vec<(String, String)>,
+        len: usize,
+        fill: F,
+        recording: Option<Vec<u8>>,
+    ) -> Result<Library, SessionError> {
+        let key = libcache::hash_units(
+            units
+                .iter()
+                .map(|(name, text)| (name.as_str(), text.as_str())),
+        );
+        let library = sysmlv2_model::prepared::PreparedLibrary::from_chunks(len, fill, key)
+            .filter(|library| library.graph_format() == GraphFormat::LegacyV2)
+            .ok_or_else(|| {
+                SessionError::Io(std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "the prepared snapshot was made by another toolkit build or from other library units",
+                ))
+            })?;
+        let library = match recording {
+            Some(bytes) => library.with_lazy_recording(bytes),
+            None => library,
+        };
+        Ok(Library::Prepared(std::sync::Arc::new(library)))
+    }
+
+    /// [`Self::prepared_snapshot`] under the selected lowering/identity contract.
+    pub fn prepared_snapshot_with_format(
+        units: Vec<(String, String)>,
+        snapshot: &[u8],
+        recording: Option<Vec<u8>>,
+        format: GraphFormat,
+    ) -> Result<Library, SessionError> {
+        let key = libcache::hash_units(
+            units
+                .iter()
+                .map(|(name, text)| (name.as_str(), text.as_str())),
+        );
+        let library = sysmlv2_model::prepared::PreparedLibrary::from_bytes(snapshot, key)
+            .filter(|library| library.graph_format() == format)
+            .ok_or_else(|| {
+                SessionError::Io(std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "the prepared snapshot was made by another toolkit build or from other library units",
+                ))
+            })?;
+        let library = match recording {
+            Some(bytes) => library.with_lazy_recording(bytes),
+            None => library,
+        };
+        Ok(Library::Prepared(std::sync::Arc::new(library)))
+    }
+
     pub fn dir(path: impl Into<PathBuf>) -> Library {
         Library::Dir(path.into())
     }
@@ -1294,6 +1397,16 @@ pub fn check_sources(
 pub fn check_sources_with_library(
     sources: &[(String, String)],
     lib: Option<&Library>,
+) -> Result<Vec<CheckFinding>, SessionError> {
+    check_sources_with_graph_format(sources, lib, GraphFormat::LegacyV2)
+}
+
+/// Check sources under the selected lowering/identity contract. Prepared
+/// libraries must use the same format, as for session construction.
+pub fn check_sources_with_graph_format(
+    sources: &[(String, String)],
+    lib: Option<&Library>,
+    format: GraphFormat,
 ) -> Result<Vec<CheckFinding>, SessionError> {
     let mut parsed = Vec::new();
     let mut findings = syntax_findings(sources, |source| {
@@ -1305,7 +1418,7 @@ pub fn check_sources_with_library(
     // Referential + semantic checks: all cleanly-parsed units as one
     // model against the library.
     if let Some(lib) = lib {
-        let mut model = Model::new();
+        let mut model = Model::with_graph_format(format);
         let cache_path = load_library_into(&mut model, lib)?;
         for source in parsed {
             model.add_parsed_source(source);
@@ -1329,14 +1442,27 @@ pub fn check_sources_with_library(
     Ok(findings)
 }
 
+struct IdBindingMode<'a> {
+    enabled: bool,
+    strict: bool,
+    rebound_sites: Option<&'a [(usize, Span, Uuid)]>,
+}
+
 /// Re-apply a session's explicit ids after a rebuild and bind the
 /// references the lift could only spell as ids.
 fn apply_explicit_ids(
     resolved: &mut ResolvedModel,
     explicit_ids: &mut HashMap<Uuid, (Uuid, &'static str)>,
-    binds_ids: bool,
+    binding: IdBindingMode<'_>,
+    bindings: &mut sysmlv2_model::loader::IdReferenceBindings,
+    values: &mut sysmlv2_model::loader::IdReferenceBindings,
     warnings: &mut Vec<String>,
 ) {
+    let IdBindingMode {
+        enabled: binds_ids,
+        strict: strict_id_bindings,
+        rebound_sites,
+    } = binding;
     if explicit_ids.is_empty() && !binds_ids {
         // A text session: nothing to overlay, and a quoted name that
         // happens to look like an id stays a name.
@@ -1369,7 +1495,16 @@ fn apply_explicit_ids(
     if !binds_ids {
         return;
     }
-    let bound = resolved.bind_id_spelled_references();
+    let bound = if strict_id_bindings {
+        if let Some(sites) = rebound_sites {
+            *bindings = resolved.rekey_id_reference_bindings(sites);
+        }
+        let bound = resolved.bind_payload_id_references(bindings);
+        *values = resolved.payload_id_reference_values(bindings);
+        bound
+    } else {
+        resolved.bind_id_spelled_references_with(bindings)
+    };
     if !bound.is_empty() {
         // The lift's "cannot name reference target" notes for the ids
         // that are now bound no longer apply. A bound id with no element
@@ -1461,13 +1596,21 @@ fn syntax_findings(
 fn rebuild(
     sources: &[(String, String)],
     lib: Option<&Library>,
+    format: GraphFormat,
+    settled: Option<std::sync::Arc<SettledOutcomes>>,
 ) -> Result<(Model, ResolvedModel, usize), SessionError> {
     // Checked before the library loads: the payload emitters key every
     // unit by its name, so a blank one has no place to be laid out.
     if let Some((name, _)) = sources.iter().find(|(name, _)| name.trim().is_empty()) {
         return Err(SessionError::InvalidUnitName(name.clone()));
     }
-    let mut model = Model::new();
+    let mut model = Model::with_graph_format(format);
+    // The outcomes a previous build settled on, for this one to start
+    // from; the outcomes this one settles on are kept for the next.
+    match settled {
+        Some(settled) => model.start_from_settled(settled),
+        None => model.keep_settled_outcomes(),
+    }
     let mut cache_path = None;
     if let Some(lib) = lib {
         cache_path = load_library_into(&mut model, lib)?;
@@ -1585,16 +1728,71 @@ impl Session {
         sources: Vec<(String, String)>,
         lib: Option<Library>,
     ) -> Result<Session, SessionError> {
-        let (model, resolved, unit_offset) = rebuild(&sources, lib.as_ref())?;
+        let mut session =
+            Self::from_sources_with_graph_format(sources, lib, GraphFormat::LegacyV2)?;
+        session.enforce_graph_format = false;
+        Ok(session)
+    }
+
+    /// [`Self::from_sources_with_library`] with resolution started from
+    /// `settled`, the outcomes a previous session settled on (see
+    /// [`Self::settled_outcomes`]): on a prepared library, a unit lowered
+    /// to the references it was lowered to then takes their outcomes and
+    /// is confirmed in one pass when it resolves as it did, and any other
+    /// unit starts unresolved — what a language server rebuilding after an
+    /// edit starts from. The session answers as one built without.
+    pub fn from_sources_settled(
+        sources: Vec<(String, String)>,
+        lib: Option<Library>,
+        settled: Option<std::sync::Arc<SettledOutcomes>>,
+    ) -> Result<Session, SessionError> {
+        let mut session = Self::from_sources_with(sources, lib, GraphFormat::LegacyV2, settled)?;
+        session.enforce_graph_format = false;
+        Ok(session)
+    }
+
+    /// The outcomes this session's build settled on, for a session over
+    /// mostly the same units to start from (see
+    /// [`Self::from_sources_settled`]): `Some` only for a build on a
+    /// prepared library whose resolution ran its redo loop and settled;
+    /// `None` for a joint build, a build that resolved in one pass, or one
+    /// that did not settle. The session's own rebuilds — after an edit,
+    /// after a library load — start from them when there are any.
+    pub fn settled_outcomes(&self) -> Option<std::sync::Arc<SettledOutcomes>> {
+        self.model.settled_outcomes()
+    }
+
+    /// Open sources with an explicit lowering/identity contract. The selection
+    /// survives edits, library reloads and binary snapshots.
+    pub fn from_sources_with_graph_format(
+        sources: Vec<(String, String)>,
+        lib: Option<Library>,
+        format: GraphFormat,
+    ) -> Result<Session, SessionError> {
+        Self::from_sources_with(sources, lib, format, None)
+    }
+
+    /// [`Self::from_sources_with_graph_format`] started from `settled`.
+    fn from_sources_with(
+        sources: Vec<(String, String)>,
+        lib: Option<Library>,
+        format: GraphFormat,
+        settled: Option<std::sync::Arc<SettledOutcomes>>,
+    ) -> Result<Session, SessionError> {
+        let (model, resolved, unit_offset) = rebuild(&sources, lib.as_ref(), format, settled)?;
         Ok(Session {
             sources,
             lib,
             unit_offset,
             model,
+            enforce_graph_format: true,
             resolved,
             warnings: Vec::new(),
             explicit_ids: HashMap::new(),
             binds_ids: false,
+            strict_id_bindings: false,
+            id_reference_values: HashMap::new(),
+            id_reference_bindings: HashMap::new(),
         })
     }
 
@@ -1656,24 +1854,72 @@ impl Session {
         lib: Option<&Library>,
         unit_names: &[String],
         indent: Indent,
+    ) -> Result<Session, SessionError> {
+        Self::from_interchange_json_impl(
+            unwrap_flexo(value),
+            lib,
+            unit_names,
+            indent,
+            GraphFormat::LegacyV2,
+        )
+    }
+
+    /// Load interchange under an explicitly selected lowering/identity contract.
+    /// JSON carries no contract header; callers must retain this choice with the
+    /// document. Legacy payloads require migration before selecting canonical.
+    pub fn from_interchange_json_with_graph_format(
+        value: &serde_json::Value,
+        lib: Option<&Library>,
+        unit_names: &[String],
+        indent: Indent,
+        format: GraphFormat,
     ) -> Result<Session, SessionError> {
         let value = unwrap_flexo(value);
+        sysmlv2_model::migration::validate_conditional_graph_format(&value, format).map_err(
+            |message| SessionError::Parse {
+                unit: "<interchange>".into(),
+                diagnostics: vec![Diagnostic::error(Span::default(), message)],
+            },
+        )?;
+        let mut session = Self::from_interchange_json_impl(value, lib, unit_names, indent, format)?;
+        session.enforce_graph_format = true;
+        Ok(session)
+    }
+
+    fn from_interchange_json_impl(
+        value: serde_json::Value,
+        lib: Option<&Library>,
+        unit_names: &[String],
+        indent: Indent,
+        format: GraphFormat,
+    ) -> Result<Session, SessionError> {
         let mut warnings = Vec::new();
         // Library ids are named through the same map the CLI seeds for
         // its JSON → text conversion.
-        let mut names = match lib {
+        let reference_hints = lib.map(|_| sysmlv2_model::loader::id_reference_bindings(&value));
+        let referenced = reference_hints
+            .as_ref()
+            .into_iter()
+            .flat_map(|hints| hints.values().copied())
+            .collect();
+        let (mut names, identity_fallbacks) = match lib {
             Some(l) => {
-                let mut model = Model::new();
+                let mut model = Model::with_graph_format(format);
                 let cache_path = load_library_into(&mut model, l)?;
-                let names = sysmlv2_model::json::library_name_map(&model);
+                let names = sysmlv2_model::json::library_reference_names(&model, &referenced);
                 if let (Some(path), Some(cache)) = (cache_path, model.take_recorded_library_cache())
                 {
                     let _ = cache.save(&path);
                 }
                 names
             }
-            None => Default::default(),
+            None => (HashMap::new(), HashSet::new()),
         };
+        let strict_id_bindings = !identity_fallbacks.is_empty();
+        let mut lift_names = names.clone();
+        for id in &identity_fallbacks {
+            lift_names.remove(id);
+        }
         // split_documents handles multi-root lists; a single-document
         // payload still carries its Flexo name on the root — extract it
         // the same way, since the unit name prefixes every ownership
@@ -1681,19 +1927,20 @@ impl Session {
         let docs: Vec<(Option<String>, serde_json::Value)> =
             sysmlv2_model::lift::split_documents(&value)
                 .unwrap_or_else(|| vec![(single_root_name(&value), value.clone())]);
-        names.extend(sysmlv2_model::lift::document_reference_name_map(&value));
+        let document_names = sysmlv2_model::lift::document_reference_name_map(&value);
+        names.extend(document_names.clone());
+        lift_names.extend(document_names);
         let mut sources = Vec::with_capacity(docs.len());
         for (i, (root_name, doc)) in docs.iter().enumerate() {
             let unit_name = unit_names
                 .get(i)
                 .cloned()
                 .unwrap_or_else(|| doc_unit_name(root_name.as_deref(), i));
-            let lifted = sysmlv2_model::lift::from_compact_json_with_names(doc, &names).map_err(
-                |message| SessionError::Parse {
+            let lifted = sysmlv2_model::lift::from_compact_json_with_names(doc, &lift_names)
+                .map_err(|message| SessionError::Parse {
                     unit: unit_name.clone(),
                     diagnostics: vec![Diagnostic::error(Span::default(), message)],
-                },
-            )?;
+                })?;
             warnings.extend(lifted.errors);
             // Lifted doc/comment bodies are dedented (interchange
             // normalization stripped their margins) — re-lay them.
@@ -1709,7 +1956,7 @@ impl Session {
                 ),
             ));
         }
-        let (model, mut resolved, unit_offset) = rebuild(&sources, lib)?;
+        let (model, mut resolved, unit_offset) = rebuild(&sources, lib, format, None)?;
         // Explicit ids: pair the loaded document's elements with the
         // rebuilt model's by ownership path (roots by document order),
         // and keep every id the document carried that the derivation
@@ -1726,16 +1973,37 @@ impl Session {
         let binds_ids = warnings
             .iter()
             .any(|w| w.contains("cannot name reference target"));
-        apply_explicit_ids(&mut resolved, &mut explicit_ids, binds_ids, &mut warnings);
+        let mut id_reference_bindings = if binds_ids {
+            reference_hints.unwrap_or_else(|| sysmlv2_model::loader::id_reference_bindings(&value))
+        } else {
+            HashMap::new()
+        };
+        let mut id_reference_values = HashMap::new();
+        apply_explicit_ids(
+            &mut resolved,
+            &mut explicit_ids,
+            IdBindingMode {
+                enabled: binds_ids,
+                strict: strict_id_bindings,
+                rebound_sites: None,
+            },
+            &mut id_reference_bindings,
+            &mut id_reference_values,
+            &mut warnings,
+        );
         Ok(Session {
             sources,
             lib: lib.cloned(),
             unit_offset,
             model,
+            enforce_graph_format: false,
             resolved,
             warnings,
             explicit_ids,
             binds_ids,
+            strict_id_bindings,
+            id_reference_values,
+            id_reference_bindings,
         })
     }
 
@@ -1752,11 +2020,26 @@ impl Session {
         (v, units)
     }
 
+    // With no lifted identity fallback, every remaining @ref is lexical.
+    // The strict fallback also preserves that distinction through exact slots.
+    // Older payload fallback sessions retain their compatibility interpretation.
+    fn uses_lexical_references(&self) -> bool {
+        self.strict_id_bindings || !self.binds_ids
+    }
+
     fn overlay(&self, v: &mut serde_json::Value) {
         if self.explicit_ids.is_empty() && !self.binds_ids {
             return;
         }
-        sysmlv2_model::loader::overlay_explicit_ids(v, &self.explicit_ids);
+        if self.uses_lexical_references() {
+            sysmlv2_model::loader::overlay_payload_ids(
+                v,
+                &self.explicit_ids,
+                &self.id_reference_values,
+            );
+        } else {
+            sysmlv2_model::loader::overlay_explicit_ids(v, &self.explicit_ids);
+        }
     }
 
     /// Whether the session holds **explicit ids** — ids the loaded
@@ -1789,11 +2072,28 @@ impl Session {
     /// [`Self::load_library`] over any [`Library`] source — in-memory
     /// `(unit name, text)` library units included (the WASM shape).
     pub fn load_library_from(&mut self, lib: Library) -> Result<(), SessionError> {
-        let (model, mut resolved, unit_offset) = rebuild(&self.sources, Some(&lib))?;
+        let (model, mut resolved, unit_offset) = rebuild(
+            &self.sources,
+            Some(&lib),
+            self.model.graph_format(),
+            self.model.settled_outcomes(),
+        )?;
+        let rebound_sites: Vec<_> = self
+            .resolved
+            .bound_id_reference_sites()
+            .into_iter()
+            .filter_map(|(u, s, id)| Some((u.checked_sub(self.unit_offset)? + unit_offset, s, id)))
+            .collect();
         apply_explicit_ids(
             &mut resolved,
             &mut self.explicit_ids,
-            self.binds_ids,
+            IdBindingMode {
+                enabled: self.binds_ids,
+                strict: self.strict_id_bindings,
+                rebound_sites: Some(&rebound_sites),
+            },
+            &mut self.id_reference_bindings,
+            &mut self.id_reference_values,
             &mut self.warnings,
         );
         self.lib = Some(lib);
@@ -1829,7 +2129,17 @@ impl Session {
         // each unit root's element index paired with its source path —
         // so decoders can lay the model back out as its original files.
         let (json, units) = self.compact_json_with_units_overlaid();
-        if self.has_explicit_ids() {
+        if self.model.graph_format() == GraphFormat::CanonicalV3 {
+            if self.has_explicit_ids() {
+                sysmlv2_cbor::to_compact_cbor_explicit_with_format(
+                    &json,
+                    &units,
+                    self.model.graph_format(),
+                )
+            } else {
+                sysmlv2_cbor::to_compact_cbor_with_format(&json, &units, self.model.graph_format())
+            }
+        } else if self.has_explicit_ids() {
             sysmlv2_cbor::to_compact_cbor_with_units_explicit(&json, &units)
         } else {
             sysmlv2_cbor::to_compact_cbor_with_units(&json, &units)
@@ -1861,11 +2171,20 @@ impl Session {
         }
         let names = self.library_id_names();
         let (json, units) = self.compact_json_with_units_overlaid();
-        Ok(sysmlv2_cbor::to_compact_cbor_elided_with_units(
-            &json,
-            &|s| names.get(s).cloned(),
-            &units,
-        )
+        Ok(if self.model.graph_format() == GraphFormat::CanonicalV3 {
+            sysmlv2_cbor::to_compact_cbor_elided_with_format(
+                &json,
+                &|s| names.get(s).cloned(),
+                &units,
+                self.model.graph_format(),
+            )
+        } else {
+            sysmlv2_cbor::to_compact_cbor_elided_with_units(
+                &json,
+                &|s| names.get(s).cloned(),
+                &units,
+            )
+        }
         .expect("session compact form is covered by the codec tables"))
     }
 
@@ -1879,6 +2198,7 @@ impl Session {
         base: &serde_json::Value,
         portable: bool,
     ) -> Result<Vec<u8>, SessionError> {
+        self.check_graph_document(base)?;
         // One emission feeds both the target and its unit table so the
         // indices line up by construction. Unit paths ride strict
         // deltas only — portable result indices are not exact.
@@ -1888,6 +2208,7 @@ impl Session {
             base,
             &target,
             &sysmlv2_cbor::DeltaOptions::new()
+                .with_graph_format(self.model.graph_format())
                 .with_portable(portable)
                 .with_units(units),
         )
@@ -1905,6 +2226,7 @@ impl Session {
         &self,
         base: &serde_json::Value,
     ) -> Result<Vec<u8>, SessionError> {
+        self.check_graph_document(base)?;
         // Same policy as the elided snapshot: an explicit-id session
         // produces no elided form.
         if self.has_explicit_ids() {
@@ -1915,7 +2237,9 @@ impl Session {
         sysmlv2_cbor::delta_compact_cbor_elided(
             base,
             &target,
-            &sysmlv2_cbor::DeltaOptions::new().with_units(units),
+            &sysmlv2_cbor::DeltaOptions::new()
+                .with_graph_format(self.model.graph_format())
+                .with_units(units),
             &|s| names.get(s).cloned(),
         )
         .map_err(SessionError::Cbor)
@@ -1950,8 +2274,30 @@ impl Session {
     /// with their pointed message — apply those with
     /// [`Self::apply_delta_cbor`].
     pub fn decode_cbor(&self, bytes: &[u8]) -> Result<serde_json::Value, SessionError> {
+        self.check_cbor_graph_format(bytes)?;
         let names = self.library_id_names();
-        sysmlv2_cbor::from_cbor_with(bytes, &|s| names.get(s).cloned()).map_err(SessionError::Cbor)
+        let value = sysmlv2_cbor::from_cbor_with(bytes, &|s| names.get(s).cloned())?;
+        self.check_graph_document(&value)?;
+        Ok(value)
+    }
+
+    fn check_graph_document(&self, value: &serde_json::Value) -> Result<(), SessionError> {
+        if !self.enforce_graph_format {
+            return Ok(());
+        }
+        sysmlv2_model::migration::validate_conditional_graph_format(
+            value,
+            self.model.graph_format(),
+        )
+        .map_err(|message| SessionError::Parse {
+            unit: "<interchange>".into(),
+            diagnostics: vec![Diagnostic::error(Span::default(), message)],
+        })
+    }
+
+    fn check_cbor_graph_format(&self, bytes: &[u8]) -> Result<(), SessionError> {
+        sysmlv2_cbor::assert_graph_format(bytes, self.model.graph_format())
+            .map_err(SessionError::Cbor)
     }
 
     /// Apply a delta payload against this session's model, returning
@@ -1983,7 +2329,9 @@ impl Session {
         base: &serde_json::Value,
         lenient: bool,
     ) -> Result<(serde_json::Value, sysmlv2_cbor::ApplyReport), SessionError> {
-        if lenient {
+        self.check_graph_document(base)?;
+        self.check_cbor_graph_format(bytes)?;
+        let result = if lenient {
             sysmlv2_cbor::apply_delta_cbor_lenient(bytes, base).map_err(SessionError::Cbor)
         } else {
             let names = self.library_id_names();
@@ -1992,7 +2340,9 @@ impl Session {
             // returned report always has base_matched.
             sysmlv2_cbor::apply_delta_cbor_report_with(bytes, base, &|s| names.get(s).cloned())
                 .map_err(SessionError::Cbor)
-        }
+        }?;
+        self.check_graph_document(&result.0)?;
+        Ok(result)
     }
 
     /// Open a session over a compact-form CBOR payload — the binary
@@ -2029,10 +2379,15 @@ impl Session {
         indent: Indent,
     ) -> Result<Session, SessionError> {
         let (value, units) = sysmlv2_cbor::from_compact_cbor_units(bytes)?;
+        let format = sysmlv2_cbor::graph_format(bytes)?;
         // Payloads carrying their unit structure restore the model's
         // original file layout: unit-path order is document order.
         let unit_names: Vec<String> = units.into_iter().map(|(_, path)| path).collect();
-        Self::from_interchange_json_indented(&value, lib, &unit_names, indent)
+        if format == GraphFormat::LegacyV2 {
+            Self::from_interchange_json_indented(&value, lib, &unit_names, indent)
+        } else {
+            Self::from_interchange_json_with_graph_format(&value, lib, &unit_names, indent, format)
+        }
     }
 
     /// Emit the session's model as full interchange JSON (derived
@@ -2041,12 +2396,56 @@ impl Session {
         self.to_full_json_with(true)
     }
 
+    /// Full-form export through checked specification-name property reads.
+    /// Refuses unavailable or approximate fields without emitting placeholders.
+    /// Explicit IDs and the session's closure policy are preserved.
+    pub fn to_full_json_strict(
+        &mut self,
+    ) -> Result<serde_json::Value, sysmlv2_model::json::SemanticExportError> {
+        self.resolved.to_full_json_strict()
+    }
+
     /// [`Self::to_full_json`] with unresolved-reference recovery
     /// annotations: when `recover_refs` is set, every reference that
     /// serializes as a dangling id also carries its source spelling, so
     /// a partial model survives emit → lift losslessly (the Flexo
     /// change-record path).
     pub fn to_full_json_with(&self, recover_refs: bool) -> serde_json::Value {
+        if self.uses_lexical_references() {
+            let mut resolved = ResolvedModel::build(&self.model);
+            let mut ids = self.explicit_ids.clone();
+            let mut bindings = self.id_reference_bindings.clone();
+            let mut values = self.id_reference_values.clone();
+            let mut warnings = Vec::new();
+            let sites = self.resolved.bound_id_reference_sites();
+            apply_explicit_ids(
+                &mut resolved,
+                &mut ids,
+                IdBindingMode {
+                    enabled: self.binds_ids,
+                    strict: true,
+                    rebound_sites: Some(&sites),
+                },
+                &mut bindings,
+                &mut values,
+                &mut warnings,
+            );
+            let compact = self.compact_json_overlaid();
+            return sysmlv2_model::full::resolved_compact_to_full_json(
+                &mut resolved,
+                &self.model,
+                compact,
+                sysmlv2_model::full::EmissionPolicy {
+                    unresolved: if recover_refs {
+                        sysmlv2_model::full::UnresolvedReferencePolicy::Preserve
+                    } else {
+                        sysmlv2_model::full::UnresolvedReferencePolicy::LegacyDanglingId
+                    },
+                    closures: Default::default(),
+                },
+            )
+            .expect("the boolean compatibility policies cannot reject");
+        }
         let mut v = sysmlv2_model::full::model_to_full_json_with(&self.model, recover_refs);
         self.overlay(&mut v);
         v
@@ -2082,7 +2481,7 @@ impl Session {
             })
             .collect();
         full_units.sort_by_key(|&(i, _)| i);
-        sysmlv2_cbor::to_full_cbor_with_units(&full, &full_units)
+        sysmlv2_cbor::to_full_cbor_with_format(&full, &full_units, self.model.graph_format())
             .expect("session full form is covered by the codec tables")
     }
 
@@ -2473,18 +2872,66 @@ impl Session {
         // site keeps its original spelling.)
         let sites: Vec<RefSite> = self.resolved.reference_sites().to_vec();
         // Primary sites (qualifier twins share the primary's span),
-        // sorted for chain-adjacency detection. Import targets resolve
-        // under their own rules (not `plain`), but they still respell
-        // safely: the plain resolver picks the candidate heuristically
-        // and the reparse verification below is the actual gate — a
-        // candidate the import rules read differently fails it and the
-        // site keeps its printed spelling.
-        let import_site =
-            |s: &RefSite| matches!(s.kind.as_str(), "importedNamespace" | "importedMembership");
+        // sorted for chain-adjacency detection. An import site's target
+        // names either a *namespace* — a package, via `Pkg::*`
+        // (`kind == "importedNamespace"`, `plain: false`) or `Pkg::**`
+        // (`kind == "importedMembership"`, `plain: true`, distinguished
+        // from a member import below only by the literal `::**` right
+        // after the site's span — the site itself spans just the package
+        // path, so the trailing stars are fixed text the splice never
+        // touches) — or one *specific member*, via `Pkg::member;`
+        // (`kind == "importedMembership"`, naming that one element).
+        //
+        // A namespace import's own target resolves safely: the package it
+        // names is reachable by plain lexical scoping on its own (it's an
+        // ordinarily-nested or top-level member), with no help from the
+        // import being tested, so a shorter candidate for it is never
+        // circular — this is the common, desired case (`$::Pkg::*`
+        // shortens to `Pkg::*`).
+        //
+        // A member import is different: its whole purpose is to make that
+        // one specific last segment resolve bare from its owning scope, so
+        // the generic "does a shorter suffix resolve here" probe always
+        // answers yes for it — via the very import being tested — no
+        // matter how deep the real path is. That produced a nonsensical
+        // self-referential rewrite (`import Pkg::Member;` collapsing to
+        // `import Member;`, which resolves nothing once reparsed) and,
+        // because the reparse-verify pass below bans whichever candidates
+        // shared that reparse batch, it was also silently taking down
+        // unrelated sibling references that only depend on the untouched
+        // import resolving correctly. So a member import's own target is
+        // never a respell candidate; leaving its text alone keeps
+        // `entry.target` intact for every other site, which is all those
+        // sites ever needed.
+        let is_recursive_namespace_import = |s: &RefSite| {
+            s.kind == "importedMembership"
+                && self.sources[s.unit - self.unit_offset]
+                    .1
+                    .get(s.span.end as usize..)
+                    .is_some_and(|rest| rest.starts_with("::**"))
+        };
+        let namespace_import_site =
+            |s: &RefSite| s.kind == "importedNamespace" || is_recursive_namespace_import(s);
+        let member_import_site =
+            |s: &RefSite| s.kind == "importedMembership" && !is_recursive_namespace_import(s);
+        // A feature-chain member (e.g. a flow endpoint like
+        // `a.b.c`) is recorded with `plain: false` (json.rs) precisely
+        // because it isn't independently resolvable — the chain-grouping
+        // pass below is what respells these safely, atomically, as a
+        // whole run. Excluding every non-plain, non-import site here
+        // (as if only `plain`/import sites existed) filtered chain
+        // members out before that pass ever saw them, so the lift's
+        // `$::`-rooted chain spelling (see `lift.rs`) was never
+        // shortened. `chain_root.is_some()` is exactly the marker
+        // json.rs sets for a resolvable chain member, so admit those too.
+        let chain_site = |s: &RefSite| s.chain_root.is_some();
         let mut primaries: Vec<&RefSite> = Vec::new();
         let mut seen: HashSet<(usize, u32, u32)> = HashSet::new();
         for s in &sites {
-            if (!s.plain && !import_site(s)) || s.kind == "qualifier" || s.unit < self.unit_offset {
+            if !s.plain && !chain_site(s) && !namespace_import_site(s) {
+                continue;
+            }
+            if member_import_site(s) || s.kind == "qualifier" || s.unit < self.unit_offset {
                 continue;
             }
             if seen.insert((s.unit, s.span.start, s.span.end)) {
@@ -2637,17 +3084,66 @@ impl Session {
                 out.push_str(&src[cursor..]);
                 new_src.1 = out;
             }
-            let (new_model, mut new_resolved, _off) = rebuild(&new_sources, self.lib.as_ref())
-                .map_err(|e| match e {
-                    SessionError::Parse { unit, diagnostics } => {
-                        TransformError::ReparseFailed { unit, diagnostics }
+            let (new_model, mut new_resolved, _off) = rebuild(
+                &new_sources,
+                self.lib.as_ref(),
+                self.model.graph_format(),
+                self.model.settled_outcomes(),
+            )
+            .map_err(|e| match e {
+                SessionError::Parse { unit, diagnostics } => {
+                    TransformError::ReparseFailed { unit, diagnostics }
+                }
+                // rebuild() reparses text — only Io is reachable here.
+                e => TransformError::ReparseFailed {
+                    unit: "<library>".into(),
+                    diagnostics: vec![Diagnostic::error(Span::default(), e.to_string())],
+                },
+            })?;
+            // Check the same identity-bound graph that would be committed.
+            // Keep overlay changes transactional until all checks succeed.
+            let mut next_ids = self.explicit_ids.clone();
+            let mut next_warnings = self.warnings.clone();
+            let mut next_bindings = self.id_reference_bindings.clone();
+            let mut next_values = self.id_reference_values.clone();
+            let rebound_sites: Vec<_> = self
+                .resolved
+                .bound_id_reference_sites()
+                .into_iter()
+                .filter_map(|(unit, span, id)| {
+                    if active
+                        .iter()
+                        .any(|c| c.unit == unit && c.start < span.end && c.end > span.start)
+                    {
+                        return None;
                     }
-                    // rebuild() reparses text — only Io is reachable here.
-                    e => TransformError::ReparseFailed {
-                        unit: "<library>".into(),
-                        diagnostics: vec![Diagnostic::error(Span::default(), e.to_string())],
-                    },
-                })?;
+                    let delta: i64 = active
+                        .iter()
+                        .filter(|c| c.unit == unit && c.end <= span.start)
+                        .map(|c| c.text.len() as i64 - (c.end - c.start) as i64)
+                        .sum();
+                    Some((
+                        unit,
+                        Span {
+                            start: (span.start as i64 + delta) as u32,
+                            end: (span.end as i64 + delta) as u32,
+                        },
+                        id,
+                    ))
+                })
+                .collect();
+            apply_explicit_ids(
+                &mut new_resolved,
+                &mut next_ids,
+                IdBindingMode {
+                    enabled: self.binds_ids,
+                    strict: self.strict_id_bindings,
+                    rebound_sites: Some(&rebound_sites),
+                },
+                &mut next_bindings,
+                &mut next_values,
+                &mut next_warnings,
+            );
             let post_sites: Vec<RefSite> = new_resolved.reference_sites().to_vec();
             let mut post_by_span: HashMap<(usize, u32, u32), ElementRef> = HashMap::new();
             for s in &post_sites {
@@ -2722,12 +3218,10 @@ impl Session {
             }
             report.respelled = active.len();
             self.sources = new_sources;
-            apply_explicit_ids(
-                &mut new_resolved,
-                &mut self.explicit_ids,
-                self.binds_ids,
-                &mut self.warnings,
-            );
+            self.explicit_ids = next_ids;
+            self.id_reference_bindings = next_bindings;
+            self.id_reference_values = next_values;
+            self.warnings = next_warnings;
             self.model = new_model;
             let policy = self.resolved.closure_policy();
             self.resolved = new_resolved;
@@ -2898,8 +3392,8 @@ pub enum SplitNaming {
 pub struct SplitOptions {
     pub naming: SplitNaming,
     /// Directory (unit-name prefix) for the new units; by default the
-    /// root's unit name without its extension (`models/TMT.sysml` →
-    /// `models/TMT`).
+    /// root's unit name without its extension (`models/Rover.sysml` →
+    /// `models/Rover`).
     pub directory: Option<String>,
     /// Unit names are URIs (an editor's workspace): the new units' file
     /// segments are percent-encoded the way editors spell a path
@@ -3355,6 +3849,10 @@ struct Planner<'s> {
     /// Pre-commit spans whose *contents* are edited or removed — old
     /// sites inside them carry no expectation.
     consumed: Vec<(usize, Span)>,
+    /// Operations explicitly replacing/deleting old reference text release its
+    /// payload identity evidence. Relocations must carry it or refuse instead.
+    released_identity_ranges: Vec<(usize, Span)>,
+    moved_identity_sites: Vec<MovedIdentitySites>,
     /// Reference sites carried inside moved text (`move_member`), to be
     /// re-verified at their post-insert positions.
     moved_expects: Vec<MovedExpects>,
@@ -3386,6 +3884,16 @@ struct Planner<'s> {
 /// after the commit sorts/dedups) plus each site's (offset within the
 /// splice text, length, pre-commit target qualified name; `None` =
 /// only require that it resolves).
+/// Exact byte provenance for unchanged UUID tokens copied by move_member.
+/// Unlike MovedExpects this preserves identity, including anonymous targets.
+struct MovedIdentitySites {
+    source_unit: usize,
+    unit: usize,
+    at: u32,
+    text: String,
+    sites: Vec<(Span, u32, Uuid)>,
+}
+
 struct MovedExpects {
     unit: usize,
     at: u32,
@@ -3400,6 +3908,8 @@ impl<'s> Planner<'s> {
             splices: Vec::new(),
             correspondence: Vec::new(),
             consumed: Vec::new(),
+            released_identity_ranges: Vec::new(),
+            moved_identity_sites: Vec::new(),
             moved_expects: Vec::new(),
             refuse_new_unresolved: false,
             projection_subjects: Vec::new(),
@@ -3679,6 +4189,7 @@ impl<'s> Planner<'s> {
                 .or_else(|| r.member_extent(e))
                 .ok_or(TransformError::NoEditableValue(e))?;
             self.consumed.push((unit, old.span));
+            self.released_identity_ranges.push((unit, old.span));
             self.splices.push(Splice {
                 unit,
                 start: old.span.start,
@@ -3726,6 +4237,7 @@ impl<'s> Planner<'s> {
             [(unit, span)] => {
                 // Replace the written clause in place.
                 self.consumed.push((*unit, *span));
+                self.released_identity_ranges.push((*unit, *span));
                 self.splices.push(Splice {
                     unit: *unit,
                     start: span.start,
@@ -3935,6 +4447,7 @@ impl<'s> Planner<'s> {
         let cut = cut_whole_lines(self.user_src(unit, e)?, extent);
         let (start, end) = (cut.start, cut.end);
         self.consumed.push((unit, cut));
+        self.released_identity_ranges.push((unit, cut));
         self.splices.push(Splice {
             unit,
             start,
@@ -4001,6 +4514,7 @@ impl<'s> Planner<'s> {
         // the old text, and untouched-site verification skips them.
         self.consumed
             .push((unit, Span::new(extent.start, extent.end)));
+        self.released_identity_ranges.push((unit, extent));
         self.splices.push(Splice {
             unit,
             start: extent.start,
@@ -4080,6 +4594,7 @@ impl<'s> Planner<'s> {
             .ok_or(TransformError::AnonymousTarget(to))?;
         let last_len = qn.rsplit("::").next().unwrap_or(&qn).len() as u32;
         self.consumed.push((site.unit, site.span));
+        self.released_identity_ranges.push((site.unit, site.span));
         self.splices.push(Splice {
             unit: site.unit,
             start: site.span.start,
@@ -4102,6 +4617,7 @@ impl<'s> Planner<'s> {
         index: Option<usize>,
     ) -> Result<(), TransformError> {
         let unit_offset = self.session.unit_offset;
+        let strict_identity = self.session.strict_id_bindings;
         let r = self.session.resolved();
         let (unit, extent) = r.member_extent(e).ok_or(TransformError::NoExtent(e))?;
         if unit < unit_offset {
@@ -4164,6 +4680,18 @@ impl<'s> Planner<'s> {
                 .collect()
         };
 
+        let identity_sites: Vec<_> = if strict_identity {
+            r.bound_id_reference_sites()
+                .into_iter()
+                .filter(|&(u, span, _)| {
+                    u == unit && span.start >= extent.start && span.end <= extent.end
+                })
+                .map(|(_, span, id)| (span, span.start - extent.start, id))
+                .collect()
+        } else {
+            Vec::new()
+        };
+
         // Excise, with remove's whitespace discipline (no stranding
         // check — the text comes back; verification decides what broke).
         let src = self.user_src(unit, e)?;
@@ -4213,6 +4741,22 @@ impl<'s> Planner<'s> {
                 _ => return Err(TransformError::NoExtent(new_owner)),
             }
         };
+        if !identity_sites.is_empty() {
+            let prefix = ins_text
+                .find(&member_text)
+                .expect("move insertion contains the unchanged member")
+                as u32;
+            self.moved_identity_sites.push(MovedIdentitySites {
+                source_unit: unit,
+                unit: dunit,
+                at: ins_start,
+                text: ins_text.clone(),
+                sites: identity_sites
+                    .into_iter()
+                    .map(|(span, off, id)| (span, off + prefix, id))
+                    .collect(),
+            });
+        }
         if !inner_sites.is_empty() {
             let prefix = ins_text
                 .find(&member_text)
@@ -5058,19 +5602,23 @@ impl<'s> Planner<'s> {
             }
         }
         // Reparse + rebuild (rollback = return before swapping state).
-        let (new_model, mut new_resolved, unit_offset) =
-            rebuild(&new_sources, self.session.lib.as_ref()).map_err(|e| match e {
-                SessionError::Parse { unit, diagnostics } => {
-                    TransformError::ReparseFailed { unit, diagnostics }
-                }
-                // rebuild() reparses text — only Io is reachable here.
-                e => TransformError::ReparseFailed {
-                    unit: "<library>".into(),
-                    diagnostics: vec![Diagnostic::error(Span::default(), e.to_string())],
-                },
-            })?;
+        let (new_model, mut new_resolved, unit_offset) = rebuild(
+            &new_sources,
+            self.session.lib.as_ref(),
+            self.session.model.graph_format(),
+            self.session.model.settled_outcomes(),
+        )
+        .map_err(|e| match e {
+            SessionError::Parse { unit, diagnostics } => {
+                TransformError::ReparseFailed { unit, diagnostics }
+            }
+            // rebuild() reparses text — only Io is reachable here.
+            e => TransformError::ReparseFailed {
+                unit: "<library>".into(),
+                diagnostics: vec![Diagnostic::error(Span::default(), e.to_string())],
+            },
+        })?;
         debug_assert_eq!(unit_offset, self.session.unit_offset);
-
         // Offset mapping per unit: position -> post-commit position, or
         // None inside an edited range. A pure insertion (start == end)
         // sits *between* tokens: a span ending exactly there keeps its
@@ -5089,6 +5637,120 @@ impl<'s> Planner<'s> {
             }
             Some((pos as i64 + delta) as u32)
         };
+        // Resolve lifted identity references before semantic checks. Failed
+        // commits and dry runs must not retire ids or change session warnings.
+        let mut next_ids = self.session.explicit_ids.clone();
+        let mut next_warnings = self.session.warnings.clone();
+        let mut next_bindings = self.session.id_reference_bindings.clone();
+        let mut next_values = self.session.id_reference_values.clone();
+        let old_identity_sites = self.session.resolved.bound_id_reference_sites();
+        let known_identity_targets: HashSet<_> = if self.session.strict_id_bindings {
+            old_identity_sites
+                .iter()
+                .filter_map(|(_, _, id)| {
+                    self.session
+                        .resolved
+                        .element_by_id(&id.to_string())
+                        .map(|_| *id)
+                })
+                .collect()
+        } else {
+            HashSet::new()
+        };
+        let mut moved = HashMap::new();
+        if self.session.strict_id_bindings {
+            for carried in &self.moved_identity_sites {
+                let Some(index) = self.splices.iter().position(|splice| {
+                    splice.unit == carried.unit
+                        && splice.start == carried.at
+                        && splice.text == carried.text
+                }) else {
+                    continue;
+                };
+                for &(source, offset, id) in &carried.sites {
+                    let destination = Span::new(
+                        new_positions[index] + offset,
+                        new_positions[index] + offset + source.len(),
+                    );
+                    let key = (carried.source_unit, source.start, source.end, id);
+                    if moved.insert(key, (carried.unit, destination, id)).is_some() {
+                        return Err(TransformError::SemanticIdentity {
+                            broken: vec![format!(
+                                "payload identity reference {id} has ambiguous move provenance"
+                            )],
+                        });
+                    }
+                }
+            }
+        }
+        let mut rebound_sites = Vec::new();
+        for (unit, span, id) in old_identity_sites {
+            if self.session.strict_id_bindings {
+                if self.released_identity_ranges.iter().any(|&(u, range)| {
+                    u == unit && span.start >= range.start && span.end <= range.end
+                }) {
+                    continue;
+                }
+                if let Some(&destination) = moved.get(&(unit, span.start, span.end, id)) {
+                    rebound_sites.push(destination);
+                    continue;
+                }
+                if self.consumed.iter().any(|&(u, range)| {
+                    u == unit && span.start >= range.start && span.end <= range.end
+                }) {
+                    return Err(TransformError::SemanticIdentity {
+                        broken: vec![format!(
+                            "payload identity reference {id} at unit {unit} bytes {}..{} cannot be carried through this relocation",
+                            span.start, span.end
+                        )],
+                    });
+                }
+            }
+            match (shift(unit, span.start, false), shift(unit, span.end, true)) {
+                (Some(start), Some(end)) => rebound_sites.push((unit, Span::new(start, end), id)),
+                _ if self.session.strict_id_bindings => {
+                    return Err(TransformError::SemanticIdentity {
+                        broken: vec![format!(
+                            "payload identity reference {id} was consumed without replacement or move provenance"
+                        )],
+                    });
+                }
+                _ => {}
+            }
+        }
+        apply_explicit_ids(
+            &mut new_resolved,
+            &mut next_ids,
+            IdBindingMode {
+                enabled: self.session.binds_ids,
+                strict: self.session.strict_id_bindings,
+                rebound_sites: Some(&rebound_sites),
+            },
+            &mut next_bindings,
+            &mut next_values,
+            &mut next_warnings,
+        );
+
+        if self.session.strict_id_bindings {
+            let rebound: HashSet<_> = new_resolved
+                .bound_id_reference_sites()
+                .into_iter()
+                .map(|(unit, span, id)| (unit, span.start, span.end, id))
+                .collect();
+            for &(unit, span, id) in &rebound_sites {
+                if !rebound.contains(&(unit, span.start, span.end, id))
+                    || (known_identity_targets.contains(&id)
+                        && new_resolved.element_by_id(&id.to_string()).is_none())
+                {
+                    return Err(TransformError::SemanticIdentity {
+                        broken: vec![format!(
+                            "payload identity reference {id} would lose its target or binding after the edit"
+                        )],
+                    });
+                }
+            }
+        }
+
         let in_consumed = |unit: usize, sp: Span| {
             self.consumed
                 .iter()
@@ -5528,12 +6190,10 @@ impl<'s> Planner<'s> {
         // Success — swap the session to the new state.
         if !dry_run {
             self.session.sources = new_sources;
-            apply_explicit_ids(
-                &mut new_resolved,
-                &mut self.session.explicit_ids,
-                self.session.binds_ids,
-                &mut self.session.warnings,
-            );
+            self.session.explicit_ids = next_ids;
+            self.session.id_reference_bindings = next_bindings;
+            self.session.id_reference_values = next_values;
+            self.session.warnings = next_warnings;
             self.session.model = new_model;
             let policy = self.session.resolved.closure_policy();
             self.session.resolved = new_resolved;
diff --git a/crates/sysmlv2-transform/tests/cardinality_identity.rs b/crates/sysmlv2-transform/tests/cardinality_identity.rs
new file mode 100644
index 0000000..977d2bb
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/cardinality_identity.rs
@@ -0,0 +1,148 @@
+//! Bound references retain valuation identity across interchange spellings.
+use sysmlv2_transform::Session;
+
+fn check(session: &mut Session) {
+    for _ in 0..2 {
+        for owner in ["Child", "Renamed"] {
+            for member in [
+                "header",
+                "body",
+                "qualified",
+                "global",
+                "aliased",
+                "named",
+                "localHeader",
+                "localBody",
+            ] {
+                let name = format!("P::{owner}::{member}");
+                let r = session.resolved();
+                let e = r.resolve_qualified(&name).unwrap();
+                assert_eq!(r.effective_cardinality(e), Some((6, Some(6))), "{name}");
+            }
+        }
+    }
+}
+
+#[test]
+fn bound_valuation_identity_survives_compact_and_full_interchange() {
+    let source = "package P { class Base { feature n default = 4;
+        alias alternate for n;
+        feature header[n]; feature body { multiplicity [n]; }
+        feature qualified { multiplicity [Base::n]; }
+        feature global { multiplicity [$::P::Base::n]; }
+        feature aliased { multiplicity [alternate]; }
+        multiplicity dynamic[n]; feature named { multiplicity subsets dynamic; }
+    }
+    class Child specializes Base { feature redefines n = 6;
+        feature localHeader[Base::n]; feature localBody { multiplicity [Base::n]; }
+        feature redefines header; feature redefines body; feature redefines qualified;
+        feature redefines global; feature redefines aliased; feature redefines named;
+    }
+    class Renamed specializes Base { feature other redefines n = 6;
+        feature localHeader[Base::n]; feature localBody { multiplicity [Base::n]; }
+        feature redefines header; feature redefines body; feature redefines qualified;
+        feature redefines global; feature redefines aliased; feature redefines named;
+    } }";
+    let mut original = Session::from_sources(vec![("p.kerml".into(), source.into())]).unwrap();
+    check(&mut original);
+    for json in [
+        original.to_compact_json(),
+        original.to_full_json_with(false),
+    ] {
+        let mut loaded =
+            Session::from_interchange_json_named(&json, None, &["p.kerml".into()]).unwrap();
+        check(&mut loaded);
+    }
+}
+
+#[test]
+fn bound_formula_dependencies_survive_compact_and_full_interchange() {
+    let source = "package P { feature external = 2;
+        class Base { feature n default = 3; alias alternate for n;
+            feature formula = alternate + external;
+            feature second = $::P::Base::formula * 2;
+            feature header[second]; feature directCount = n + 1; feature direct[directCount];
+            feature body { multiplicity [second]; }
+            multiplicity dynamic[second]; feature named { multiplicity subsets dynamic; }
+        }
+        class Child specializes Base { feature other redefines n = 6;
+            feature external = 100;
+            feature redefines header; feature redefines direct;
+            feature redefines body; feature redefines named;
+        }
+    }";
+    fn check(session: &mut Session) {
+        for _ in 0..2 {
+            for (owner, value) in [("Child", 16), ("Base", 10)] {
+                for member in ["header", "body", "named"] {
+                    let name = format!("P::{owner}::{member}");
+                    let r = session.resolved();
+                    let e = r.resolve_qualified(&name).unwrap();
+                    assert_eq!(
+                        r.effective_cardinality(e),
+                        Some((value, Some(value))),
+                        "{name}"
+                    );
+                }
+            }
+            let r = session.resolved();
+            let direct = r.resolve_qualified("P::Child::direct").unwrap();
+            assert_eq!(r.effective_cardinality(direct), Some((7, Some(7))));
+        }
+    }
+    let mut original =
+        Session::from_sources(vec![("formulas.kerml".into(), source.into())]).unwrap();
+    check(&mut original);
+    for json in [
+        original.to_compact_json(),
+        original.to_full_json_with(false),
+    ] {
+        let mut loaded =
+            Session::from_interchange_json_named(&json, None, &["formulas.kerml".into()]).unwrap();
+        check(&mut loaded);
+    }
+}
+
+#[test]
+fn provider_proofs_preserve_header_body_and_interchange_reference_identity() {
+    let source = "package Good { feature n = 4; }
+        package P { public import Good::*; public import absent::*;
+            feature header[n]; feature body { multiplicity [n]; }
+        }
+        class Base { public import Good::*; feature n default = 3;
+            feature header[n]; feature body { multiplicity [n]; }
+        }
+        class Child specializes Base { feature other redefines n = 6;
+            feature redefines header; feature redefines body;
+        }
+        class Bad specializes Base { public import absent::*;
+            feature redefines header; feature redefines body;
+        }";
+    fn check(session: &mut Session) {
+        for _ in 0..2 {
+            for (owner, expected) in [
+                ("P", Some((4, Some(4)))),
+                ("Child", Some((6, Some(6)))),
+                ("Bad", None),
+            ] {
+                for member in ["header", "body"] {
+                    let name = format!("{owner}::{member}");
+                    let r = session.resolved();
+                    let e = r.resolve_qualified(&name).unwrap();
+                    assert_eq!(r.effective_cardinality(e), expected, "{name}");
+                }
+            }
+        }
+    }
+    let mut original =
+        Session::from_sources(vec![("providers.kerml".into(), source.into())]).unwrap();
+    check(&mut original);
+    for json in [
+        original.to_compact_json(),
+        original.to_full_json_with(false),
+    ] {
+        let mut loaded =
+            Session::from_interchange_json_named(&json, None, &["providers.kerml".into()]).unwrap();
+        check(&mut loaded);
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/exposure_roundtrip.rs b/crates/sysmlv2-transform/tests/exposure_roundtrip.rs
new file mode 100644
index 0000000..84d6f20
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/exposure_roundtrip.rs
@@ -0,0 +1,76 @@
+//! Exposure filters retain their meaning through identity-preserving interchange.
+use serde_json::Value;
+use sysmlv2_transform::Session;
+
+fn exposed_names(full: &Value) -> Vec<String> {
+    let rows = full.as_array().unwrap();
+    let view = rows.iter().find(|e| e["declaredName"] == "v").unwrap();
+    view["exposedElement"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|r| {
+            rows.iter().find(|e| e["@id"] == r["@id"]).unwrap()["qualifiedName"]
+                .as_str()
+                .unwrap()
+                .to_owned()
+        })
+        .collect()
+}
+fn foreign_ids(value: &Value) -> Value {
+    let map: std::collections::HashMap<String, String> = value
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|e| {
+            let id = e["@id"].as_str().unwrap();
+            (
+                id.to_owned(),
+                uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, id.as_bytes()).to_string(),
+            )
+        })
+        .collect();
+    fn rewrite(value: &Value, map: &std::collections::HashMap<String, String>) -> Value {
+        match value {
+            Value::String(s) => Value::String(map.get(s).unwrap_or(s).clone()),
+            Value::Array(a) => Value::Array(a.iter().map(|v| rewrite(v, map)).collect()),
+            Value::Object(o) => Value::Object(
+                o.iter()
+                    .map(|(k, v)| (k.clone(), rewrite(v, map)))
+                    .collect(),
+            ),
+            other => other.clone(),
+        }
+    }
+    rewrite(value, &map)
+}
+
+#[test]
+fn metadata_attribute_exposure_filters_survive_json_and_foreign_id_reload() {
+    for declaration in [
+        "view v {expose Parts::**[@Flag and (as Flag).enabled];}",
+        "view def Filtered {filter @Flag and (as Flag).enabled;} view v:Filtered {expose Parts::**;}",
+    ] {
+        let source = format!(
+            "package P {{ metadata def Flag {{ attribute enabled; }} package Parts {{part yes {{@Flag {{enabled=true;}}}} part no {{@Flag {{enabled=false;}}}}}} {declaration}}}"
+        );
+        let session = Session::from_sources(vec![("exposure.sysml".into(), source)]).unwrap();
+        assert_eq!(
+            exposed_names(&session.to_full_json_with(false)),
+            ["P::Parts::yes"]
+        );
+        let compact = session.to_compact_json();
+        for payload in [&compact, &foreign_ids(&compact)] {
+            let loaded =
+                Session::from_interchange_json_named(payload, None, &["exposure.sysml".into()])
+                    .unwrap();
+            assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+            for _ in 0..2 {
+                assert_eq!(
+                    exposed_names(&loaded.to_full_json_with(false)),
+                    ["P::Parts::yes"]
+                );
+            }
+        }
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/format_transport_adversarial.rs b/crates/sysmlv2-transform/tests/format_transport_adversarial.rs
new file mode 100644
index 0000000..b175b73
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/format_transport_adversarial.rs
@@ -0,0 +1,232 @@
+use std::collections::HashMap;
+use sysmlv2_model::loader::load_document_with_format;
+use sysmlv2_transform::{GraphFormat, Indent, Library, Session};
+
+fn session(format: GraphFormat, conditional: bool, value: usize) -> Session {
+    let expression = if conditional {
+        format!("if true ? {value} else 1/0")
+    } else {
+        value.to_string()
+    };
+    Session::from_sources_with_graph_format(
+        vec![(
+            "model.sysml".into(),
+            format!("package P {{ attribute x = {expression}; }}"),
+        )],
+        None,
+        format,
+    )
+    .unwrap()
+}
+
+#[test]
+fn graph_aware_loaders_refuse_cross_format_conditional_rebuilds() {
+    for (source, target) in [
+        (GraphFormat::LegacyV2, GraphFormat::CanonicalV3),
+        (GraphFormat::CanonicalV3, GraphFormat::LegacyV2),
+    ] {
+        let document = session(source, true, 7).to_compact_json();
+        assert!(
+            Session::from_interchange_json_with_graph_format(
+                &document,
+                None,
+                &["model.sysml".into()],
+                Indent::default(),
+                target,
+            )
+            .is_err(),
+            "a graph contract mismatch must not reassign an operand ID to its wrapper"
+        );
+        assert!(load_document_with_format(&document, &HashMap::new(), target).is_err());
+    }
+}
+
+#[test]
+fn session_snapshot_context_rejects_other_contract_even_without_conditionals() {
+    for (source, target) in [
+        (GraphFormat::LegacyV2, GraphFormat::CanonicalV3),
+        (GraphFormat::CanonicalV3, GraphFormat::LegacyV2),
+    ] {
+        let producer = session(source, false, 7);
+        let receiver = session(target, false, 7);
+        // The graph shapes happen to coincide here. The header, not shape
+        // inference, must keep the selected library/identity context intact.
+        assert_eq!(producer.to_compact_json(), receiver.to_compact_json());
+        for bytes in [
+            producer.to_compact_cbor(),
+            producer.to_compact_cbor_elided().unwrap(),
+            producer.to_full_cbor(false),
+        ] {
+            assert!(receiver.decode_cbor(&bytes).is_err());
+            assert!(producer.decode_cbor(&bytes).is_ok());
+        }
+    }
+}
+
+#[test]
+fn session_delta_context_refuses_cross_contract_strict_elided_and_portable_payloads() {
+    for (source, target) in [
+        (GraphFormat::LegacyV2, GraphFormat::CanonicalV3),
+        (GraphFormat::CanonicalV3, GraphFormat::LegacyV2),
+    ] {
+        let base = session(source, false, 7).to_compact_json();
+        let producer = session(source, false, 8);
+        let receiver = session(target, false, 7);
+        assert_eq!(base, receiver.to_compact_json());
+        for (bytes, lenient) in [
+            (producer.delta_cbor_from(&base, false).unwrap(), false),
+            (producer.delta_cbor_elided_from(&base).unwrap(), false),
+            (producer.delta_cbor_from(&base, true).unwrap(), true),
+        ] {
+            assert!(receiver.apply_delta_cbor(&bytes, lenient).is_err());
+            assert!(
+                receiver
+                    .apply_delta_cbor_to(&bytes, &base, lenient)
+                    .is_err()
+            );
+            assert!(producer.apply_delta_cbor_to(&bytes, &base, lenient).is_ok());
+        }
+    }
+}
+
+#[test]
+fn explicit_legacy_snapshots_keep_historical_scheme_compatibility() {
+    let original = session(GraphFormat::LegacyV2, true, 7);
+    let document = original.to_compact_json();
+    for scheme in [1, 255] {
+        let mut bytes = original.to_compact_cbor();
+        // Eight-byte magic, outer array, uint64 header; scheme byte at 16.
+        bytes[16] = scheme;
+        assert_eq!(sysmlv2_cbor::from_compact_cbor(&bytes).unwrap(), document);
+        assert_eq!(original.decode_cbor(&bytes).unwrap(), document);
+        let replay = Session::from_compact_cbor(&bytes).unwrap();
+        assert_eq!(replay.model().graph_format(), GraphFormat::LegacyV2);
+        assert_eq!(replay.to_compact_json(), document);
+        assert!(
+            session(GraphFormat::CanonicalV3, true, 7)
+                .decode_cbor(&bytes)
+                .is_err()
+        );
+    }
+}
+
+#[test]
+fn source_checks_can_use_canonical_prepared_libraries_explicitly() {
+    let library = Library::prepared_sources_with_format(
+        vec![(
+            "library.kerml".into(),
+            "package L { datatype Number; feature x = if true ? 7 else 8; }".into(),
+        )],
+        None,
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    let sources = vec![(
+        "model.sysml".into(),
+        "package P { attribute x : L::Number; }".into(),
+    )];
+    assert!(
+        sysmlv2_transform::check_sources_with_graph_format(
+            &sources,
+            Some(&library),
+            GraphFormat::CanonicalV3,
+        )
+        .is_ok()
+    );
+    assert!(sysmlv2_transform::check_sources_with_library(&sources, Some(&library)).is_err());
+}
+
+#[test]
+fn canonical_delta_decoder_refuses_legacy_graph_hidden_under_canonical_stamp() {
+    let base = session(GraphFormat::CanonicalV3, false, 7).to_compact_json();
+    let bad_target = session(GraphFormat::LegacyV2, true, 8).to_compact_json();
+    for portable in [false, true] {
+        let mut bytes = sysmlv2_cbor::delta_compact_cbor(
+            &base,
+            &bad_target,
+            &sysmlv2_cbor::DeltaOptions::new().with_portable(portable),
+        )
+        .unwrap();
+        bytes[16] = 3;
+        assert!(sysmlv2_cbor::apply_delta_cbor(&bytes, &base).is_err());
+        if portable {
+            assert!(sysmlv2_cbor::apply_delta_cbor_lenient(&bytes, &base).is_err());
+        }
+    }
+}
+
+#[test]
+fn canonical_transport_refuses_contradictory_conditional_input_direction() {
+    let original = session(GraphFormat::CanonicalV3, true, 7).to_compact_json();
+    let rows = original.as_array().unwrap();
+    let index_of = |reference: &serde_json::Value| {
+        rows.iter()
+            .position(|row| row["@id"] == reference["@id"])
+            .unwrap()
+    };
+    let conditional = rows.iter().find(|row| row["operator"] == "if").unwrap();
+    let membership = index_of(&conditional["ownedRelationship"][1]);
+    let parameter = index_of(&rows[membership]["ownedRelatedElement"][0]);
+    for direction in [
+        serde_json::json!("out"),
+        serde_json::json!("inout"),
+        serde_json::Value::Null,
+    ] {
+        let mut malformed = original.clone();
+        malformed[parameter]["direction"] = direction;
+        assert!(
+            Session::from_interchange_json_with_graph_format(
+                &malformed,
+                None,
+                &["model.sysml".into()],
+                Indent::default(),
+                GraphFormat::CanonicalV3,
+            )
+            .is_err()
+        );
+        assert!(
+            sysmlv2_cbor::to_compact_cbor_with_format(&malformed, &[], GraphFormat::CanonicalV3,)
+                .is_err()
+        );
+        // Construct a validly encoded but falsely stamped payload through the
+        // legacy codec to exercise decoder validation independently of encoding.
+        let mut bytes = sysmlv2_cbor::to_compact_cbor(&malformed).unwrap();
+        bytes[16] = 3;
+        assert!(sysmlv2_cbor::from_compact_cbor(&bytes).is_err());
+        let mut delta = sysmlv2_cbor::delta_compact_cbor(
+            &original,
+            &malformed,
+            &sysmlv2_cbor::DeltaOptions::new(),
+        )
+        .unwrap();
+        delta[16] = 3;
+        assert!(sysmlv2_cbor::apply_delta_cbor(&delta, &original).is_err());
+    }
+}
+
+#[test]
+fn session_delta_generation_and_application_refuse_foreign_graph_bases() {
+    for (source, target) in [
+        (GraphFormat::LegacyV2, GraphFormat::CanonicalV3),
+        (GraphFormat::CanonicalV3, GraphFormat::LegacyV2),
+    ] {
+        let foreign_base = session(source, true, 7).to_compact_json();
+        let receiver = session(target, true, 8);
+        assert!(receiver.delta_cbor_from(&foreign_base, false).is_err());
+        assert!(receiver.delta_cbor_from(&foreign_base, true).is_err());
+        assert!(receiver.delta_cbor_elided_from(&foreign_base).is_err());
+        if target == GraphFormat::LegacyV2 {
+            let bytes = sysmlv2_cbor::delta_compact_cbor(
+                &foreign_base,
+                &receiver.to_compact_json(),
+                &sysmlv2_cbor::DeltaOptions::new(),
+            )
+            .unwrap();
+            assert!(
+                receiver
+                    .apply_delta_cbor_to(&bytes, &foreign_base, false)
+                    .is_err()
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/graph_format.rs b/crates/sysmlv2-transform/tests/graph_format.rs
new file mode 100644
index 0000000..16754c9
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/graph_format.rs
@@ -0,0 +1,377 @@
+use sysmlv2_model::{eval::Value, migration::validate_graph_format};
+use sysmlv2_transform::{GraphFormat, Indent, Library, Session};
+
+fn session() -> Session {
+    Session::from_sources_with_graph_format(
+        vec![(
+            "p.sysml".into(),
+            "package P { attribute x = if true ? 7 else 1/0; attribute y = x; }".into(),
+        )],
+        None,
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap()
+}
+#[test]
+fn canonical_sessions_preserve_format_through_edits_and_transport() {
+    let mut s = session();
+    let base = s.to_compact_json();
+    let x = s.resolved().resolve_qualified("P::x").unwrap();
+    let mut edit = s.edit();
+    edit.rename(x, "renamed");
+    edit.commit().unwrap();
+    s.minimize_qualifications().unwrap();
+    s.load_library_from(Library::sources(vec![(
+        "lib.kerml".into(),
+        "package L { feature f; }".into(),
+    )]))
+    .unwrap();
+    assert_eq!(s.model().graph_format(), GraphFormat::CanonicalV3);
+    assert_eq!(
+        s.resolved().evaluate_qualified("P::y"),
+        Ok(Value::Integer(7))
+    );
+    let target = s.to_compact_json();
+    validate_graph_format(&target, GraphFormat::CanonicalV3).unwrap();
+    let bytes = s.to_compact_cbor();
+    assert_eq!(
+        sysmlv2_cbor::describe(&bytes).unwrap()["versions"]["scheme"],
+        3
+    );
+    let mut replay = Session::from_compact_cbor(&bytes).unwrap();
+    assert_eq!(replay.model().graph_format(), GraphFormat::CanonicalV3);
+    assert_eq!(replay.to_compact_json(), target);
+    assert_eq!(
+        replay.resolved().evaluate_qualified("P::y"),
+        Ok(Value::Integer(7))
+    );
+    let elided = s.to_compact_cbor_elided().unwrap();
+    assert_eq!(s.decode_cbor(&elided).unwrap(), target);
+    let full = s.to_full_cbor(false);
+    assert_eq!(
+        sysmlv2_cbor::describe(&full).unwrap()["versions"]["scheme"],
+        3
+    );
+    for elided in [false, true] {
+        let bytes = if elided {
+            s.delta_cbor_elided_from(&base)
+        } else {
+            s.delta_cbor_from(&base, false)
+        }
+        .unwrap();
+        assert_eq!(
+            sysmlv2_cbor::describe(&bytes).unwrap()["versions"]["scheme"],
+            3
+        );
+        let (applied, report) = s.apply_delta_cbor_to(&bytes, &base, false).unwrap();
+        assert!(report.base_matched);
+        assert_eq!(sysmlv2_cbor::delta_canonical(&target).unwrap(), applied);
+    }
+}
+
+#[test]
+fn canonical_constructor_ownership_survives_rename_replay_and_deltas() {
+    let mut session = Session::from_sources_with_graph_format(
+        vec![(
+            "constructors.kerml".into(),
+            "class Point {feature x;} feature p=new Point(x=if true ? 7 else 8);".into(),
+        )],
+        None,
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    let base = session.to_compact_json();
+    let point = session.resolved().resolve_qualified("Point").unwrap();
+    let mut edit = session.edit();
+    edit.rename(point, "Position");
+    edit.commit().unwrap();
+    let target = session.to_compact_json();
+    validate_graph_format(&target, GraphFormat::CanonicalV3).unwrap();
+    for elided in [false, true] {
+        let bytes = if elided {
+            session.delta_cbor_elided_from(&base)
+        } else {
+            session.delta_cbor_from(&base, false)
+        }
+        .unwrap();
+        let (applied, report) = session.apply_delta_cbor_to(&bytes, &base, false).unwrap();
+        assert!(report.base_matched);
+        assert_eq!(applied, sysmlv2_cbor::delta_canonical(&target).unwrap());
+    }
+    let mut replay = Session::from_compact_cbor(&session.to_compact_cbor()).unwrap();
+    assert_eq!(replay.to_compact_json(), target);
+    let point = replay.resolved().resolve_qualified("Position").unwrap();
+    let mut edit = replay.edit();
+    edit.rename(point, "Point");
+    edit.commit().unwrap();
+    assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+    let constructors = replay
+        .to_compact_json()
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter(|row| row["@type"] == "ConstructorExpression")
+        .count();
+    assert_eq!(constructors, 1);
+    validate_graph_format(&replay.to_compact_json(), GraphFormat::CanonicalV3).unwrap();
+}
+#[test]
+fn canonical_payload_keeps_foreign_explicit_ids_and_legacy_stays_default() {
+    let s = session();
+    let original = s.to_compact_json();
+    let mut document = original.clone();
+    let root = document[0]["@id"].as_str().unwrap().to_owned();
+    let foreign = "00000000-0000-4000-8000-000000000077";
+    document = serde_json::from_str(
+        &serde_json::to_string(&document)
+            .unwrap()
+            .replace(&root, foreign),
+    )
+    .unwrap();
+    let replay = Session::from_interchange_json_with_graph_format(
+        &document,
+        None,
+        &["p.sysml".into()],
+        Indent::default(),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+    assert_eq!(replay.to_compact_json(), document);
+    let bytes = replay.to_compact_cbor();
+    assert_eq!(sysmlv2_cbor::from_compact_cbor(&bytes).unwrap(), document);
+    assert!(replay.to_compact_cbor_elided().is_err());
+    assert_eq!(
+        Session::from_compact_cbor(&bytes)
+            .unwrap()
+            .to_compact_json(),
+        document
+    );
+    let legacy = Session::from_sources(vec![(
+        "p.sysml".into(),
+        "package P { attribute x = if true ? 7 else 1/0; }".into(),
+    )])
+    .unwrap();
+    assert_eq!(legacy.model().graph_format(), GraphFormat::LegacyV2);
+    assert_eq!(
+        sysmlv2_cbor::describe(&legacy.to_compact_cbor()).unwrap()["versions"]["scheme"],
+        2
+    );
+}
+
+#[test]
+fn canonical_conditional_references_keep_bindings_through_full_replay_and_rename() {
+    let sources = vec![("defs.sysml".into(),"package Defs { attribute n = 7; }".into()),("uses.sysml".into(),"package Uses { attribute a = if true ? Defs::n else 1/0; attribute b = null ?? Defs::n; attribute c = false or (Defs::n == 7); }".into())];
+    let mut s =
+        Session::from_sources_with_graph_format(sources, None, GraphFormat::CanonicalV3).unwrap();
+    let check = |s: &mut Session| {
+        assert_eq!(
+            s.resolved().evaluate_qualified("Uses::a"),
+            Ok(Value::Integer(7))
+        );
+        assert_eq!(
+            s.resolved().evaluate_qualified("Uses::b"),
+            Ok(Value::Integer(7))
+        );
+        assert_eq!(
+            s.resolved().evaluate_qualified("Uses::c"),
+            Ok(Value::Boolean(true))
+        );
+    };
+    check(&mut s);
+    let mut replay = Session::from_interchange_json_with_graph_format(
+        &s.to_full_json(),
+        None,
+        &["defs.sysml".into(), "uses.sysml".into()],
+        Indent::default(),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+    check(&mut replay);
+    let n = replay.resolved().resolve_qualified("Defs::n").unwrap();
+    let mut edit = replay.edit();
+    edit.rename(n, "renamed");
+    edit.commit().unwrap();
+    check(&mut replay);
+}
+
+#[test]
+fn canonical_library_reference_identity_survives_nested_wrappers_and_full_replay() {
+    let lib = Library::sources(vec![("library.kerml".into(), "standard library package L { datatype Scalar; function Anonymous { return : Scalar; } feature visible; }".into())]);
+    let mut s = Session::from_sources_with_graph_format(
+        vec![(
+            "p.kerml".into(),
+            "package P { feature x = if true ? (null ?? L::visible) else L::visible; }".into(),
+        )],
+        Some(lib.clone()),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    let r = s.resolved();
+    let owner = r.resolve_qualified("L::Anonymous").unwrap();
+    let elements: Vec<_> = r.elements().collect();
+    let target = elements
+        .into_iter()
+        .find(|&e| {
+            r.element_type(e) == "Feature"
+                && r.element_name(e).is_none()
+                && r.owner(e) == Some(owner)
+        })
+        .unwrap();
+    let target_id = r.element_id(target).to_string();
+    let visible = r.resolve_qualified("L::visible").unwrap();
+    let visible_id = r.element_id(visible).to_string();
+    let mut document = s.to_compact_json();
+    for row in document.as_array_mut().unwrap() {
+        if row["@type"] == "Membership" && row["memberElement"]["@id"] == visible_id {
+            row["memberElement"] = serde_json::json!({"@id":target_id});
+        }
+    }
+    let mut loaded = Session::from_interchange_json_with_graph_format(
+        &document,
+        Some(&lib),
+        &["p.kerml".into()],
+        Indent::default(),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert_eq!(loaded.to_compact_json(), document);
+    assert!(
+        loaded
+            .resolved()
+            .bound_id_reference_sites()
+            .iter()
+            .all(|(_, _, id)| id.to_string() == target_id)
+    );
+    assert_eq!(loaded.resolved().bound_id_reference_sites().len(), 2);
+    let full = loaded.to_full_json_with(false);
+    let mut replay = Session::from_interchange_json_with_graph_format(
+        &full,
+        Some(&lib),
+        &["p.kerml".into()],
+        Indent::default(),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+    let p = replay.resolved().resolve_qualified("P").unwrap();
+    let mut edit = replay.edit();
+    edit.rename(p, "Renamed");
+    edit.commit().unwrap();
+    assert_eq!(replay.resolved().bound_id_reference_sites().len(), 2);
+    assert!(
+        replay
+            .resolved()
+            .bound_id_reference_sites()
+            .iter()
+            .all(|(_, _, id)| id.to_string() == target_id)
+    );
+}
+
+#[test]
+fn canonical_full_replay_with_standard_library_preserves_values_and_typing() {
+    let mut model = sysmlv2_transform::ModelHandle::with_graph_format(GraphFormat::CanonicalV3);
+    model
+        .load_library_dir(&sysmlv2_testkit::library_dir())
+        .unwrap();
+    let lib = Library::Prepared(model.prepare_library().unwrap());
+    let sources=vec![("standard.sysml".into(),"package P { attribute x : ScalarValues::Integer = 7; attribute y = if true ? x else 1/0; }".into())];
+    let original = Session::from_sources_with_graph_format(
+        sources,
+        Some(lib.clone()),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    let mut replay = Session::from_interchange_json_with_graph_format(
+        &original.to_full_json(),
+        Some(&lib),
+        &["standard.sysml".into()],
+        Indent::default(),
+        GraphFormat::CanonicalV3,
+    )
+    .unwrap();
+    assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+    assert_eq!(
+        replay.resolved().evaluate_qualified("P::y"),
+        Ok(Value::Integer(7))
+    );
+    let before = original.to_compact_json();
+    let after = replay.to_compact_json();
+    assert_eq!(
+        before.as_array().unwrap().len(),
+        after.as_array().unwrap().len()
+    );
+    for (before, after) in before
+        .as_array()
+        .unwrap()
+        .iter()
+        .zip(after.as_array().unwrap())
+    {
+        for (key, value) in before.as_object().unwrap() {
+            assert_eq!(value, &after[key], "{key}");
+        }
+    }
+}
+
+#[test]
+fn unversioned_json_loading_retains_foreign_graph_recovery() {
+    let document = session().to_compact_json();
+    let mut recovered =
+        Session::from_interchange_json_named(&document, None, &["p.sysml".into()]).unwrap();
+    assert_eq!(recovered.model().graph_format(), GraphFormat::LegacyV2);
+    assert!(
+        recovered
+            .warnings()
+            .iter()
+            .any(|w| w.contains("no structural counterpart")),
+        "{:?}",
+        recovered.warnings()
+    );
+    assert_eq!(
+        recovered.resolved().evaluate_qualified("P::y"),
+        Ok(Value::Integer(7))
+    );
+    assert!(
+        Session::from_interchange_json_with_graph_format(
+            &document,
+            None,
+            &["p.sysml".into()],
+            Indent::default(),
+            GraphFormat::LegacyV2
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn legacy_binary_entry_points_keep_foreign_graph_recovery() {
+    let document = session().to_compact_json();
+    // Historical generic encoders can carry foreign graphs under scheme 2.
+    let bytes = sysmlv2_cbor::to_compact_cbor(&document).unwrap();
+    let context = Session::from_sources(Vec::new()).unwrap();
+    assert_eq!(context.decode_cbor(&bytes).unwrap(), document);
+    let mut replay = Session::from_compact_cbor(&bytes).unwrap();
+    assert_eq!(replay.model().graph_format(), GraphFormat::LegacyV2);
+    assert!(
+        replay
+            .warnings()
+            .iter()
+            .any(|w| w.contains("no structural counterpart"))
+    );
+    assert_eq!(
+        replay.resolved().evaluate_qualified("P::y"),
+        Ok(Value::Integer(7))
+    );
+    let explicit_legacy =
+        Session::from_sources_with_graph_format(Vec::new(), None, GraphFormat::LegacyV2).unwrap();
+    assert!(explicit_legacy.decode_cbor(&bytes).is_err());
+    let delta = context.delta_cbor_from(&document, false).unwrap();
+    assert!(
+        context
+            .apply_delta_cbor_to(&delta, &document, false)
+            .is_ok()
+    );
+    assert!(explicit_legacy.delta_cbor_from(&document, false).is_err());
+}
diff --git a/crates/sysmlv2-transform/tests/inherited_lookup_provenance.rs b/crates/sysmlv2-transform/tests/inherited_lookup_provenance.rs
new file mode 100644
index 0000000..d7ba1a3
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/inherited_lookup_provenance.rs
@@ -0,0 +1,72 @@
+use sysmlv2_transform::Session;
+
+#[test]
+fn rename_rewrites_explicit_and_relative_header_qualifiers() {
+    for (source, target, expected) in [
+        (
+            "class A { feature x; } class Child specializes A { feature y redefines A::x; }",
+            "A",
+            "redefines Renamed::x",
+        ),
+        (
+            "class A { class Nested { feature x; } } class Child specializes A { feature y redefines Nested::x; }",
+            "A::Nested",
+            "redefines Renamed::x",
+        ),
+    ] {
+        let mut s = Session::from_sources(vec![("qualified.kerml".into(), source.into())]).unwrap();
+        let target = s.resolved().resolve_qualified(target).unwrap();
+        let mut edit = s.edit();
+        edit.rename(target, "Renamed");
+        edit.commit()
+            .expect("qualifier rename preserves header identity");
+        assert!(s.units().next().unwrap().2.contains(expected));
+        assert_eq!(s.resolved().unresolved_count(), 0);
+    }
+}
+
+#[test]
+fn rename_preserves_imported_base_and_redefinition_target_identity() {
+    for import in ["private import Lib::*;", "private import Lib::Base;"] {
+        let source = format!(
+            "package Lib {{ class Base {{ feature x; }} }}
+            package P {{ {import}
+                class Child specializes Base {{ feature x; feature y redefines x; }}
+            }}"
+        );
+        let mut session = Session::from_sources(vec![("imported.kerml".into(), source)]).unwrap();
+        let base = session.resolved().resolve_qualified("Lib::Base").unwrap();
+        let mut edit = session.edit();
+        edit.rename(base, "Renamed");
+        edit.commit()
+            .expect("rename preserves imported base binding");
+        let slot = session
+            .resolved()
+            .resolve_qualified("Lib::Renamed::x")
+            .unwrap();
+        let mut edit = session.edit();
+        edit.rename(slot, "inheritedSlot");
+        edit.commit()
+            .expect("rename preserves inherited header target");
+        let source = session.units().next().unwrap().2;
+        assert!(source.contains("specializes Renamed"));
+        assert!(
+            source.contains("feature x;"),
+            "the local shadow keeps its name"
+        );
+        assert!(source.contains("redefines inheritedSlot"));
+        let r = session.resolved();
+        assert_eq!(r.unresolved_count(), 0);
+        let expected = r.resolve_qualified("Lib::Renamed::inheritedSlot").unwrap();
+        let y = r.resolve_qualified("P::Child::y").unwrap();
+        let relation = r
+            .owned_relationships(y)
+            .into_iter()
+            .find(|&e| r.element_type(e) == "Redefinition")
+            .unwrap();
+        assert_eq!(
+            r.element_properties(relation)["redefinedFeature"]["@id"],
+            r.element_id(expected).to_string()
+        );
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/library_reference_spelling.rs b/crates/sysmlv2-transform/tests/library_reference_spelling.rs
new file mode 100644
index 0000000..6db42f1
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/library_reference_spelling.rs
@@ -0,0 +1,552 @@
+//! Library identity fallback is distinct from authored lexical spelling.
+use serde_json::{Value, json};
+use std::collections::HashMap;
+use sysmlv2_model::{json::ResolvedModel, model::Model};
+use sysmlv2_transform::{Library, Session};
+
+const LIBRARY: &str = "standard library package Lib { private function Hidden { return result; } function Public specializes Hidden; feature visible; datatype Scalar; function Anonymous { return : Scalar; } }";
+fn library() -> Library {
+    Library::sources(vec![("lib.kerml".into(), LIBRARY.into())])
+}
+fn model(source: &str) -> (Model, ResolvedModel) {
+    let mut m = Model::new();
+    m.add_library_source("lib.kerml", LIBRARY);
+    m.add_source("u.kerml", source);
+    assert!(!m.has_errors());
+    let r = ResolvedModel::build(&m);
+    (m, r)
+}
+fn rows(v: &Value) -> HashMap<String, Value> {
+    v.as_array()
+        .unwrap()
+        .iter()
+        .map(|e| (e["@id"].as_str().unwrap().to_owned(), e.clone()))
+        .collect()
+}
+fn load(v: &Value) -> Session {
+    Session::from_interchange_json_named(v, Some(&library()), &["u.kerml".into()]).unwrap()
+}
+#[test]
+fn private_declaring_path_preserves_inherited_library_result_and_import_identity() {
+    let source = "package P { feature x = Lib::Public::result; import Lib::Public::result; import Lib::visible; }";
+    let (m, mut r) = model(source);
+    let hidden = r.resolve_qualified("Lib::Hidden::result").unwrap();
+    let public = r.resolve_qualified("Lib::Public::result").unwrap();
+    assert_eq!(hidden, public);
+    let compact = sysmlv2_model::json::model_to_compact_json(&m);
+    let full = sysmlv2_model::full::model_to_full_json_with(&m, false);
+    let mut loaded = load(&compact);
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert!(!loaded.has_explicit_ids());
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    let reloaded_full = loaded.to_full_json_with(false);
+    assert_eq!(rows(&full), rows(&reloaded_full));
+    let compact_bytes = loaded.to_compact_cbor();
+    let binary = Session::from_compact_cbor_with(&compact_bytes, Some(&library())).unwrap();
+    assert!(binary.warnings().is_empty(), "{:?}", binary.warnings());
+    assert_eq!(rows(&compact), rows(&binary.to_compact_json()));
+    let elided = loaded.to_compact_cbor_elided().unwrap();
+    assert_eq!(rows(&compact), rows(&loaded.decode_cbor(&elided).unwrap()));
+    let full_bytes = loaded.to_full_cbor(false);
+    assert_eq!(rows(&full), rows(&loaded.decode_cbor(&full_bytes).unwrap()));
+    for e in compact
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter(|e| e["@type"] == "MembershipImport")
+    {
+        let id = e["importedMembership"]["@id"].as_str().unwrap();
+        let target = loaded.resolved().element_by_id(id).unwrap();
+        assert!(
+            loaded
+                .resolved()
+                .element_type(target)
+                .ends_with("Membership")
+        );
+    }
+}
+#[test]
+fn fallback_preserves_unresolved_and_resolved_uuid_shaped_authored_names() {
+    let (_, mut r) = model("");
+    let target = r.resolve_qualified("Lib::Public::result").unwrap();
+    let id = r.element_id(target);
+    let missing = "88888888-8888-4888-8888-888888888888";
+    let source = format!(
+        "package P {{ feature '{id}'; feature lexical = '{id}'; feature missing = '{missing}'; feature actual = Lib::Public::result; }} package Other {{ feature disguised = '{id}'; }}"
+    );
+    let (m, _) = model(&source);
+    let compact = sysmlv2_model::json::model_to_compact_json(&m);
+    assert!(
+        compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["memberElement"] == json!({"@ref":format!("'{missing}'")}))
+    );
+    let mut loaded = load(&compact);
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    let lexical = loaded
+        .resolved()
+        .resolve_qualified(&format!("P::'{id}'"))
+        .unwrap();
+    assert_ne!(loaded.resolved().element_id(lexical), id);
+    assert_eq!(loaded.resolved().unresolved_count(), 2);
+    let recovered = load(&loaded.to_full_json());
+    assert!(
+        recovered.warnings().is_empty(),
+        "{:?}",
+        recovered.warnings()
+    );
+    assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+    loaded.minimize_qualifications().unwrap();
+    loaded.load_library_from(library()).unwrap();
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+}
+#[test]
+fn strict_identity_site_survives_unrelated_edit_and_parent_rename_then_releases_changed_target() {
+    let (m, mut original) = model("package P { feature x = Lib::Public::result; }");
+    let target = original.resolve_qualified("Lib::Public::result").unwrap();
+    let target_id = original.element_id(target).to_string();
+    let mut loaded = load(&sysmlv2_model::json::model_to_compact_json(&m));
+    let p = loaded.resolved().resolve_qualified("P").unwrap();
+    let mut edit = loaded.edit();
+    edit.insert_member(p, "package Unrelated;");
+    edit.commit().unwrap();
+    let p = loaded.resolved().resolve_qualified("P").unwrap();
+    let mut edit = loaded.edit();
+    edit.rename(p, "Renamed");
+    edit.commit().unwrap();
+    let compact = loaded.to_compact_json();
+    assert!(
+        compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == target_id)
+    );
+    loaded.load_library_from(library()).unwrap();
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    let x = loaded.resolved().resolve_qualified("Renamed::x").unwrap();
+    let mut edit = loaded.edit();
+    edit.set_feature_value(x, "Lib::visible");
+    edit.commit().unwrap();
+    let visible = loaded.resolved().resolve_qualified("Lib::visible").unwrap();
+    let visible_id = loaded.resolved().element_id(visible).to_string();
+    let after = loaded.to_compact_json();
+    assert!(
+        after
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == visible_id)
+    );
+    assert!(
+        !after
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == target_id)
+    );
+}
+#[test]
+fn strict_fallback_preserves_an_unnamed_library_return_parameter() {
+    let (m, mut r) = model(
+        "package P { feature actual = Lib::Public::result; feature unnamed = Lib::visible; }",
+    );
+    let owner = r.resolve_qualified("Lib::Anonymous").unwrap();
+    let elements: Vec<_> = r.elements().collect();
+    let target = elements
+        .into_iter()
+        .find(|&e| {
+            r.element_type(e) == "Feature"
+                && r.element_name(e).is_none()
+                && r.owner(e) == Some(owner)
+        })
+        .unwrap();
+    let target_id = r.element_id(target).to_string();
+    let visible = r.resolve_qualified("Lib::visible").unwrap();
+    let visible_id = r.element_id(visible).to_string();
+    let mut compact = sysmlv2_model::json::model_to_compact_json(&m);
+    let row = compact
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == visible_id)
+        .unwrap();
+    row["memberElement"] = json!({"@id":target_id});
+    let mut loaded = load(&compact);
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    assert!(loaded.resolved().element_by_id(&target_id).is_some());
+}
+
+#[test]
+fn private_library_reference_survives_foreign_user_ids_and_full_reload() {
+    let (_, mut r) = model("");
+    let target = r.resolve_qualified("Lib::Public::result").unwrap();
+    let id = r.element_id(target);
+    let (m, _) = model(&format!(
+        "package P {{ feature '{id}'; feature lexical = '{id}'; feature x = Lib::Public::result; import Lib::Public::result; alias kept for '{id}'; }}"
+    ));
+    let mut compact = sysmlv2_model::json::model_to_compact_json(&m);
+    let replacements: HashMap<_, _> = compact
+        .as_array()
+        .unwrap()
+        .iter()
+        .enumerate()
+        .map(|(i, e)| {
+            (
+                e["@id"].as_str().unwrap().to_owned(),
+                format!("99999999-9999-4999-8999-{i:012x}"),
+            )
+        })
+        .collect();
+    fn rewrite(value: &mut Value, replacements: &HashMap<String, String>) {
+        match value {
+            Value::Object(o) => {
+                for (key, value) in o {
+                    if matches!(key.as_str(), "@id" | "elementId") {
+                        if let Some(replacement) = value.as_str().and_then(|s| replacements.get(s))
+                        {
+                            *value = Value::String(replacement.clone());
+                        }
+                    } else {
+                        rewrite(value, replacements);
+                    }
+                }
+            }
+            Value::Array(items) => {
+                for item in items {
+                    rewrite(item, replacements);
+                }
+            }
+            _ => {}
+        }
+    }
+    rewrite(&mut compact, &replacements);
+    let loaded = load(&compact);
+    assert!(loaded.has_explicit_ids());
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    let full = loaded.to_full_json_with(false);
+    let again = load(&full);
+    assert!(again.warnings().is_empty(), "{:?}", again.warnings());
+    assert_eq!(rows(&compact), rows(&again.to_compact_json()));
+    assert_eq!(rows(&full), rows(&again.to_full_json_with(false)));
+}
+
+#[test]
+fn strict_library_identity_survives_member_move_and_dry_run_then_can_be_deleted() {
+    let (m, mut r) = model("package P { feature x = Lib::Public::result; } package Destination;");
+    let target = r.resolve_qualified("Lib::Public::result").unwrap();
+    let target_id = r.element_id(target).to_string();
+    let mut loaded = load(&sysmlv2_model::json::model_to_compact_json(&m));
+    let before = loaded.to_compact_json();
+    let x = loaded.resolved().resolve_qualified("P::x").unwrap();
+    let destination = loaded.resolved().resolve_qualified("Destination").unwrap();
+    let mut edit = loaded.edit();
+    edit.move_member(x, destination, None);
+    edit.check().unwrap();
+    assert_eq!(rows(&before), rows(&loaded.to_compact_json()));
+    let x = loaded.resolved().resolve_qualified("P::x").unwrap();
+    let destination = loaded.resolved().resolve_qualified("Destination").unwrap();
+    let mut edit = loaded.edit();
+    edit.move_member(x, destination, None);
+    edit.commit().unwrap();
+    assert!(
+        loaded
+            .resolved()
+            .resolve_qualified("Destination::x")
+            .is_some()
+    );
+    let moved = loaded.to_compact_json();
+    assert!(
+        moved
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == target_id)
+    );
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    let x = loaded
+        .resolved()
+        .resolve_qualified("Destination::x")
+        .unwrap();
+    let mut edit = loaded.edit();
+    edit.remove(x);
+    edit.commit().unwrap();
+    assert!(
+        !loaded
+            .to_compact_json()
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == target_id)
+    );
+}
+
+#[test]
+fn unsupported_consumed_identity_provenance_refuses_transactionally() {
+    let (m, _) = model("package P { feature x = Lib::Public::result; }");
+    let mut loaded = load(&sysmlv2_model::json::model_to_compact_json(&m));
+    let before = loaded.to_compact_json();
+    let p = loaded.resolved().resolve_qualified("P").unwrap();
+    let mut edit = loaded.edit();
+    edit.add_unit("moved.kerml");
+    edit.hoist_to_unit(p, "moved.kerml", None);
+    let error = edit.commit().unwrap_err();
+    assert!(
+        matches!(
+            error,
+            sysmlv2_transform::TransformError::SemanticIdentity { .. }
+        ),
+        "{error}"
+    );
+    assert!(
+        error.to_string().contains("payload identity reference"),
+        "{error}"
+    );
+    assert_eq!(rows(&before), rows(&loaded.to_compact_json()));
+    loaded.load_library_from(library()).unwrap();
+    assert_eq!(rows(&before), rows(&loaded.to_compact_json()));
+}
+
+#[test]
+fn changing_an_unnamed_user_target_identity_refuses_instead_of_leaving_external_id() {
+    let (m, mut r) = model(
+        "package P { feature; feature x = Lib::Public::result; feature user = Lib::visible; }",
+    );
+    let p = r.resolve_qualified("P").unwrap();
+    let elements: Vec<_> = r.elements().collect();
+    let anonymous = elements
+        .into_iter()
+        .find(|&e| {
+            r.element_type(e) == "Feature" && r.element_name(e).is_none() && r.owner(e) == Some(p)
+        })
+        .unwrap();
+    let anonymous_id = r.element_id(anonymous).to_string();
+    let visible = r.resolve_qualified("Lib::visible").unwrap();
+    let visible_id = r.element_id(visible).to_string();
+    let mut payload = sysmlv2_model::json::model_to_compact_json(&m);
+    let site = payload
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == visible_id)
+        .unwrap();
+    site["memberElement"] = json!({"@id":anonymous_id});
+    let mut loaded = load(&payload);
+    let before = loaded.to_compact_json();
+    assert!(loaded.resolved().element_by_id(&anonymous_id).is_some());
+    let p = loaded.resolved().resolve_qualified("P").unwrap();
+    let mut edit = loaded.edit();
+    edit.rename(p, "Renamed");
+    let error = edit.commit().unwrap_err();
+    assert!(
+        matches!(
+            error,
+            sysmlv2_transform::TransformError::SemanticIdentity { .. }
+        ),
+        "{error}"
+    );
+    assert!(
+        error.to_string().contains("payload identity reference"),
+        "{error}"
+    );
+    assert_eq!(rows(&before), rows(&loaded.to_compact_json()));
+}
+
+#[test]
+fn bound_compact_full_policy_treats_remaining_uuid_refs_as_lexical() {
+    use sysmlv2_model::full::{EmissionError, EmissionPolicy, UnresolvedReferencePolicy};
+    let spelling = "'88888888-8888-4888-8888-888888888888'";
+    let (m, mut r) = model(&format!("package P {{ feature x = {spelling}; }}"));
+    let compact = sysmlv2_model::json::model_to_compact_json(&m);
+    let previous = r.closure_policy();
+    let reject = sysmlv2_model::full::resolved_compact_to_full_json(
+        &mut r,
+        &m,
+        compact.clone(),
+        EmissionPolicy {
+            unresolved: UnresolvedReferencePolicy::Reject,
+            closures: Default::default(),
+        },
+    )
+    .unwrap_err();
+    assert!(
+        matches!(reject, EmissionError::UnresolvedReferences(error) if error.references == vec![spelling])
+    );
+    assert_eq!(r.closure_policy(), previous);
+    let full = sysmlv2_model::full::resolved_compact_to_full_json(
+        &mut r,
+        &m,
+        compact,
+        EmissionPolicy::default(),
+    )
+    .unwrap();
+    assert!(full.as_array().unwrap().iter().any(|e| e["language"]
+        == sysmlv2_model::full::UNRESOLVED_REP_LANGUAGE
+        && e["body"] == spelling));
+    let dangling = sysmlv2_model::json::dangling_id(spelling);
+    assert!(
+        full.as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership" && e["memberElement"]["@id"] == dangling)
+    );
+    // Existing compatibility entry points retain their documented ID-shaped
+    // spelling interpretation; only bound-compact input establishes provenance.
+    let legacy = sysmlv2_model::full::model_to_full_json_with(&m, true);
+    assert!(
+        legacy
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == "Membership"
+                && e["memberElement"]["@id"] == spelling.trim_matches('\''))
+    );
+}
+
+#[test]
+fn recovered_effective_names_preserve_structural_pairing() {
+    for keyword in ["references", "redefines"] {
+        for spelling in [
+            "Missing",
+            "'88888888-8888-4888-8888-888888888888'",
+            "'missing::quoted'",
+            "Missing::'quoted::leaf'",
+        ] {
+            let source = format!(
+                "package P {{ feature actual = Lib::Public::result; feature {keyword} {spelling}; }}"
+            );
+            let (m, _) = model(&source);
+            let compact = sysmlv2_model::json::model_to_compact_json(&m);
+            let loaded = load(&compact);
+            assert!(
+                loaded.warnings().is_empty(),
+                "{keyword} {spelling}: {:?}",
+                loaded.warnings()
+            );
+            let recovered = load(&loaded.to_full_json());
+            assert!(
+                recovered.warnings().is_empty(),
+                "{keyword} {spelling}: {:?}",
+                recovered.warnings()
+            );
+            assert!(!recovered.has_explicit_ids(), "{keyword} {spelling}");
+            assert_eq!(
+                rows(&compact),
+                rows(&recovered.to_compact_json()),
+                "{keyword} {spelling}"
+            );
+        }
+    }
+}
+
+fn check_expression_reference_membership_roundtrip(fragment: &str, expression_type: &str) {
+    let (m, _) = model(&format!(
+        "package P {{ feature actual = Lib::Public::result; \
+         feature target; alias kept for target; \
+         feature body = {{ alias bodyKept for target; bodyKept }}; {fragment} }}"
+    ));
+    let mut compact = sysmlv2_model::json::model_to_compact_json(&m);
+    assert!(
+        compact
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|e| e["@type"] == expression_type)
+    );
+    let replacements: HashMap<_, _> = compact
+        .as_array()
+        .unwrap()
+        .iter()
+        .enumerate()
+        .map(|(i, e)| {
+            (
+                e["@id"].as_str().unwrap().to_owned(),
+                format!("77777777-7777-4777-8777-{i:012x}"),
+            )
+        })
+        .collect();
+    fn rewrite(value: &mut Value, replacements: &HashMap<String, String>) {
+        match value {
+            Value::Object(object) => {
+                for (key, value) in object {
+                    if matches!(key.as_str(), "@id" | "elementId") {
+                        if let Some(replacement) = value.as_str().and_then(|s| replacements.get(s))
+                        {
+                            *value = Value::String(replacement.clone());
+                        }
+                    } else {
+                        rewrite(value, replacements);
+                    }
+                }
+            }
+            Value::Array(items) => {
+                for item in items {
+                    rewrite(item, replacements);
+                }
+            }
+            _ => {}
+        }
+    }
+    rewrite(&mut compact, &replacements);
+    let loaded = load(&compact);
+    assert!(loaded.has_explicit_ids());
+    assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+    assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+    let full = loaded.to_full_json_with(false);
+    let recovered = load(&full);
+    assert!(recovered.has_explicit_ids());
+    assert!(
+        recovered.warnings().is_empty(),
+        "{:?}",
+        recovered.warnings()
+    );
+    assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+    assert_eq!(rows(&full), rows(&recovered.to_full_json_with(false)));
+    for alias in ["kept", "bodyKept"] {
+        assert!(
+            recovered
+                .to_compact_json()
+                .as_array()
+                .unwrap()
+                .iter()
+                .any(|e| { e["@type"] == "Membership" && e["memberName"] == alias })
+        );
+    }
+}
+
+#[test]
+fn invocation_reference_membership_preserves_foreign_identity() {
+    check_expression_reference_membership_roundtrip(
+        "function F { return result; } feature value = F();",
+        "InvocationExpression",
+    );
+}
+
+#[test]
+fn constructor_reference_membership_preserves_foreign_identity() {
+    check_expression_reference_membership_roundtrip(
+        "class T; feature value = new T();",
+        "ConstructorExpression",
+    );
+}
+
+#[test]
+fn metadata_reference_membership_preserves_foreign_identity() {
+    check_expression_reference_membership_roundtrip(
+        "class T; feature value = T.metadata;",
+        "MetadataAccessExpression",
+    );
+}
+
+#[test]
+fn chain_reference_membership_preserves_foreign_identity() {
+    check_expression_reference_membership_roundtrip(
+        "class T { feature child; } feature obj : T; feature value = obj.child;",
+        "FeatureChainExpression",
+    );
+}
diff --git a/crates/sysmlv2-transform/tests/payload_loader.rs b/crates/sysmlv2-transform/tests/payload_loader.rs
index 40eccb5..f537ef9 100644
--- a/crates/sysmlv2-transform/tests/payload_loader.rs
+++ b/crates/sysmlv2-transform/tests/payload_loader.rs
@@ -1,4 +1,4 @@
-//! The id-preserving payload loader (plan §33c): a document loaded into
+//! The id-preserving payload loader: a document loaded into
 //! a session keeps the ids it carried — this toolkit's own, a foreign
 //! producer's, or ids of elements the textual notation cannot name.
 
@@ -316,7 +316,7 @@ fn library_references_stay_ids_without_a_library() {
 
 #[test]
 fn references_to_unnamed_elements_are_bound_by_id() {
-    // API-GAPS issue 13: a legal payload may reference an element with
+    // A legal payload may reference an element with
     // no name; the text cannot spell it, but the loaded model must keep
     // the link.
     let src = "package P {
@@ -383,7 +383,7 @@ fn references_to_unnamed_elements_are_bound_by_id() {
 /// another corpus file. The lift spells cross-scope references rooted at
 /// the model root (`$::Name::…`), which is unambiguous within one
 /// document but not in a model that holds two documents declaring the
-/// same top-level name (API-GAPS issue 15); the text route resolves
+/// same top-level name; the text route resolves
 /// those references lexically.
 #[test]
 fn corpus_payload_route_matches_the_text_route() {
@@ -488,20 +488,11 @@ fn corpus_payload_route_body() {
     let reloaded = loaded.to_compact_json();
     let (a, b) = (by_id(&compact), by_id(&reloaded));
     assert_eq!(a.len(), b.len(), "element count");
-    // API-GAPS issue 16: one reference to a library return parameter is
-    // spelled by the parameter's effective name and does not re-resolve.
-    const KNOWN_UNRESOLVED: &str = "$::Requirements::RequirementConstraintCheck::result";
-    let mut known = 0usize;
-    let mut known_ids: Vec<String> = Vec::new();
     let mut differing = 0usize;
     let mut example = String::new();
     for (id, el) in &a {
         match b.get(id) {
             Some(x) if canon(x) == canon(el) => {}
-            Some(x) if x["memberElement"]["@ref"] == KNOWN_UNRESOLVED => {
-                known += 1;
-                known_ids.push(id.clone());
-            }
             other => {
                 differing += 1;
                 if example.is_empty() {
@@ -510,7 +501,6 @@ fn corpus_payload_route_body() {
             }
         }
     }
-    assert_eq!(known, 1, "exactly one known unresolvable spelling");
     assert_eq!(
         differing, 0,
         "compact round trip through the loader; e.g. {example}"
@@ -520,24 +510,12 @@ fn corpus_payload_route_body() {
     let loaded_full = loaded.to_full_json_with(false);
     let (a, b) = (by_id(&direct_full), by_id(&loaded_full));
     assert_eq!(a.len(), b.len(), "full-form element count");
-    // The known unresolvable reference becomes a deterministic dangling
-    // id in the full form; skip it and every element that carries that
-    // id in a derived property.
-    let dangling: Vec<String> = known_ids
-        .iter()
-        .filter_map(|id| b.get(id.as_str()))
-        .filter_map(|x| x["memberElement"]["@id"].as_str().map(str::to_string))
-        .collect();
     let mut differing = 0usize;
     for (id, el) in &a {
         if b.get(id).map(|x| canon(x)) != Some(canon(el)) {
-            let text = canon(b[id]);
-            if known_ids.contains(id) || dangling.iter().any(|d| text.contains(d)) {
-                continue;
-            }
             differing += 1;
             if differing == 1 {
-                eprintln!("first full-form difference at {id}: {}", canon(b[id]));
+                eprintln!("first full-form difference at {id}: {:?}", b.get(id));
             }
         }
     }
@@ -597,3 +575,490 @@ fn long_expressions_keep_their_value_through_json_and_cbor_sessions() {
         },
     );
 }
+
+#[test]
+fn unnamed_type_references_restore_semantic_queries_and_survive_rebuild() {
+    let source = "package P {
+        part def Base { attribute mass = 7; }
+        part def Child :> Base;
+        part p : Base[1];
+        attribute result = p.mass;
+    }";
+    let original = Session::from_sources(vec![("p.sysml".into(), source.into())]).unwrap();
+    let (mut document, _) = foreignize(&original.to_compact_json());
+    let base = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Base")
+        .unwrap();
+    let base_id = base["@id"].as_str().unwrap().to_owned();
+    base.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    for iteration in 0..2 {
+        let model = loaded.resolved();
+        let base = model.element_by_id(&base_id).unwrap();
+        let child = model.resolve_qualified("P::Child").unwrap();
+        let p = model.resolve_qualified("P::p").unwrap();
+        assert_eq!(model.typings(p), vec![base]);
+        assert!(model.conforms(p, base));
+        assert!(model.conforms(child, base));
+        let mass = model.resolve_qualified("P::p::mass").unwrap();
+        assert_eq!(model.resolve_qualified("P::Child::mass"), Some(mass));
+        assert!(model.inherited_features(p, false).contains(&mass));
+        assert!(matches!(
+            model.evaluate_qualified("P::result"),
+            Ok(sysmlv2_model::eval::Value::Integer(7))
+        ));
+        let sites = model.references_to(base);
+        assert_eq!(sites.iter().filter(|s| s.kind == "type").count(), 1);
+        assert_eq!(
+            sites.iter().filter(|s| s.kind == "superclassifier").count(),
+            1
+        );
+        assert!(
+            sites.iter().all(|s| !s.plain),
+            "identity references must not be respelled as names"
+        );
+        assert_eq!(model.unresolved_count(), 0);
+        assert!(
+            model.bind_id_spelled_references().is_empty(),
+            "binding is idempotent"
+        );
+        if iteration == 0 {
+            let p = loaded.resolved().resolve_qualified("P").unwrap();
+            let mut edit = loaded.edit();
+            edit.insert_member(p, "part unrelated;");
+            edit.commit().unwrap();
+        }
+    }
+}
+
+#[test]
+fn unresolved_external_type_keeps_identity_without_invented_semantics() {
+    let source = "package P { part def Base; part p : Base; }";
+    let original = Session::from_sources(vec![("p.sysml".into(), source.into())]).unwrap();
+    let mut document = original.to_compact_json();
+    let external = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"external-type").to_string();
+    for element in document.as_array_mut().unwrap() {
+        if element["@type"] == "FeatureTyping" {
+            element["type"]["@id"] = Value::String(external.clone());
+        }
+    }
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let p = model.resolve_qualified("P::p").unwrap();
+    assert!(model.typings(p).is_empty());
+    assert!(model.element_by_id(&external).is_none());
+    assert_eq!(
+        model.unresolved_count(),
+        0,
+        "known external identities are not unresolved names"
+    );
+    assert!(
+        loaded
+            .warnings()
+            .iter()
+            .any(|w| w.contains("outside the document"))
+    );
+    let output = loaded.to_compact_json();
+    let typing = output
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|e| e["@type"] == "FeatureTyping")
+        .unwrap();
+    assert_eq!(typing["type"]["@id"], external);
+}
+
+#[test]
+fn uuid_spelling_in_text_remains_a_lexical_name() {
+    let name = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"ordinary-name").to_string();
+    let source = format!("package P {{ part def '{name}'; part p : '{name}'; }}");
+    let mut session = Session::from_sources(vec![("p.sysml".into(), source)]).unwrap();
+    let model = session.resolved();
+    let p = model.resolve_qualified("P::p").unwrap();
+    let typ = model.resolve_qualified(&format!("P::'{name}'")).unwrap();
+    assert_eq!(model.typings(p), vec![typ]);
+    assert_ne!(model.element_id(typ).to_string(), name);
+}
+
+#[test]
+fn unnamed_redefinition_targets_restore_shadowing_and_default_evaluation() {
+    let source = "package P {
+        part def Base { attribute mass default = 7; }
+        part def Child :> Base { attribute weight :>> mass; }
+    }";
+    let original = Session::from_sources(vec![("p.sysml".into(), source.into())]).unwrap();
+    let (mut document, _) = foreignize(&original.to_compact_json());
+    let mass = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "mass")
+        .unwrap();
+    let mass_id = mass["@id"].as_str().unwrap().to_owned();
+    mass.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let mass = model.element_by_id(&mass_id).unwrap();
+    let child = model.resolve_qualified("P::Child").unwrap();
+    let weight = model.resolve_qualified("P::Child::weight").unwrap();
+    assert!(
+        model
+            .explicit_specializations(weight)
+            .contains(&("Redefinition", mass))
+    );
+    assert_eq!(model.redefiners(mass), vec![weight]);
+    assert!(!model.inherited_features(child, false).contains(&mass));
+    assert!(matches!(
+        model.evaluate_qualified("P::Child::weight"),
+        Ok(sysmlv2_model::eval::Value::Integer(7))
+    ));
+    let site = model
+        .references_to(mass)
+        .into_iter()
+        .find(|s| s.kind == "redefinedFeature")
+        .unwrap();
+    assert!(!site.plain);
+    let before = loaded.to_compact_json();
+    let warnings = loaded.warnings().to_vec();
+    let p = loaded.resolved().resolve_qualified("P").unwrap();
+    let mut edit = loaded.edit();
+    edit.insert_member(p, "part unrelated;");
+    edit.check().unwrap();
+    assert_eq!(loaded.to_compact_json(), before);
+    assert_eq!(loaded.warnings(), warnings);
+    // Qualification minimization rebuilds and verifies the semantic graph too.
+    loaded.minimize_qualifications().unwrap();
+    let model = loaded.resolved();
+    let mass = model.element_by_id(&mass_id).unwrap();
+    let weight = model.resolve_qualified("P::Child::weight").unwrap();
+    assert_eq!(model.redefiners(mass), vec![weight]);
+}
+
+#[test]
+fn unnamed_namespace_import_replays_dependents_without_duplicating_reference_arrays() {
+    let source = "package Q {
+        attribute a = 3;
+        attribute b = 4;
+        dependency D from a, b to a, b;
+    }
+    package P { public import Q::*; attribute total = a + b; }";
+    let original = Session::from_sources(vec![("p.sysml".into(), source.into())]).unwrap();
+    let (mut document, _) = foreignize(&original.to_compact_json());
+    let namespace = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Q")
+        .unwrap();
+    namespace.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    assert!(model.resolve_qualified("P::a").is_some());
+    assert!(matches!(
+        model.evaluate_qualified("P::total"),
+        Ok(sysmlv2_model::eval::Value::Integer(7))
+    ));
+    assert_eq!(model.unresolved_count(), 0);
+    let output = loaded.to_compact_json();
+    let dependency = output
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|e| e["@type"] == "Dependency")
+        .unwrap();
+    assert_eq!(dependency["client"].as_array().unwrap().len(), 2);
+    assert_eq!(dependency["supplier"].as_array().unwrap().len(), 2);
+}
+
+#[test]
+fn loaded_identity_spelling_does_not_capture_a_distinct_uuid_named_type() {
+    let target_id = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"anonymous-type").to_string();
+    let source = format!(
+        "package P {{
+        part def Anonymous;
+        part def '{target_id}';
+        part anonymous : Anonymous;
+        part named : '{target_id}';
+    }}"
+    );
+    let original = Session::from_sources(vec![("p.sysml".into(), source)]).unwrap();
+    let mut document = original.to_compact_json();
+    let target = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Anonymous")
+        .unwrap();
+    let old_id = target["@id"].as_str().unwrap().to_owned();
+    target.as_object_mut().unwrap().remove("declaredName");
+    // Substitute the anonymous type's identity consistently in the payload.
+    fn replace(value: &mut Value, old: &str, new: &str) {
+        match value {
+            Value::String(s) if s == old => *s = new.to_owned(),
+            Value::Array(a) => a.iter_mut().for_each(|v| replace(v, old, new)),
+            Value::Object(o) => o.values_mut().for_each(|v| replace(v, old, new)),
+            _ => {}
+        }
+    }
+    replace(&mut document, &old_id, &target_id);
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    for iteration in 0..2 {
+        let model = loaded.resolved();
+        let anonymous = model.resolve_qualified("P::anonymous").unwrap();
+        let named = model.resolve_qualified("P::named").unwrap();
+        let target = model.element_by_id(&target_id).unwrap();
+        let lexical = model
+            .resolve_qualified(&format!("P::'{target_id}'"))
+            .unwrap();
+        assert_ne!(target, lexical);
+        assert_eq!(model.typings(anonymous), vec![target]);
+        assert_eq!(model.typings(named), vec![lexical]);
+        if iteration == 0 {
+            let p = loaded.resolved().resolve_qualified("P").unwrap();
+            let mut edit = loaded.edit();
+            edit.insert_member(p, "part unrelated;");
+            edit.commit().unwrap();
+        }
+    }
+}
+
+#[test]
+fn later_document_root_scope_restores_anonymous_typing() {
+    let original = Session::from_sources(vec![
+        ("one.sysml".into(), "part initialPart;".into()),
+        ("two.sysml".into(), "part def Base; part p : Base;".into()),
+    ])
+    .unwrap();
+    let mut document = original.to_compact_json();
+    let base = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Base")
+        .unwrap();
+    let id = base["@id"].as_str().unwrap().to_owned();
+    base.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let base = model.element_by_id(&id).unwrap();
+    let p = model.resolve_qualified("p").unwrap();
+    assert_eq!(model.typings(p), vec![base]);
+    assert!(model.conforms(p, base));
+}
+
+#[test]
+fn inherited_default_with_anonymous_reference_preserves_its_identity() {
+    let original = Session::from_sources(vec![("p.sysml".into(),
+        "package P { attribute original = 7; part def Base { attribute value default = original; } part def Child :> Base { attribute result :>> value; } }".into())]).unwrap();
+    let mut document = original.to_compact_json();
+    let original = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "original")
+        .unwrap();
+    original.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    assert!(matches!(
+        loaded.resolved().evaluate_qualified("P::Child::result"),
+        Ok(sysmlv2_model::eval::Value::Integer(7))
+    ));
+}
+
+#[test]
+fn equal_spans_in_distinct_documents_do_not_confuse_identity_and_lexical_references() {
+    let target_id = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"anonymous-type").to_string();
+    let original = Session::from_sources(vec![
+        ("one.sysml".into(), "part aLong : Anonymous;".into()),
+        ("two.sysml".into(), format!("part ab : '{target_id}';")),
+        (
+            "defs.sysml".into(),
+            format!("part def Anonymous; part def '{target_id}';"),
+        ),
+    ])
+    .unwrap();
+    let mut document = original.to_compact_json();
+    let target = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Anonymous")
+        .unwrap();
+    let old = target["@id"].as_str().unwrap().to_owned();
+    target.as_object_mut().unwrap().remove("declaredName");
+    let mut document = serde_json::from_str::<Value>(
+        &serde_json::to_string(&document)
+            .unwrap()
+            .replace(&old, &target_id),
+    )
+    .unwrap();
+    // Ensure no declared name or target spelling is normalized away.
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let target = model.element_by_id(&target_id).unwrap();
+    let lexical = model.resolve_qualified(&format!("'{target_id}'")).unwrap();
+    let a = model.resolve_qualified("aLong").unwrap();
+    let b = model.resolve_qualified("ab").unwrap();
+    assert_eq!(model.typings(a), vec![target]);
+    assert_eq!(model.typings(b), vec![lexical]);
+    let identity_site = model
+        .references_to(target)
+        .into_iter()
+        .find(|s| s.kind == "type")
+        .unwrap();
+    let lexical_site = model
+        .references_to(lexical)
+        .into_iter()
+        .find(|s| s.kind == "type")
+        .unwrap();
+    assert_eq!(identity_site.name_span, lexical_site.name_span);
+    assert_ne!(identity_site.unit, lexical_site.unit);
+    document.as_array_mut().unwrap().reverse();
+    let mut reordered = Session::from_interchange_json(&document).unwrap();
+    let model = reordered.resolved();
+    let a = model.resolve_qualified("aLong").unwrap();
+    let target = model.element_by_id(&target_id).unwrap();
+    assert_eq!(model.typings(a), vec![target]);
+}
+
+#[test]
+fn cross_document_alias_keeps_its_anonymous_target_provenance() {
+    let original = Session::from_sources(vec![
+        ("defs.sysml".into(), "package Defs { part def Base { attribute mass = 7; } alias Alias for Base; }".into()),
+        ("uses.sysml".into(), "package Uses { part p : Defs::Alias[1]; attribute total = p.mass; public import Defs::Alias; part q : Alias; }".into()),
+    ]).unwrap();
+    let mut document = original.to_compact_json();
+    let base = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Base")
+        .unwrap();
+    let base_id = base["@id"].as_str().unwrap().to_owned();
+    base.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let base = model.element_by_id(&base_id).unwrap();
+    assert_eq!(model.resolve_qualified("Defs::Alias"), Some(base));
+    let p = model.resolve_qualified("Uses::p").unwrap();
+    let q = model.resolve_qualified("Uses::q").unwrap();
+    assert_eq!(model.typings(p), vec![base]);
+    assert_eq!(model.typings(q), vec![base]);
+    assert!(
+        matches!(
+            model.evaluate_qualified("Uses::total"),
+            Ok(sysmlv2_model::eval::Value::Integer(7))
+        ),
+        "{:?}",
+        model.evaluate_qualified("Uses::total")
+    );
+}
+
+#[test]
+fn uuid_shaped_unresolved_names_keep_legacy_identity_recovery() {
+    let original = Session::from_sources(vec![(
+        "p.sysml".into(),
+        "package P { part def Base; part p : Base; part lexical : Missing; }".into(),
+    )])
+    .unwrap();
+    let mut document = original.to_compact_json();
+    let base = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "Base")
+        .unwrap();
+    base.as_object_mut().unwrap().remove("declaredName");
+    let spelling = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"unresolved-name").to_string();
+    for element in document.as_array_mut().unwrap() {
+        if element["@type"] == "FeatureTyping" && element["type"].get("@ref").is_some() {
+            element["type"] = serde_json::json!({"@ref":format!("'{spelling}'")});
+        }
+    }
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    assert_eq!(model.unresolved_count(), 0);
+    let lexical = model.resolve_qualified("P::lexical").unwrap();
+    let typing = model
+        .owned_relationships(lexical)
+        .into_iter()
+        .find(|e| model.element_type(*e) == "FeatureTyping")
+        .unwrap();
+    assert_eq!(model.element_properties(typing)["type"]["@id"], spelling);
+    assert!(model.typings(lexical).is_empty());
+}
+
+#[test]
+fn identity_resolution_follows_explicit_id_overrides_after_loading() {
+    let original = Session::from_sources(vec![(
+        "p.sysml".into(),
+        "package P { attribute original = 7; attribute answer = original; }".into(),
+    )])
+    .unwrap();
+    let mut document = original.to_compact_json();
+    let target = document
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["declaredName"] == "original")
+        .unwrap();
+    let old = Uuid::parse_str(target["@id"].as_str().unwrap()).unwrap();
+    target.as_object_mut().unwrap().remove("declaredName");
+    let mut loaded = Session::from_interchange_json(&document).unwrap();
+    let model = loaded.resolved();
+    let new = Uuid::new_v5(&Uuid::NAMESPACE_OID, b"replacement-identity");
+    model.override_ids(&HashMap::from([(old, new)]));
+    assert!(model.element_by_id(&old.to_string()).is_none());
+    assert!(model.element_by_id(&new.to_string()).is_some());
+    assert!(matches!(
+        model.evaluate_qualified("P::answer"),
+        Ok(sysmlv2_model::eval::Value::Integer(7))
+    ));
+}
+#[test]
+fn sysml_generated_binding_full_json_and_cbor_preserve_source_and_foreign_ids() {
+    let source = Session::from_sources(vec![(
+        "reference.sysml".into(),
+        "part def Container { attribute n; attribute x=n; }".into(),
+    )])
+    .unwrap();
+    let original = source.to_compact_json();
+    for foreign in [false, true] {
+        // Foreignize only authored compact rows: generated identities should
+        // be derived from their preserved owners, not imported as source IDs.
+        let compact = if foreign {
+            foreignize(&original).0
+        } else {
+            original.clone()
+        };
+        let session =
+            Session::from_interchange_json_named(&compact, None, &["reference.sysml".into()])
+                .unwrap();
+        assert!(session.warnings().is_empty(), "{:?}", session.warnings());
+        assert_eq!(by_id(&session.to_compact_json()), by_id(&compact));
+        let full = session.to_full_json_with(false);
+        assert!(
+            full.as_array()
+                .unwrap()
+                .iter()
+                .any(|row| { row["@type"] == "BindingConnector" && row["isImplied"] == true })
+        );
+        let binary = session.to_full_cbor(false);
+        let decoded = session.decode_cbor(&binary).unwrap();
+        assert_eq!(by_id(&decoded), by_id(&full));
+        for payload in [&full, &decoded] {
+            let lifted = sysmlv2_model::lift::from_compact_json(payload).unwrap();
+            assert!(lifted.errors.is_empty(), "{:?}", lifted.errors);
+            assert_eq!(lifted.unit.dialect, sysmlv2_syntax::ast::Dialect::Sysml);
+            let loaded =
+                Session::from_interchange_json_named(payload, None, &["reference.sysml".into()])
+                    .unwrap();
+            assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+            assert_eq!(by_id(&loaded.to_compact_json()), by_id(&compact));
+            assert_eq!(by_id(&loaded.to_full_json_with(false)), by_id(&full));
+        }
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/settled_outcomes.rs b/crates/sysmlv2-transform/tests/settled_outcomes.rs
new file mode 100644
index 0000000..1402431
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/settled_outcomes.rs
@@ -0,0 +1,129 @@
+//! A session started from the outcomes a previous session settled on
+//! answers as a session built cold does: the corpus's Vehicle example on
+//! the prepared standard library, rebuilt after an edit to each of its
+//! units in turn — a comment appended, which changes no outcome, and the
+//! unit emptied, which unresolves every reference into it.
+
+use std::path::{Path, PathBuf};
+use sysmlv2_transform::{Library, Session};
+
+fn units_under(dir: &Path) -> Vec<(String, String)> {
+    let mut files = Vec::new();
+    let mut stack = vec![dir.to_path_buf()];
+    while let Some(dir) = stack.pop() {
+        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                stack.push(path);
+            } else if matches!(
+                path.extension().and_then(|e| e.to_str()),
+                Some("sysml" | "kerml")
+            ) {
+                files.push(path);
+            }
+        }
+    }
+    files.sort();
+    files
+        .into_iter()
+        .map(|p| {
+            let name = p.strip_prefix(dir).unwrap().display().to_string();
+            (name, std::fs::read_to_string(&p).unwrap())
+        })
+        .collect()
+}
+
+/// The standard library prepared from the corpus, and the Vehicle example's
+/// units; `None` when the corpus is not initialized.
+fn fixture() -> Option<(Library, Vec<(String, String)>)> {
+    let root = sysmlv2_testkit::workspace_root().join("spec-refs/SysML-v2-Release");
+    let example: PathBuf = root.join("sysml/src/examples/Vehicle Example");
+    if !example.exists() {
+        eprintln!("corpus not initialized; skipping");
+        return None;
+    }
+    let mut library = units_under(&root.join("sysml.library"));
+    library.extend(sysmlv2_model::ambient::units());
+    let library = Library::prepared_sources(library, None).unwrap();
+    Some((library, units_under(&example)))
+}
+
+/// What a session answers: its full and compact interchange documents,
+/// its findings and its unresolved references.
+fn answers(session: &mut Session) -> String {
+    let mut out = serde_json::to_string(&session.to_full_json()).unwrap();
+    out.push('\n');
+    out.push_str(&serde_json::to_string(&session.to_compact_json()).unwrap());
+    for finding in session.check_findings() {
+        out.push_str(&format!(
+            "\n{:?} {:?} {}:{}:{} {}",
+            finding.severity,
+            finding.stage,
+            finding.unit,
+            finding.line,
+            finding.col,
+            finding.message
+        ));
+    }
+    for unresolved in session.resolved().unresolved_references() {
+        out.push_str(&format!("\n{unresolved:?}"));
+    }
+    out
+}
+
+#[test]
+fn a_seeded_session_answers_as_a_cold_one_after_every_edit() {
+    let Some((library, units)) = fixture() else {
+        return;
+    };
+    assert!(units.len() >= 3, "the example has several units");
+    let mut cold =
+        Session::from_sources_with_library(units.clone(), Some(library.clone())).unwrap();
+    let settled = cold
+        .settled_outcomes()
+        .expect("a cold build on the prepared library settles");
+    assert_eq!(settled.unit_count(), units.len());
+    // the same units again
+    let mut same =
+        Session::from_sources_settled(units.clone(), Some(library.clone()), Some(settled.clone()))
+            .unwrap();
+    assert_eq!(answers(&mut same), answers(&mut cold));
+    assert!(same.settled_outcomes().is_some());
+    for i in 0..units.len() {
+        for edit in ["comment", "emptied"] {
+            let mut edited = units.clone();
+            match edit {
+                "comment" => edited[i].1.push_str("\n// edited\n"),
+                _ => edited[i].1 = "package Edited;".to_string(),
+            }
+            let mut cold =
+                Session::from_sources_with_library(edited.clone(), Some(library.clone())).unwrap();
+            // from the unedited build's outcomes
+            let mut seeded = Session::from_sources_settled(
+                edited.clone(),
+                Some(library.clone()),
+                Some(settled.clone()),
+            )
+            .unwrap();
+            assert_eq!(
+                answers(&mut seeded),
+                answers(&mut cold),
+                "unit {} {edit}",
+                units[i].0
+            );
+            // and back from the edited build's
+            let mut back = Session::from_sources_settled(
+                units.clone(),
+                Some(library.clone()),
+                seeded.settled_outcomes(),
+            )
+            .unwrap();
+            assert_eq!(
+                answers(&mut back),
+                answers(&mut same),
+                "unit {} {edit}, back",
+                units[i].0
+            );
+        }
+    }
+}
diff --git a/crates/sysmlv2-transform/tests/text_reference_spelling.rs b/crates/sysmlv2-transform/tests/text_reference_spelling.rs
new file mode 100644
index 0000000..d8b6575
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/text_reference_spelling.rs
@@ -0,0 +1,207 @@
+//! Textual UUID-shaped names retain lexical meaning through interchange.
+use serde_json::{Value, json};
+use std::collections::HashMap;
+use sysmlv2_model::{json::ResolvedModel, model::Model};
+use sysmlv2_transform::{Library, Session};
+
+const LIBRARY: &str = "standard library package Lib { feature visible; }";
+const MISSING: &str = "88888888-8888-4888-8888-888888888888";
+
+fn library() -> Library {
+    Library::sources(vec![("lib.kerml".into(), LIBRARY.into())])
+}
+
+fn library_target_id() -> String {
+    let mut model = Model::new();
+    model.add_library_source("lib.kerml", LIBRARY);
+    let mut resolved = ResolvedModel::build(&model);
+    let target = resolved.resolve_qualified("Lib::visible").unwrap();
+    resolved.element_id(target).to_string()
+}
+
+fn rows(value: &Value) -> HashMap<String, Value> {
+    value
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|row| (row["@id"].as_str().unwrap().to_owned(), row.clone()))
+        .collect()
+}
+
+fn load(value: &Value, lib: Option<&Library>) -> Session {
+    Session::from_interchange_json_named(value, lib, &["u.kerml".into()]).unwrap()
+}
+
+fn text(source: String, lib: Option<Library>) -> Session {
+    Session::from_sources_with_library(vec![("u.kerml".into(), source)], lib).unwrap()
+}
+
+#[test]
+fn text_uuid_name_stays_unresolved_before_and_after_loading_its_namesake_identity() {
+    let id = library_target_id();
+    let spelling = format!("'{id}'");
+    let mut session = text(format!("package P {{ feature value = {spelling}; }}"), None);
+    let compact = session.to_compact_json();
+    assert_eq!(session.resolved().unresolved_count(), 1);
+    let full = session.to_full_json();
+    assert!(full.as_array().unwrap().iter().any(|e| {
+        e["language"] == sysmlv2_model::full::UNRESOLVED_REP_LANGUAGE && e["body"] == spelling
+    }));
+    let dangling = sysmlv2_model::json::dangling_id(&spelling);
+    assert!(
+        full.as_array()
+            .unwrap()
+            .iter()
+            .any(|e| { e["@type"] == "Membership" && e["memberElement"]["@id"] == dangling })
+    );
+    assert_ne!(dangling, id);
+    let mut recovered = load(&full, None);
+    assert!(
+        recovered.warnings().is_empty(),
+        "{:?}",
+        recovered.warnings()
+    );
+    assert_eq!(recovered.resolved().unresolved_count(), 1);
+    assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+    recovered.load_library_from(library()).unwrap();
+    assert_eq!(recovered.resolved().unresolved_count(), 1);
+    assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+    assert!(recovered.resolved().element_by_id(&id).is_some());
+    assert_eq!(
+        rows(&full),
+        rows(&session.decode_cbor(&session.to_full_cbor(true)).unwrap())
+    );
+}
+
+#[test]
+fn text_resolved_and_unresolved_uuid_names_keep_lexical_meaning_with_library() {
+    let id = library_target_id();
+    let source = format!(
+        "package P {{ feature '{id}'; feature lexical = '{id}'; feature missing = '{MISSING}'; }} \
+         package Other {{ feature disguised = '{id}'; }}"
+    );
+    let mut session = text(source, Some(library()));
+    let compact = session.to_compact_json();
+    assert_eq!(session.resolved().unresolved_count(), 2);
+    let lexical = session
+        .resolved()
+        .resolve_qualified(&format!("P::'{id}'"))
+        .unwrap();
+    assert_ne!(session.resolved().element_id(lexical).to_string(), id);
+    let full = session.to_full_json();
+    let mut recovered = load(&full, Some(&library()));
+    assert!(
+        recovered.warnings().is_empty(),
+        "{:?}",
+        recovered.warnings()
+    );
+    assert_eq!(recovered.resolved().unresolved_count(), 2);
+    assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+    assert_eq!(rows(&full), rows(&recovered.to_full_json()));
+}
+
+fn remap_user_ids(value: &mut Value) {
+    let replacements: HashMap<_, _> = value
+        .as_array()
+        .unwrap()
+        .iter()
+        .enumerate()
+        .map(|(i, e)| {
+            (
+                e["@id"].as_str().unwrap().to_owned(),
+                format!("66666666-6666-4666-8666-{i:012x}"),
+            )
+        })
+        .collect();
+    fn rewrite(value: &mut Value, replacements: &HashMap<String, String>) {
+        match value {
+            Value::Object(object) => {
+                for (key, value) in object {
+                    if matches!(key.as_str(), "@id" | "elementId") {
+                        if let Some(replacement) = value.as_str().and_then(|s| replacements.get(s))
+                        {
+                            *value = Value::String(replacement.clone());
+                        }
+                    } else {
+                        rewrite(value, replacements);
+                    }
+                }
+            }
+            Value::Array(items) => {
+                for item in items {
+                    rewrite(item, replacements);
+                }
+            }
+            _ => {}
+        }
+    }
+    rewrite(value, &replacements);
+}
+
+#[test]
+fn nonfallback_payloads_preserve_uuid_names_with_derived_and_foreign_user_ids() {
+    let id = library_target_id();
+    for foreign in [false, true] {
+        let session = text(
+            format!("package P {{ feature value = '{id}'; }}"),
+            Some(library()),
+        );
+        let mut compact = session.to_compact_json();
+        if foreign {
+            remap_user_ids(&mut compact);
+        }
+        let mut loaded = load(&compact, Some(&library()));
+        assert_eq!(loaded.has_explicit_ids(), foreign);
+        assert!(loaded.warnings().is_empty(), "{:?}", loaded.warnings());
+        assert_eq!(loaded.resolved().unresolved_count(), 1);
+        assert_eq!(rows(&compact), rows(&loaded.to_compact_json()));
+        let compact_bytes = loaded.to_compact_cbor();
+        let mut binary = Session::from_compact_cbor_with(&compact_bytes, Some(&library())).unwrap();
+        assert!(binary.warnings().is_empty(), "{:?}", binary.warnings());
+        assert_eq!(binary.resolved().unresolved_count(), 1);
+        assert_eq!(rows(&compact), rows(&binary.to_compact_json()));
+        let full = loaded.to_full_json();
+        let mut recovered = load(&full, Some(&library()));
+        assert!(
+            recovered.warnings().is_empty(),
+            "{:?}",
+            recovered.warnings()
+        );
+        assert_eq!(recovered.resolved().unresolved_count(), 1);
+        assert_eq!(rows(&compact), rows(&recovered.to_compact_json()));
+        assert_eq!(rows(&full), rows(&recovered.to_full_json()));
+        assert_eq!(
+            rows(&full),
+            rows(&loaded.decode_cbor(&loaded.to_full_cbor(true)).unwrap())
+        );
+    }
+}
+
+#[test]
+fn legacy_payload_identity_fallback_keeps_existing_uuid_interpretation() {
+    let session = text(
+        format!("package P {{ feature value = '{MISSING}'; }}"),
+        None,
+    );
+    let mut payload = session.to_compact_json();
+    let membership = payload
+        .as_array_mut()
+        .unwrap()
+        .iter_mut()
+        .find(|e| e["@type"] == "Membership" && e["memberElement"].get("@ref").is_some())
+        .unwrap();
+    membership["memberElement"] = json!({"@id": MISSING});
+    let loaded = load(&payload, None);
+    assert_eq!(rows(&payload), rows(&loaded.to_compact_json()));
+    let full = loaded.to_full_json();
+    assert!(
+        full.as_array()
+            .unwrap()
+            .iter()
+            .any(|e| { e["@type"] == "Membership" && e["memberElement"]["@id"] == MISSING })
+    );
+    assert!(!full.as_array().unwrap().iter().any(|e| {
+        e["language"] == sysmlv2_model::full::UNRESOLVED_REP_LANGUAGE
+            && e["body"] == format!("'{MISSING}'")
+    }));
+}
diff --git a/crates/sysmlv2-transform/tests/transform.rs b/crates/sysmlv2-transform/tests/transform.rs
index cb6e078..f063ff1 100644
--- a/crates/sysmlv2-transform/tests/transform.rs
+++ b/crates/sysmlv2-transform/tests/transform.rs
@@ -993,7 +993,7 @@ fn move_member_reorders_within_owner() {
     let front_at = t.find("part front : Wheel;").unwrap();
     assert!(spare_at < front_at, "order not swapped:\n{t}");
     // Named members chain past their membership's ordinal (IDS.md,
-    // id scheme 1), so reordering named siblings moves **no**
+    // id scheme 2), so reordering named siblings moves **no**
     // ids at all — selections in UIs survive the reorder unmapped.
     // (Positional members would still remap; `Vehicle`'s parts are
     // all named.)
diff --git a/crates/sysmlv2-transform/tests/type_inputs.rs b/crates/sysmlv2-transform/tests/type_inputs.rs
new file mode 100644
index 0000000..4b6604a
--- /dev/null
+++ b/crates/sysmlv2-transform/tests/type_inputs.rs
@@ -0,0 +1,55 @@
+use sysmlv2_transform::{GraphFormat, Indent, Library, ModelHandle, Session};
+
+fn inputs(s: &mut Session) -> Vec<String> {
+    let r = s.resolved();
+    let f = r.resolve_qualified("G").unwrap();
+    r.type_input_report(f)
+        .inputs
+        .unwrap()
+        .into_iter()
+        .map(|e| r.element_id(e).to_string())
+        .collect()
+}
+#[test]
+fn checked_inputs_survive_full_json_replay_and_session_rename() {
+    for format in [GraphFormat::LegacyV2, GraphFormat::CanonicalV3] {
+        let mut model = ModelHandle::with_graph_format(format);
+        model
+            .load_library_dir(&sysmlv2_testkit::library_dir())
+            .unwrap();
+        let lib = Library::Prepared(model.prepare_library().unwrap());
+        let mut s = Session::from_sources_with_graph_format(
+            vec![(
+                "inputs.kerml".into(),
+                "function F { in a; inout b; return answer; } function G specializes F;".into(),
+            )],
+            Some(lib.clone()),
+            format,
+        )
+        .unwrap();
+        let expected = inputs(&mut s);
+        let full = s.to_full_json();
+        let mut replay = Session::from_interchange_json_with_graph_format(
+            &full,
+            Some(&lib),
+            &["inputs.kerml".into()],
+            Indent::default(),
+            format,
+        )
+        .unwrap();
+        assert!(replay.warnings().is_empty(), "{:?}", replay.warnings());
+        assert_eq!(inputs(&mut replay), expected);
+        let a = replay.resolved().resolve_qualified("F::a").unwrap();
+        let mut edit = replay.edit();
+        edit.rename(a, "renamed");
+        edit.commit().unwrap();
+        let expected = ["F::renamed", "F::b"]
+            .into_iter()
+            .map(|name| {
+                let e = replay.resolved().resolve_qualified(name).unwrap();
+                replay.resolved().element_id(e).to_string()
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(inputs(&mut replay), expected);
+    }
+}
diff --git a/crates/sysmlv2-viz/Cargo.toml b/crates/sysmlv2-viz/Cargo.toml
index f432ce9..7d99942 100644
--- a/crates/sysmlv2-viz/Cargo.toml
+++ b/crates/sysmlv2-viz/Cargo.toml
@@ -19,8 +19,8 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-sysmlv2-model = { path = "../sysmlv2-model", version = "0.9.1" }
-sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.9.1" }
+sysmlv2-model = { path = "../sysmlv2-model", version = "0.10.0" }
+sysmlv2-syntax = { path = "../sysmlv2-syntax", version = "0.10.0" }
 serde.workspace = true
 serde_json.workspace = true
 
diff --git a/crates/sysmlv2-viz/README.md b/crates/sysmlv2-viz/README.md
index 8922987..a2b74df 100644
--- a/crates/sysmlv2-viz/README.md
+++ b/crates/sysmlv2-viz/README.md
@@ -44,4 +44,4 @@ reset that context; unresolved markers do not become initial transitions.
 
 ## License
 
-Apache License 2.0 — Copyright 2026 Open-MBEE.
+Apache License 2.0 — Copyright 2026 Planetary Utilities.
diff --git a/crates/sysmlv2-viz/src/lib.rs b/crates/sysmlv2-viz/src/lib.rs
index 5ae921c..6741f3d 100644
--- a/crates/sysmlv2-viz/src/lib.rs
+++ b/crates/sysmlv2-viz/src/lib.rs
@@ -48,7 +48,7 @@ mod sequence;
 
 pub use graph::{GraphError, graph};
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt;
 use std::fmt::Write as _;
 use std::str::FromStr;
@@ -428,14 +428,19 @@ impl VizOptions {
     }
 }
 
-/// What a *view usage* directs: the rendering style its `render` member
-/// requests (when it maps onto a PlantUML view) and the diagram roots its
+/// What a *view usage* directs: the rendering style its rendering
+/// requests (when it maps onto a PlantUML view) — its own `render`
+/// member's, else the one it inherits, as
+/// [`ResolvedModel::view_rendering`] reads it — and the diagram roots its
 /// `expose`/`filter` members admit. Exposure reduces to the finest
 /// exposed granularity — an exposed container whose members are also
 /// individually exposed yields the members (so filtered-out siblings
 /// stay off the diagram) — and connector end features and metadata
-/// usages drop (they render through their owners). `None` when the
-/// element is not a view usage.
+/// usages drop (they render through their owners). So does a member the
+/// view reaches only through inheritance: a type's visible members
+/// include the ones it inherits, so exposing `amp : Amp` exposes `Amp`'s
+/// ports too, and they render on `amp`'s own box rather than beside it.
+/// `None` when the element is not a view usage.
 pub fn view_directed(
     r: &mut ResolvedModel,
     view: ElementRef,
@@ -448,20 +453,35 @@ pub fn view_directed(
         Some("asInterconnectionDiagram") => Some(View::Interconnection),
         _ => None,
     };
+    let exposed = r.view_exposed_elements(view);
+    // Only a member no expose reaches through ownership can have arrived
+    // through inheritance; the inheritance walk runs only when one did.
+    let reach = ExposeReach::of(r, view);
+    let unowned: HashSet<ElementRef> = exposed
+        .iter()
+        .copied()
+        .filter(|&x| !reach.owns(r, x))
+        .collect();
+    let inherited = if unowned.is_empty() {
+        HashSet::new()
+    } else {
+        reach.inherited_members(r, &exposed)
+    };
     // Connector end features and metadata usages drop *before* the
     // granularity pass — they render through their owners, and an
     // exposed connector must not read as a container just because its
-    // own ends were enumerated.
-    let exposed: Vec<ElementRef> = r
-        .view_exposed_elements(view)
+    // own ends were enumerated. Inherited members drop there as well, so
+    // a definition the view exposes whole is not taken apart for them.
+    let exposed: Vec<ElementRef> = exposed
         .into_iter()
         .filter(|&x| {
             r.element_type(x) != "MetadataUsage"
                 && r.owning_membership_type(x) != Some("EndFeatureMembership")
+                && !(unowned.contains(&x) && inherited.contains(&x))
         })
         .collect();
-    let set: std::collections::HashSet<ElementRef> = exposed.iter().copied().collect();
-    let mut coarse: std::collections::HashSet<ElementRef> = std::collections::HashSet::new();
+    let set: HashSet<ElementRef> = exposed.iter().copied().collect();
+    let mut coarse: HashSet<ElementRef> = HashSet::new();
     for &x in &exposed {
         let mut cur = r.owner(x);
         while let Some(o) = cur {
@@ -478,6 +498,131 @@ pub fn view_directed(
     Some((style, roots))
 }
 
+/// How a view's own `expose` relationships reach elements through
+/// ownership. `expose x;` names `x`; `expose x::*;` lists the members
+/// `x` owns; the `::**` forms also list everything owned below those,
+/// and `expose x::**;` names `x` as well. A bracket filter wraps the
+/// import that names the target in a package of its own, owned by the
+/// expose, which the reach reads through.
+#[derive(Default)]
+struct ExposeReach {
+    /// Elements an expose names.
+    named: HashSet<ElementRef>,
+    /// Namespaces whose owned members an expose lists, each with whether
+    /// the listing descends into the namespaces it lists.
+    listed: BTreeMap<ElementRef, bool>,
+}
+
+impl ExposeReach {
+    fn of(r: &mut ResolvedModel, view: ElementRef) -> ExposeReach {
+        let mut reach = ExposeReach::default();
+        for rel in r.owned_relationships(view) {
+            if !matches!(r.element_type(rel), "NamespaceExpose" | "MembershipExpose") {
+                continue;
+            }
+            let Some(mut target) = import_target(r, rel) else {
+                continue;
+            };
+            // A bracket filter's package: the import it holds names the
+            // actual target.
+            if r.owning_membership_type(target.0) == Some("NamespaceExpose") {
+                let inner = r
+                    .owned_relationships(target.0)
+                    .into_iter()
+                    .find_map(|inner| import_target(r, inner));
+                let Some(inner) = inner else {
+                    continue;
+                };
+                target = inner;
+            }
+            let (element, namespace, recursive) = target;
+            if !namespace {
+                reach.named.insert(element);
+            }
+            if namespace || recursive {
+                *reach.listed.entry(element).or_default() |= recursive;
+            }
+        }
+        reach
+    }
+
+    /// Whether an expose reaches `x` through ownership.
+    fn owns(&self, r: &mut ResolvedModel, x: ElementRef) -> bool {
+        if self.named.contains(&x) {
+            return true;
+        }
+        let mut direct = true;
+        let mut cur = r.owner(x);
+        while let Some(o) = cur {
+            if self.listed.get(&o).is_some_and(|&deep| deep || direct) {
+                return true;
+            }
+            direct = false;
+            cur = r.owner(o);
+        }
+        false
+    }
+
+    /// The members inherited by everything the exposure enumerates:
+    /// each listed namespace (a plain `x::*` takes in `x`'s implied
+    /// library heritage too), everything a descending listing owns —
+    /// including what the view's conditions reject, whose admitted
+    /// members stay exposed — and every exposed element, which covers
+    /// namespaces reached through imports.
+    fn inherited_members(
+        &self,
+        r: &mut ResolvedModel,
+        exposed: &[ElementRef],
+    ) -> HashSet<ElementRef> {
+        let mut visits: Vec<(ElementRef, bool)> =
+            self.listed.keys().map(|&ns| (ns, true)).collect();
+        let mut below: Vec<ElementRef> = self
+            .listed
+            .iter()
+            .filter(|&(_, &deep)| deep)
+            .map(|(&ns, _)| ns)
+            .collect();
+        let mut seen: HashSet<ElementRef> = below.iter().copied().collect();
+        while let Some(ns) = below.pop() {
+            for member in r.owned_members(ns) {
+                if seen.insert(member) {
+                    visits.push((member, false));
+                    below.push(member);
+                }
+            }
+        }
+        visits.extend(
+            exposed
+                .iter()
+                .filter(|x| !seen.contains(x))
+                .map(|&x| (x, false)),
+        );
+        let mut members = HashSet::new();
+        for (e, implied) in visits {
+            for membership in r.inherited_memberships(e, implied) {
+                members.extend(r.membership_member(membership));
+            }
+        }
+        members
+    }
+}
+
+/// What an import-family relationship targets — a membership read
+/// through to its member — with whether it lists the target's members
+/// (`::*`) and whether it descends (`::**`).
+fn import_target(r: &mut ResolvedModel, rel: ElementRef) -> Option<(ElementRef, bool, bool)> {
+    let (namespace, key) = match r.element_type(rel) {
+        "NamespaceImport" | "NamespaceExpose" => (true, "importedNamespace"),
+        "MembershipImport" | "MembershipExpose" => (false, "importedMembership"),
+        _ => return None,
+    };
+    let props = r.element_properties(rel);
+    let recursive = props.get("isRecursive").and_then(|v| v.as_bool()) == Some(true);
+    let target = r.element_by_id(props.get(key)?.get("@id")?.as_str()?)?;
+    let target = r.membership_member(target).unwrap_or(target);
+    Some((target, namespace, recursive))
+}
+
 /// Emit the configured view of `root` (or of every top-level user
 /// element when `root` is `None`) as PlantUML text.
 pub fn plantuml(r: &mut ResolvedModel, root: Option<ElementRef>, opts: &VizOptions) -> String {
diff --git a/crates/sysmlv2-viz/tests/viz.rs b/crates/sysmlv2-viz/tests/viz.rs
index a500182..9c92aba 100644
--- a/crates/sysmlv2-viz/tests/viz.rs
+++ b/crates/sysmlv2-viz/tests/viz.rs
@@ -1056,7 +1056,10 @@ fn graph_state_view_pseudostates_and_transition_identity() {
 /// to its individually exposed members, so filtered-out siblings stay
 /// off the canvas) and `render` picks the style. Metadata-filtered
 /// connectors disappear as edges; the kept connector still draws
-/// between the kept parts' ports.
+/// between the kept parts' ports. The ports the parts inherit from
+/// their definitions are exposed too, since a part's visible members
+/// include its inherited ones, but they draw once, on each part's box,
+/// never again as boxes of their own.
 #[test]
 fn view_directed_rendering() {
     let src = "package VD {
@@ -1076,6 +1079,10 @@ fn view_directed_rendering() {
             expose stage::**;
             filter not (@LOUD);
         }
+        view whole {
+            expose Amp;
+            expose stage::**;
+        }
     }";
     let mut r = resolved(src);
     let view = r.resolve_qualified("VD::quiet").expect("view resolves");
@@ -1084,12 +1091,19 @@ fn view_directed_rendering() {
     assert_eq!(style, None);
     let names: Vec<String> = roots
         .iter()
-        .filter_map(|&e| r.element_qualified_name(e))
+        .map(|&e| {
+            r.element_qualified_name(e)
+                .unwrap_or_else(|| r.element_type(e).to_string())
+        })
         .collect();
-    assert!(
-        names.contains(&"VD::stage::amp".to_string())
-            && names.contains(&"VD::stage::main".to_string()),
-        "{names:?}"
+    assert_eq!(
+        names,
+        [
+            "VD::stage::amp",
+            "VD::stage::main",
+            "VD::stage::monitor",
+            "InterfaceUsage"
+        ]
     );
     let opts = VizOptions::default()
         .with_view(View::Interconnection)
@@ -1099,15 +1113,151 @@ fn view_directed_rendering() {
     // LOUD-tagged one is filtered off. The untagged parts (including
     // `monitor`) all stay — only a provably-matching condition hides a
     // member — and the `stage` wrapper defers to its exposed members
-    // (no duplicate subtrees).
-    assert_eq!(out.matches("«interface»").count(), 1, "{out}");
-    assert!(out.contains("monitor : Speaker"), "{out}");
-    assert!(!out.contains("\"stage\""), "{out}");
+    // (no duplicate subtrees). Each part's box carries its definition's
+    // ports, and those are the only port nodes.
+    assert_eq!(
+        out,
+        r#"@startuml
+rectangle "amp : Amp" as n1 <<part>> {
+  port "line : Jack" as n2
+  port "aux : Jack" as n3
+}
+rectangle "main : Speaker" as n4 <<part>> {
+  port "feed : Jack" as n5
+}
+rectangle "monitor : Speaker" as n6 <<part>> {
+  port "feed : Jack" as n7
+}
+n2 -- n5 : «interface»
+@enduml
+"#
+    );
+    // A definition the view exposes whole stays a node of its own: the
+    // ports `amp` inherits from it do not take it apart.
+    let view = r.resolve_qualified("VD::whole").expect("view resolves");
+    let (_, roots) = sysmlv2_viz::view_directed(&mut r, view).expect("a view usage");
+    let names: Vec<String> = roots
+        .iter()
+        .filter_map(|&e| r.element_qualified_name(e))
+        .collect();
+    assert!(names.contains(&"VD::Amp".to_string()), "{names:?}");
+    assert!(
+        !names
+            .iter()
+            .any(|n| ["VD::Amp::", "VD::Speaker::", "VD::Jack::"]
+                .iter()
+                .any(|owner| n.starts_with(owner))),
+        "{names:?}"
+    );
     // A non-view element answers None.
     let part = r.resolve_qualified("VD::stage").unwrap();
     assert!(sysmlv2_viz::view_directed(&mut r, part).is_none());
 }
 
+/// A view usage without a `render` member of its own takes its style
+/// from the rendering its definition declares; its own `render` member
+/// wins over the inherited one.
+#[test]
+fn view_directed_style_follows_an_inherited_rendering() {
+    let mut r = resolved(
+        "package VI {
+            package Views {
+                rendering asTreeDiagram;
+                rendering asInterconnectionDiagram;
+            }
+            part rig { part amp; }
+            view def Wiring { render Views::asInterconnectionDiagram; }
+            view wiring : Wiring { expose rig; }
+            view outline : Wiring {
+                expose rig;
+                render Views::asTreeDiagram;
+            }
+        }",
+    );
+    let rig = r.resolve_qualified("VI::rig").unwrap();
+    for (name, expected) in [
+        ("VI::wiring", View::Interconnection),
+        ("VI::outline", View::Tree),
+    ] {
+        let view = r.resolve_qualified(name).expect("view resolves");
+        let (style, roots) = sysmlv2_viz::view_directed(&mut r, view).expect("a view usage");
+        assert_eq!(style, Some(expected), "{name}");
+        assert_eq!(roots, vec![rig], "{name}");
+    }
+}
+
+/// Finest granularity follows ownership whatever else inherits: a
+/// definition whose members the view reaches through ownership still
+/// defers to them, so the member its condition rejects stays off the
+/// diagram, though a specialization inherits the same members.
+#[test]
+fn view_directed_owned_members_defer_despite_inheritance() {
+    let mut r = resolved(
+        "package Kit {
+            metadata def LOUD;
+            part def Base { part x; #LOUD part y; }
+            part def Derived :> Base;
+        }
+        package Show {
+            view kit {
+                expose Kit::**;
+                filter not (@Kit::LOUD);
+            }
+        }",
+    );
+    let view = r.resolve_qualified("Show::kit").expect("view resolves");
+    let (_, roots) = sysmlv2_viz::view_directed(&mut r, view).expect("a view usage");
+    let names: Vec<String> = roots
+        .iter()
+        .filter_map(|&e| r.element_qualified_name(e))
+        .collect();
+    assert!(
+        names.contains(&"Kit::Base::x".to_string())
+            && names.contains(&"Kit::Derived".to_string())
+            && !names.contains(&"Kit::Base".to_string()),
+        "{names:?}"
+    );
+    let out = plantuml(&mut r, None, &VizOptions::default().with_roots(Some(roots)));
+    assert!(!out.contains("\"y\""), "{out}");
+}
+
+/// `expose x::*` exposes what `x` inherits besides what it owns, from
+/// the model's own definitions and from the standard library alike.
+/// Those members render through `x`, so the diagram gets `x`'s owned
+/// members only, not a node for every feature a part inherits.
+#[test]
+fn view_directed_leaves_inherited_members_to_their_inheritor() {
+    let lib = sysmlv2_testkit::library_dir();
+    let mut model = Model::new();
+    model.load_library_dir(&lib).expect("library loads");
+    model.add_source(
+        "rig.sysml".to_string(),
+        "package Rig {
+            part def Frame { part brace; }
+            part rig : Frame {
+                part amp;
+                part spare;
+            }
+            view shallow { expose rig::*; }
+        }",
+    );
+    let mut r = ResolvedModel::build(&model);
+    let view = r.resolve_qualified("Rig::shallow").expect("view resolves");
+    let exposed = r.view_exposed_elements(view);
+    let brace = r.resolve_qualified("Rig::Frame::brace").unwrap();
+    assert!(exposed.contains(&brace));
+    assert!(exposed.iter().any(|&e| r.is_library_element(e)));
+    let (_, roots) = sysmlv2_viz::view_directed(&mut r, view).expect("a view usage");
+    let names: Vec<String> = roots
+        .iter()
+        .map(|&e| {
+            r.element_qualified_name(e)
+                .unwrap_or_else(|| r.element_type(e).to_string())
+        })
+        .collect();
+    assert_eq!(names, ["Rig::rig::amp", "Rig::rig::spare"]);
+}
+
 /// Action-view flow anchors: a bare `then x;` succession sources from
 /// the member that precedes it, an inline node declaration
 /// (`then fork;`, `then action last { … }`) resolves the succession
diff --git a/crates/sysmlv2-wasm/Cargo.toml b/crates/sysmlv2-wasm/Cargo.toml
index 6cb051a..ea0effe 100644
--- a/crates/sysmlv2-wasm/Cargo.toml
+++ b/crates/sysmlv2-wasm/Cargo.toml
@@ -29,3 +29,7 @@ sysmlv2-lint.workspace = true
 wasm-bindgen = "0.2"
 # gen-stdlib-bundle only (native tool; gzip emission).
 miniz_oxide.workspace = true
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# the streaming snapshot constructor reads a host-held buffer
+js-sys = "0.3"
diff --git a/crates/sysmlv2-wasm/README.md b/crates/sysmlv2-wasm/README.md
index 6b6a7da..b5cd761 100644
--- a/crates/sysmlv2-wasm/README.md
+++ b/crates/sysmlv2-wasm/README.md
@@ -38,10 +38,11 @@ A defect in the toolkit is different. It aborts the call with `RuntimeError: unr
 
 ## The standard library
 
-The package ships the OMG standard library under `stdlib/`:
+The package ships the OMG standard library under `stdlib/`. The library is licensed under EPL-2.0, not under this package's Apache-2.0: the package carries that license as `LICENSE-EPL-2.0`, and the upstream copyright notices, source repository and revision in `THIRD-PARTY-NOTICES.md`.
 
 - `sysml-library.json.gz` — the 94 library units as `[{name, text}]` (array order is load order — pass the decompressed text through unchanged).
 - `sysml-library.libcache.gz` — a sealed resolution snapshot recorded against exactly that bundle; passing it makes library resolution replay instead of search (several times faster). Stale or corrupt bytes are rejected safely and the build falls back to a cold resolve.
+- `sysml-library.prepared.gz` — the library resolved and frozen, keyed by the bundle's content: `PreparedLibrary.fromSnapshot(prepared, bundle, libcache)` decodes it instead of resolving at startup and keeps no syntax trees in memory (about half the memory of `new PreparedLibrary(bundle, libcache)`). A snapshot from another build or another bundle throws; prepare from source then.
 - `manifest.json` — toolkit version, unit count, sizes.
 
 Serve the two `.gz` files statically and load them once (cache them — they change only with the toolkit version):
@@ -82,6 +83,28 @@ and snapshot APIs remain available. `fromInterchangeJsonWithPreparedLibrary`,
 `fromCompactCborWithPreparedLibrary`, and `loadPreparedLibrary` accept the same
 handle; attaching a library invalidates existing element handles.
 
+A host that rebuilds its session after every edit starts the next build from the
+outcomes the previous one settled on, which a build on a prepared library keeps
+once its resolution has run more than one pass and settled (`settledOutcomes()` is
+`undefined` otherwise, and after a joint build). The outcomes are a handle of their
+own, so the previous session is freed first; a unit that resolves as it did is then
+confirmed in one pass, an edited one is carried through as many passes as it takes,
+and the session answers as one built cold:
+
+```js
+let session = Session.fromSourcesWithPreparedLibrary(sources, library);
+let settled = session.settledOutcomes();
+// …on each edit:
+session.free();
+session = settled
+  ? Session.fromSourcesSettled(editedSources, library, settled)
+  : Session.fromSourcesWithPreparedLibrary(editedSources, library);
+settled?.free();
+settled = session.settledOutcomes();
+```
+
+`LspServer.withPreparedLibrary(library)` builds the language server on such a handle. A session reuses the library's prepared resolution, where `LspServer.withLibrary(bundle, snapshot)` re-parses the library's sources and rebuilds its graph for every session; a workspace that may change what the library's own names resolve to still has the library resolved together with it: a root name the library looked up and missed replays the resolution recorded in the handle's snapshot (or recorded while preparing, when the snapshot is unusable), a root filter keeps that recording's element identities but resolves the library's references again, and a root declaration named like a library package resolves the library from scratch.
+
 ## Running the command-line module
 
 The package ships the toolkit's command line as a `wasm32-wasip1` module under `cli/`, version-locked to the kernel module beside it. It reserves a 16 MiB stack, because the parser's recursion bounds are sized to report a finding on deep input rather than exhaust the stack, and that reservation is the module's declared initial memory.
diff --git a/crates/sysmlv2-wasm/npm/build.mjs b/crates/sysmlv2-wasm/npm/build.mjs
index 35f4e7d..55c86e7 100644
--- a/crates/sysmlv2-wasm/npm/build.mjs
+++ b/crates/sysmlv2-wasm/npm/build.mjs
@@ -9,16 +9,20 @@
 //
 // Env:
 //   WASM_PACK        wasm-pack executable (default: wasm-pack on PATH)
+//   WASM_OPT         wasm-opt executable for the CLI artifact (default:
+//                    the one wasm-pack uses — see step 2.5)
 //   SYSMLV2_LIBRARY  standard-library dir (default: the spec-refs
 //                    submodule's sysml.library)
 //
 // Outputs (all under crates/sysmlv2-wasm/npm/, gitignored):
-//   pkg/       the package: web-target module + stdlib/ artifacts
+//   pkg/       the package: web-target module + stdlib/ artifacts, the
+//              toolkit's LICENSE, and the library's LICENSE-EPL-2.0 +
+//              THIRD-PARTY-NOTICES.md
 //   pkg-node/  nodejs-target build, for smoke.mjs only (not packaged)
 //   dist/      sysml-wasm-<version>.tgz
 
 import { execFileSync } from "node:child_process";
-import { copyFileSync, readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from "node:fs";
+import { copyFileSync, readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, realpathSync } from "node:fs";
 import { dirname, join, resolve, delimiter } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -49,6 +53,27 @@ const libraryDir =
   process.env.SYSMLV2_LIBRARY ??
   join(repoRoot, "spec-refs", "SysML-v2-Release", "sysml.library");
 
+// The toolkit is Apache-2.0, but stdlib/ carries the standard library's
+// source text, which stays under the license that sits beside it in its
+// checkout. The package ships that license and the upstream copyright
+// notices (step 3.6); stop now, before the build, rather than label a
+// library whose license is not the one the manifest declares.
+const libraryRoot = dirname(libraryDir);
+const libraryLicensePath = join(libraryRoot, "LICENSE");
+const libraryReadmePath = join(libraryRoot, "README.md");
+if (!existsSync(libraryLicensePath) || !existsSync(libraryReadmePath)) {
+  throw new Error(`${libraryRoot} must hold the library's LICENSE and README.md: the package ships them as its notices`);
+}
+if (!readFileSync(libraryLicensePath, "utf8").startsWith("Eclipse Public License - v 2.0")) {
+  throw new Error(`${libraryLicensePath} is not the EPL-2.0 text the package declares for stdlib/; revise the manifest license and notices`);
+}
+const upstreamNotice = readFileSync(libraryReadmePath, "utf8")
+  .match(/^## Licensing\r?\n([\s\S]*?)(?=^## |(?![\s\S]))/m)?.[1]
+  .trim();
+if (!upstreamNotice) {
+  throw new Error(`${libraryReadmePath} has no "## Licensing" section to carry as the upstream notice`);
+}
+
 const run = (cmd, args, opts = {}) => {
   console.log(`> ${cmd} ${args.join(" ")}`);
   execFileSync(cmd, args, { stdio: "inherit", env, ...opts });
@@ -83,10 +108,20 @@ const stackSizeBytes = (() => {
 // target variable, so any flags the caller exported are folded into the
 // target variable and removed from the environment wasm-pack sees.
 const encodedRustflags = process.env.CARGO_ENCODED_RUSTFLAGS?.split("\x1f") ?? [];
+// Panic locations and debug paths embed the source path of every crate as
+// the build machine knows it: the checkout and the cargo home (under the
+// builder's home directory). The shipped module keeps the crate-relative
+// paths only. The standard library's are already remapped by its own build.
+const cargoHome = process.env.CARGO_HOME ?? join(homedir(), ".cargo");
+const remapPathFlags = [
+  `--remap-path-prefix=${repoRoot}=.`,
+  ...(cargoHome ? [`--remap-path-prefix=${cargoHome}=/cargo`] : []),
+];
 const targetRustflags = [
   ...encodedRustflags,
   process.env.RUSTFLAGS,
   process.env.CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS,
+  ...remapPathFlags,
   `-C link-arg=--max-memory=${MAX_MEMORY_BYTES}`,
   `-C link-arg=-zstack-size=${stackSizeBytes}`,
 ].filter(Boolean).join(" ");
@@ -95,13 +130,9 @@ const wasmEnv = { ...hostEnv, CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS: tar
 run(wasmPack, ["build", crateDir, "--release", "--target", "web", "--out-dir", "npm/pkg", "--out-name", "sysmlv2"], { env: wasmEnv });
 run(wasmPack, ["build", crateDir, "--release", "--target", "nodejs", "--out-dir", "npm/pkg-node", "--out-name", "sysmlv2"], { env: wasmEnv });
 
-// 2. Standard-library artifacts into the package. The shipped bundle
-// carries the ambient libraries (Web, Template, engine overlays,
-// TransformMeta) after the standard library; a second, core-only bundle
-// (SYSMLV2_AMBIENT=off) serves the library generator's own validation,
-// where a candidate library must not collide with the committed copy.
+// 2. Standard-library artifacts into the package. The bundle carries the
+// ambient library (TransformMeta) after the standard library.
 run("cargo", ["run", "--release", "-p", "sysmlv2-wasm", "--bin", "gen_stdlib_bundle", "--", libraryDir, join(crateDir, "npm", "pkg", "stdlib")], { cwd: repoRoot });
-run("cargo", ["run", "--release", "-p", "sysmlv2-wasm", "--bin", "gen_stdlib_bundle", "--", libraryDir, join(crateDir, "npm", "pkg-node", "stdlib-core")], { cwd: repoRoot, env: { ...env, SYSMLV2_AMBIENT: "off" } });
 
 // 2.5. The wasi CLI artifact: the real `sysmlv2`
 // binary for wasm32-wasip1, shipped inside the package (cli/) so hosts
@@ -119,9 +150,12 @@ const wasiEnv = {
     ...encodedRustflags,
     process.env.RUSTFLAGS,
     process.env.CARGO_TARGET_WASM32_WASIP1_RUSTFLAGS,
+    ...remapPathFlags,
     `-C link-arg=-zstack-size=${stackSizeBytes}`,
   ].filter(Boolean).join(" "),
 };
+// CI's wasm job clippy-checks the CLI for this target with these same
+// features; change the two together.
 run(
   cargo,
   ["build", "-p", "sysmlv2-cli", "--no-default-features", "--features", "solve,viz", "--target", "wasm32-wasip1", "--profile", "wasi-release"],
@@ -131,10 +165,79 @@ const targetDir = process.env.CARGO_TARGET_DIR
   ? resolve(repoRoot, process.env.CARGO_TARGET_DIR)
   : join(repoRoot, "target");
 mkdirSync(join(crateDir, "npm", "pkg", "cli"), { recursive: true });
-copyFileSync(
+// The binary ships optimized for size by binaryen's wasm-opt, which
+// takes about a tenth off it: the bytes hosts load, compile and hold,
+// though little of that survives compression in transit. The optimizer
+// is the one wasm-pack ran on the module above, found as wasm-pack finds
+// it (on PATH, else the release wasm-pack fetched into its cache),
+// unless WASM_OPT names another.
+const wasmOpt = (() => {
+  if (process.env.WASM_OPT) return process.env.WASM_OPT;
+  const exe = process.platform === "win32" ? "wasm-opt.exe" : "wasm-opt";
+  const release = (path) => {
+    try {
+      return Number(execFileSync(path, ["--version"], { env, encoding: "utf8" }).match(/version (\d+)/)?.[1] ?? 0);
+    } catch {
+      return undefined;
+    }
+  };
+  if (release(exe) !== undefined) return exe;
+  const cache =
+    process.env.WASM_PACK_CACHE ??
+    join(
+      process.platform === "darwin"
+        ? join(homedir(), "Library", "Caches")
+        : process.platform === "win32"
+          ? (process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"))
+          : (process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache")),
+      ".wasm-pack"
+    );
+  // One release per wasm-pack version that ran here; the newest wins.
+  const [newest] = (existsSync(cache) ? readdirSync(cache) : [])
+    .filter((dir) => dir.startsWith("wasm-opt-"))
+    .map((dir) => join(cache, dir, "bin", exe))
+    .map((path) => ({ path, release: release(path) }))
+    .filter((found) => found.release !== undefined)
+    .sort((a, b) => b.release - a.release);
+  if (!newest) {
+    throw new Error(`no wasm-opt on PATH or in ${cache}: wasm-pack fetches one when it optimizes the module; set WASM_OPT to name another`);
+  }
+  return newest.path;
+})();
+// It may use exactly the features the target compiles for: fewer and it
+// rejects the compiler's output, more and it may emit what a host of the
+// target lacks. The compiler reports them; each needs wasm-opt's name
+// for it, and one without a name here stops the build.
+const wasmOptFeatures = (() => {
+  const names = {
+    "bulk-memory": "bulk-memory",
+    multivalue: "multivalue",
+    "mutable-globals": "mutable-globals",
+    "nontrapping-fptoint": "nontrapping-float-to-int",
+    "reference-types": "reference-types",
+    "sign-ext": "sign-ext",
+  };
+  const rustflags = wasiEnv.CARGO_TARGET_WASM32_WASIP1_RUSTFLAGS.split(/\s+/).filter(Boolean);
+  const cfg = execFileSync(process.env.RUSTC ?? "rustc", ["--print", "cfg", "--target", "wasm32-wasip1", ...rustflags], {
+    env,
+    encoding: "utf8",
+  });
+  return [...cfg.matchAll(/^target_feature="([^"]+)"$/gm)]
+    .map(([, feature]) => feature)
+    // A linking mode, not an instruction set.
+    .filter((feature) => feature !== "crt-static")
+    .map((feature) => {
+      if (!names[feature]) throw new Error(`the wasi target compiles with ${feature}, which build.mjs has no wasm-opt name for`);
+      return `--enable-${names[feature]}`;
+    });
+})();
+run(wasmOpt, [
+  ...wasmOptFeatures,
+  "-Oz",
   join(targetDir, "wasm32-wasip1", "wasi-release", "sysmlv2.wasm"),
-  join(crateDir, "npm", "pkg", "cli", "sysmlv2-cli.wasm")
-);
+  "-o",
+  join(crateDir, "npm", "pkg", "cli", "sysmlv2-cli.wasm"),
+]);
 
 // 3. Package identity: scope the wasm-pack-generated manifest and ship
 // the stdlib alongside the module.
@@ -162,8 +265,48 @@ const buildinfo = {
   dirty: probe("git", ["status", "--porcelain"]) ? true : false,
   builtAt: new Date().toISOString(),
   toolchain: probe("rustc", ["--version"]),
+  optimizer: probe(wasmOpt, ["--version"]),
 };
 writeFileSync(join(crateDir, "npm", "pkg", "buildinfo.json"), JSON.stringify(buildinfo, null, 2) + "\n");
+
+// 3.6. Licensing: the toolkit's LICENSE, the library's, and its
+// upstream notices (checked before the build, above). Only the library's
+// own checkout names its source; a plain directory inside another
+// repository would report that repository's HEAD. Credentials in the
+// remote URL never reach the package.
+const ownCheckout = probe("git", ["-C", libraryRoot, "rev-parse", "--show-toplevel"]) === realpathSync(libraryRoot);
+const libraryOrigin = ownCheckout
+  ? probe("git", ["-C", libraryRoot, "remote", "get-url", "origin"])?.replace(/^(https?:\/\/)[^@/]+@/, "$1").replace(/\.git$/, "")
+  : undefined;
+const libraryRevision = ownCheckout ? probe("git", ["-C", libraryRoot, "rev-parse", "HEAD"]) : undefined;
+const pkgDir = join(crateDir, "npm", "pkg");
+copyFileSync(join(repoRoot, "LICENSE"), join(pkgDir, "LICENSE"));
+copyFileSync(libraryLicensePath, join(pkgDir, "LICENSE-EPL-2.0"));
+writeFileSync(
+  join(pkgDir, "THIRD-PARTY-NOTICES.md"),
+  [
+    "# Third-party notices",
+    "",
+    `${pkg.name} is licensed under the Apache License 2.0 (\`LICENSE\`), except for the material below.`,
+    "",
+    "## SysML v2 standard library",
+    "",
+    "`stdlib/sysml-library.json.gz` carries the unmodified source text of the standard library" +
+      (libraryOrigin ? ` from ${libraryOrigin}` : "") +
+      (libraryRevision ? ` at revision ${libraryRevision}` : "") +
+      ", and `stdlib/sysml-library.libcache.gz` and `stdlib/sysml-library.prepared.gz` are resolution snapshots derived from it. " +
+      "That material is licensed under the Eclipse Public License 2.0 (`LICENSE-EPL-2.0`). " +
+      "The bundle's remaining units, loaded after the standard library, are this package's own and Apache-2.0.",
+    "",
+    "The upstream licensing notice, as published with that source:",
+    "",
+    ...upstreamNotice.split(/\r?\n/).map((line) => (line ? `> ${line}` : ">")),
+    "",
+  ].join("\n")
+);
+pkg.license = "Apache-2.0 AND EPL-2.0";
+pkg.files = [...new Set([...pkg.files, "LICENSE", "LICENSE-EPL-2.0", "THIRD-PARTY-NOTICES.md"])];
+
 // Publishes go to the package registry CI is configured for (release
 // tags / manual runs).
 pkg.publishConfig = { registry: "https://npm.pkg.github.com" };
diff --git a/crates/sysmlv2-wasm/npm/cli_smoke.mjs b/crates/sysmlv2-wasm/npm/cli_smoke.mjs
index 8fd5f55..fa2b545 100644
--- a/crates/sysmlv2-wasm/npm/cli_smoke.mjs
+++ b/crates/sysmlv2-wasm/npm/cli_smoke.mjs
@@ -31,13 +31,20 @@ const wasmPath =
   process.env.SYSMLV2_CLI_WASM ?? join(npmDir, "pkg", "cli", "sysmlv2-cli.wasm");
 
 // Size budget: the artifact is fetched lazily by browsers; growth past
-// this line should be a conscious decision, not drift.
-const SIZE_BUDGET = 4 * 1024 * 1024;
+// this line should be a conscious decision, not drift. Set at 4.5 MiB
+// once checked semantic contracts had taken the compiled binary from
+// 3,549,140 bytes in v0.9.1 to 4,163,555 (1.16 to 1.40 MB gzip, 0.87 to
+// 1.05 MB brotli): about 440 KB of new model semantics and 130 KB of
+// standard-library generics instantiated for it. The build's size
+// optimizer then ships it at 3,664,665 (1.36 MB gzip), 1.05 MB below
+// the line.
+const SIZE_BUDGET = 4.5 * 1024 * 1024;
 const size = statSync(wasmPath).size;
 if (size > SIZE_BUDGET) {
   throw new Error(`cli wasm is ${size} bytes — over the ${SIZE_BUDGET} budget`);
 }
-console.log(`artifact: ${wasmPath} (${(size / 1024 / 1024).toFixed(2)} MB)`);
+const mib = (bytes) => (bytes / 1024 / 1024).toFixed(2);
+console.log(`artifact: ${wasmPath} (${mib(size)} of ${mib(SIZE_BUDGET)} MiB budget)`);
 
 const mod = new WebAssembly.Module(readFileSync(wasmPath));
 const work = mkdtempSync(join(tmpdir(), "sysmlv2-cli-smoke-"));
@@ -84,7 +91,9 @@ function expect(cond, label, r) {
   console.log(`ok: ${label}`);
 }
 
-// The ambient model directory, preopened at /model.
+// The ambient model directory, preopened at /model. Usages a package
+// owns are [0..*] unless declared, so the ones the query and range
+// cases read as single values declare [1].
 const modelDir = join(work, "model");
 mkdirSync(modelDir);
 writeFileSync(
@@ -93,11 +102,11 @@ writeFileSync(
 );
 writeFileSync(
   join(modelDir, "power.sysml"),
-  "package Rover {\n    private import Chassis::*;\n    part base : Frame;\n    attribute payload = 8.5;\n    attribute totalMass = base.mass + payload;\n}\n"
+  "package Rover {\n    private import Chassis::*;\n    part base : Frame[1];\n    attribute payload[1] = 8.5;\n    attribute totalMass[1] = base.mass + payload;\n}\n"
 );
 writeFileSync(
   join(modelDir, "limits.sysml"),
-  "package Limits {\n    attribute def Real;\n    attribute x : Real;\n    assert constraint lo { x >= 1 }\n    assert constraint hi { x <= 5 }\n}\n"
+  "package Limits {\n    attribute def Real;\n    attribute x : Real[1];\n    assert constraint lo { x >= 1 }\n    assert constraint hi { x <= 5 }\n}\n"
 );
 const ambient = {
   env: { SYSMLV2_MODEL_DIR: "/model" },
diff --git a/crates/sysmlv2-wasm/npm/smoke.mjs b/crates/sysmlv2-wasm/npm/smoke.mjs
index c19d3b8..fe7b35f 100644
--- a/crates/sysmlv2-wasm/npm/smoke.mjs
+++ b/crates/sysmlv2-wasm/npm/smoke.mjs
@@ -116,6 +116,73 @@ const real = s2.resolve("ScalarValues::Real");
 assert.ok(real, "stdlib element resolves");
 assert.ok(s2.isLibraryElement(real));
 
+// A session started from the outcomes the previous build settled on answers
+// as a cold one — over the same units and after an edit — and the outcomes
+// outlive the session that produced them, so the host frees it first.
+const settledLibrary = new PreparedLibrary(bundle, snapshot);
+const workspace = (carName) => JSON.stringify([
+  {
+    name: "defs.sysml",
+    text: `package VehicleDefs {
+      private import ISQ::*;
+      part def Vehicle { attribute mass : MassValue; part engine : Engine; }
+      part def Engine { attribute power : PowerValue; port fuelIn : FuelPort; }
+      port def FuelPort { in item fuel : Fuel; }
+      item def Fuel;
+      calc def KineticEnergy { in m : MassValue; in v : SpeedValue; return : EnergyValue = 0.5 * m * v ** 2; }
+    }`,
+  },
+  {
+    name: "usage.sysml",
+    text: `package VehicleUsage {
+      private import VehicleDefs::*;
+      private import ISQ::*;
+      private import SI::*;
+      part ${carName} : Vehicle {
+        attribute :>> mass = 1500 [kg];
+        part :>> engine { attribute :>> power = 150000 [W]; }
+      }
+      part tank { port fuelOut : ~FuelPort; }
+      connect tank.fuelOut to ${carName}.engine.fuelIn;
+      attribute ke : EnergyValue = KineticEnergy(${carName}.mass, 30 [m/s]);
+    }`,
+  },
+  {
+    name: "views.sysml",
+    text: `package VehicleViews {
+      private import VehicleUsage::*;
+      private import Views::*;
+      view def PartTree;
+      view carTree : PartTree { expose car::**; render asTreeDiagram; }
+    }`,
+  },
+]);
+const answerOf = (session) => session.toFullJson(true) + "\n" + session.check() + "\n" + session.unresolvedCount();
+const previous = Session.fromSourcesWithPreparedLibrary(workspace("car"), settledLibrary);
+const previousAnswer = answerOf(previous);
+const settled = previous.settledOutcomes();
+assert.ok(settled, "a build on the prepared library keeps the outcomes it settled on");
+assert.equal(settled.unitCount(), 3);
+previous.free();
+const t3 = performance.now();
+const sameSeeded = Session.fromSourcesSettled(workspace("car"), settledLibrary, settled);
+const sameSeededMs = performance.now() - t3;
+assert.equal(answerOf(sameSeeded), previousAnswer, "the same units again");
+sameSeeded.free();
+const t4 = performance.now();
+const editedCold = Session.fromSourcesWithPreparedLibrary(workspace("truck"), settledLibrary);
+const editedColdMs = performance.now() - t4;
+const t5 = performance.now();
+const editedSeeded = Session.fromSourcesSettled(workspace("truck"), settledLibrary, settled);
+const editedSeededMs = performance.now() - t5;
+assert.equal(answerOf(editedSeeded), answerOf(editedCold), "after a rename that unresolves another unit's references");
+assert.ok(JSON.parse(editedSeeded.check()).length > 0, "the rename leaves findings");
+settled.free();
+editedCold.free();
+editedSeeded.free();
+settledLibrary.free();
+console.log(`settled start: same units ${sameSeededMs.toFixed(1)} ms; after an edit cold ${editedColdMs.toFixed(1)} ms, seeded ${editedSeededMs.toFixed(1)} ms`);
+
 // Shared graph preparation preserves results, including after the host releases
 // its handle. Each session keeps its own reference and resolver state.
 const prepared = new PreparedLibrary(bundle, snapshot);
@@ -128,6 +195,34 @@ const liftedShared = Session.fromInterchangeJsonWithPreparedLibrary(shared.toCom
 assert.deepEqual(JSON.parse(liftedShared.check()), []);
 liftedShared.free();
 prepared.free();
+
+// The prepared snapshot decodes for the package's own bundle, equals the
+// source-prepared graph, and is refused for any other bundle.
+const preparedBytes = new Uint8Array(gunzipSync(readFileSync(join(stdlibDir, "sysml-library.prepared.gz"))));
+const tDecoded = performance.now();
+const decoded = PreparedLibrary.fromSnapshot(preparedBytes, bundle, snapshot);
+console.log(`stdlib prepared snapshot: decoded in ${(performance.now() - tDecoded).toFixed(0)} ms`);
+const overDecoded = Session.fromSourcesWithPreparedLibrary(user, decoded);
+assert.equal(overDecoded.toCompactJson(), shared.toCompactJson());
+assert.equal(overDecoded.check(), shared.check());
+overDecoded.free();
+decoded.free();
+// ... and streamed from the host's buffer, one window at a time.
+const tStreamed = performance.now();
+const streamed = PreparedLibrary.fromSnapshotStream(preparedBytes, bundle, snapshot);
+console.log(`stdlib prepared snapshot: streamed in ${(performance.now() - tStreamed).toFixed(0)} ms`);
+const overStreamed = Session.fromSourcesWithPreparedLibrary(user, streamed);
+assert.equal(overStreamed.toCompactJson(), shared.toCompactJson());
+overStreamed.free();
+streamed.free();
+const flipped = new Uint8Array(preparedBytes);
+flipped[flipped.length - 1] ^= 0xff;
+assert.throws(() => PreparedLibrary.fromSnapshotStream(flipped, bundle, snapshot), "a corrupt snapshot is refused after the decode");
+assert.throws(
+  () => PreparedLibrary.fromSnapshot(preparedBytes, JSON.stringify([...JSON.parse(bundle), { name: "x.sysml", text: "package X;" }]), snapshot),
+  /another toolkit build or from other library units/,
+  "a snapshot of other units is refused"
+);
 shared.edit(JSON.stringify([{ op: "rename", target: "Demo::car", newName: "vehicle" }]));
 const edited = shared.resolve("Demo::vehicle");
 assert.ok(edited);
diff --git a/crates/sysmlv2-wasm/src/bin/gen_stdlib_bundle.rs b/crates/sysmlv2-wasm/src/bin/gen_stdlib_bundle.rs
index c04eb01..8de470f 100644
--- a/crates/sysmlv2-wasm/src/bin/gen_stdlib_bundle.rs
+++ b/crates/sysmlv2-wasm/src/bin/gen_stdlib_bundle.rs
@@ -10,6 +10,10 @@
 //!   exactly this sequence, so consumers must add units in array order
 //!   (the binding's `parse_sources` does).
 //! - `sysml-library.libcache.gz` — `LibraryCache::to_bytes`, gzip.
+//! - `sysml-library.prepared.gz` — `PreparedLibrary::to_bytes`, gzip: the
+//!   library resolved and frozen, keyed by the bundle's content, for the
+//!   binding's `PreparedLibrary.fromSnapshot(prepared, bundle, libcache)`,
+//!   which decodes it instead of resolving at boot.
 //! - `manifest.json` — toolkit version, unit count, raw/compressed sizes.
 //!
 //! Browsers decompress with `DecompressionStream("gzip")`, node with
@@ -125,6 +129,25 @@ fn main() {
         .expect("recording armed before the build")
         .to_bytes();
 
+    // The prepared snapshot: the same library prepared over the recording
+    // just made, as the binding's `PreparedLibrary.new(bundle, libcache)`
+    // prepares it, then encoded under the bundle's content key.
+    let prepared = {
+        let mut model = Model::new();
+        for (name, src) in &units {
+            model.add_library_source(name.clone(), src);
+        }
+        let cache = sysmlv2_model::libcache::LibraryCache::from_bytes(&snapshot)
+            .expect("the recording just made decodes");
+        model.set_library_cache(cache);
+        let library = model.prepare_library().expect("the library prepares");
+        let key = sysmlv2_model::libcache::hash_units(
+            units
+                .iter()
+                .map(|(name, text)| (name.as_str(), text.as_str())),
+        );
+        library.to_bytes(key).expect("the prepared library encodes")
+    };
     let bundle = serde_json::to_string(
         &units
             .iter()
@@ -143,6 +166,7 @@ fn main() {
     };
     let bundle_gz = write("sysml-library.json.gz", &gzip(bundle.as_bytes()));
     let snapshot_gz = write("sysml-library.libcache.gz", &gzip(&snapshot));
+    let prepared_gz = write("sysml-library.prepared.gz", &gzip(&prepared));
     let manifest = serde_json::json!({
         "toolkitVersion": env!("CARGO_PKG_VERSION"),
         "units": units.len(),
@@ -157,18 +181,25 @@ fn main() {
             "rawBytes": snapshot.len(),
             "gzipBytes": snapshot_gz,
         },
+        "prepared": {
+            "file": "sysml-library.prepared.gz",
+            "rawBytes": prepared.len(),
+            "gzipBytes": prepared_gz,
+        },
     });
     write(
         "manifest.json",
         serde_json::to_string_pretty(&manifest).unwrap().as_bytes(),
     );
     println!(
-        "{} units; bundle {} -> {} gz; snapshot {} -> {} gz; {} library-internal unresolved",
+        "{} units; bundle {} -> {} gz; snapshot {} -> {} gz; prepared {} -> {} gz; {} library-internal unresolved",
         units.len(),
         bundle.len(),
         bundle_gz,
         snapshot.len(),
         snapshot_gz,
+        prepared.len(),
+        prepared_gz,
         unresolved,
     );
 }
diff --git a/crates/sysmlv2-wasm/src/lib.rs b/crates/sysmlv2-wasm/src/lib.rs
index 73781d4..e21b6cd 100644
--- a/crates/sysmlv2-wasm/src/lib.rs
+++ b/crates/sysmlv2-wasm/src/lib.rs
@@ -547,6 +547,62 @@ impl PreparedLibrary {
                 .map_err(|e| e.to_string())?,
         })
     }
+
+    /// Decode a prepared snapshot (the package's `sysml-library.prepared.gz`,
+    /// decompressed) of exactly `sources_json`, the bundle it was generated
+    /// from: no resolve at boot, no syntax trees in memory. A snapshot made by
+    /// another build or from other units is refused with an error, and the
+    /// caller prepares from source with `new` instead. `recording` is the
+    /// sealed resolution snapshot, kept encoded for the builds that must
+    /// resolve the library together with user units.
+    /// [`Self::from_snapshot`] reading the snapshot where it lies: `view` stays
+    /// in the host's memory and is copied into this module one window at a
+    /// time, so the module's memory never holds the whole snapshot (which it
+    /// would keep as its high-water mark). Same refusals as `fromSnapshot`.
+    #[cfg(target_arch = "wasm32")]
+    #[wasm_bindgen(js_name = fromSnapshotStream)]
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn from_snapshot_stream(
+        view: js_sys::Uint8Array,
+        sources_json: &str,
+        recording: Option<Vec<u8>>,
+    ) -> Result<PreparedLibrary, String> {
+        let len = usize::try_from(view.length()).map_err(|e| e.to_string())?;
+        let mut at: u32 = 0;
+        let fill = |buf: &mut [u8]| {
+            let n = u32::try_from(buf.len())
+                .unwrap_or(u32::MAX)
+                .min(view.length() - at);
+            if n == 0 {
+                return 0;
+            }
+            view.subarray(at, at + n).copy_to(&mut buf[..n as usize]);
+            at += n;
+            n as usize
+        };
+        Ok(Self {
+            inner: Library::prepared_snapshot_chunks(
+                parse_sources(sources_json)?,
+                len,
+                fill,
+                recording,
+            )
+            .map_err(|e| e.to_string())?,
+        })
+    }
+
+    #[wasm_bindgen(js_name = fromSnapshot)]
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn from_snapshot(
+        snapshot: Vec<u8>,
+        sources_json: &str,
+        recording: Option<Vec<u8>>,
+    ) -> Result<PreparedLibrary, String> {
+        Ok(Self {
+            inner: Library::prepared_snapshot(parse_sources(sources_json)?, &snapshot, recording)
+                .map_err(|e| e.to_string())?,
+        })
+    }
 }
 
 #[wasm_bindgen]
@@ -617,6 +673,72 @@ impl Session {
         self.gen += 1;
         Ok(())
     }
+}
+
+/// The outcomes a session's build settled on, held apart from the
+/// session for the next build of mostly the same units to start from
+/// (see [`Session::from_sources_settled`]). The handle keeps only the
+/// outcomes — each reference's fingerprint and the identity of its
+/// target — so the session that produced it may be freed before the
+/// next build; free the handle once a build has taken it, or keep the
+/// latest one across edits.
+#[wasm_bindgen]
+pub struct SettledOutcomes {
+    inner: std::sync::Arc<sysmlv2_transform::SettledOutcomes>,
+}
+
+#[wasm_bindgen]
+impl SettledOutcomes {
+    /// How many units' outcomes the handle keeps.
+    #[must_use]
+    #[wasm_bindgen(js_name = unitCount)]
+    pub fn unit_count(&self) -> usize {
+        self.inner.unit_count()
+    }
+}
+
+#[wasm_bindgen]
+impl Session {
+    /// The outcomes this session's build settled on, for a session over
+    /// mostly the same units to start from ([`Self::from_sources_settled`]):
+    /// `undefined` unless the session was built on a prepared library and
+    /// its resolution ran more than one pass and settled — a build that
+    /// resolved in one pass, one that resolved the library together with
+    /// its units, or one that did not settle keeps none. A session rebuilt
+    /// by an edit or a library load keeps the outcomes of its latest build.
+    #[must_use]
+    #[wasm_bindgen(js_name = settledOutcomes)]
+    pub fn settled_outcomes(&self) -> Option<SettledOutcomes> {
+        self.inner
+            .settled_outcomes()
+            .map(|inner| SettledOutcomes { inner })
+    }
+
+    /// [`Self::from_sources_with_prepared_library`] with resolution started
+    /// from `settled`, the outcomes a previous session settled on
+    /// ([`Self::settled_outcomes`]): a reference lowered where and as it
+    /// was takes its outcome, so a unit that resolves as it did is
+    /// confirmed in one pass, while an edited reference, and every
+    /// reference after an inserted or removed element, starts unresolved
+    /// and is carried through as many passes as it takes. What a host that
+    /// rebuilds its session after every edit starts the next build from;
+    /// the session answers as one built without.
+    #[wasm_bindgen(js_name = fromSourcesSettled)]
+    pub fn from_sources_settled(
+        sources_json: &str,
+        library: &PreparedLibrary,
+        settled: &SettledOutcomes,
+    ) -> Result<Session, String> {
+        Ok(Session {
+            inner: TSession::from_sources_settled(
+                parse_sources(sources_json)?,
+                Some(library.inner.clone()),
+                Some(settled.inner.clone()),
+            )
+            .map_err(|e| e.to_string())?,
+            gen: 0,
+        })
+    }
 
     /// Open a session over in-memory sources: JSON `[{name, text}]`.
     /// Unit names ending in `.kerml` parse as KerML.
@@ -797,33 +919,12 @@ impl Session {
         Ok(self.value_to_json(&value).to_string())
     }
 
-    /// Render the template a `view` usage presents over its exposed model
-    /// slice (semantic mode): `qualified_name` names the view
-    /// usage; the result is the rendered node tree as JSON, or HTML when
-    /// `format` is `"html"`. Evaluation writes nothing into the model.
-    // The export boundary converts an optional string only when owned.
-    #[allow(clippy::needless_pass_by_value)]
-    #[wasm_bindgen(js_name = renderView)]
-    pub fn render_view(
-        &mut self,
-        qualified_name: &str,
-        format: Option<String>,
-    ) -> Result<String, String> {
-        let view = self
-            .inner
-            .resolved()
-            .resolve_qualified(qualified_name)
-            .ok_or_else(|| format!("element not found: {qualified_name}"))?;
-        let nodes = self.inner.resolved().render_view(view)?;
-        Ok(match format.as_deref() {
-            Some("html") => sysmlv2_model::render::to_html(&nodes),
-            _ => serde_json::Value::Array(nodes.iter().map(|n| n.to_json()).collect()).to_string(),
-        })
-    }
-
     /// Describe a `view` usage for tabular consumers: the rendering it
-    /// requests (`render …;` → the rendering usage's declared name),
-    /// the elements it exposes (its `expose` imports with the view's
+    /// requests (`render …;` → the rendering usage's declared name; a
+    /// view with no `render` member of its own reports the one it
+    /// inherits from its definition or a view it specializes, the first
+    /// in heritage order when there are several), the elements it
+    /// exposes (its `expose` imports with the view's
     /// `filter` conditions applied — the same exposure the CLI's
     /// view-directed diagrams use), the view usages it owns (a matrix's
     /// `columns` sub-view), and its prefix metadata with every owned
@@ -982,6 +1083,25 @@ impl Session {
         Ok(json.to_string())
     }
 
+    /// Checked owned/derived property by specification name, encoded as JSON.
+    pub fn property(&mut self, e: &Element, name: &str) -> Result<String, String> {
+        self.guard(e)?;
+        self.inner
+            .resolved()
+            .property(e.e, name)
+            .map(|v| v.to_string())
+            .map_err(|e| e.to_string())
+    }
+
+    /// Strict full JSON; no recovery elements or unavailable-value placeholders.
+    #[wasm_bindgen(js_name = toFullJsonStrict)]
+    pub fn to_full_json_strict(&mut self) -> Result<String, String> {
+        self.inner
+            .to_full_json_strict()
+            .map(|v| v.to_string())
+            .map_err(|e| e.to_string())
+    }
+
     /// The element handles of the derived property `name` of `e`: the
     /// element of a single-valued value, the elements of a list, the
     /// in-model targets of a reference-typed value — a target outside the
@@ -1227,6 +1347,19 @@ impl Session {
         Ok(self.inner.resolved().conforms(e.e, ancestor.e))
     }
 
+    /// Reachability including supported implied library and variation bases.
+    /// A negative result does not establish complete non-conformance.
+    #[wasm_bindgen(js_name = conformsWithImplied)]
+    pub fn conforms_with_implied(
+        &mut self,
+        e: &Element,
+        ancestor: &Element,
+    ) -> Result<bool, String> {
+        self.guard(e)?;
+        self.guard(ancestor)?;
+        Ok(self.inner.resolved().conforms_with_implied(e.e, ancestor.e))
+    }
+
     /// The shortest spelling of `target` that resolves to it from
     /// inside `context`'s declaration — what a generated value
     /// expression should write instead of the full qualified name
@@ -2693,6 +2826,22 @@ impl LspServer {
         })
     }
 
+    /// A server whose navigation and completions see a prepared library.
+    /// The library was resolved when it was prepared, so a session resolves
+    /// the workspace's units against it rather than the library's sources;
+    /// a workspace that may change what the library's own names resolve to
+    /// (for example a root name the library looked up and missed, or a root
+    /// declaration named like one of the library's) has the library resolved
+    /// again with it. The server keeps its own reference; the handle may be
+    /// freed afterwards.
+    #[must_use]
+    #[wasm_bindgen(js_name = withPreparedLibrary)]
+    pub fn with_prepared_library(library: &PreparedLibrary) -> LspServer {
+        LspServer {
+            inner: sysmlv2_lsp::PushServer::with_library(library.inner.clone()),
+        }
+    }
+
     /// Seed (or replace) the navigation workspace: every model unit the
     /// host knows about, as JSON `[{name, text}]` where `name` is the
     /// same uri string the client opens the document under. Open
diff --git a/crates/sysmlv2-wasm/tests/api.rs b/crates/sysmlv2-wasm/tests/api.rs
index 4d9ce63..067dd19 100644
--- a/crates/sysmlv2-wasm/tests/api.rs
+++ b/crates/sysmlv2-wasm/tests/api.rs
@@ -26,6 +26,21 @@ fn offset(v: &serde_json::Value) -> usize {
 
 const FLASHLIGHT: &str = "package Flashlight {\n    part def Body;\n    part def Battery {\n        attribute voltage = 3;\n    }\n    part flashlight {\n        part body : Body;\n        part battery : Battery;\n    }\n}\n";
 
+#[test]
+fn checked_properties_and_strict_export() {
+    let mut s =
+        Session::from_sources(&sources(&[("m.sysml", "package P { interface def I; }")])).unwrap();
+    let i = s.resolve("P::I").unwrap();
+    assert_eq!(s.property(&i, "isSufficient").unwrap(), "true");
+    assert!(s.to_full_json_strict().is_err());
+    let mut s = Session::from_sources(&sources(&[("m.sysml", "package P;")])).unwrap();
+    assert!(
+        s.to_full_json_strict()
+            .unwrap()
+            .contains("\"isImpliedIncluded\":false")
+    );
+}
+
 #[test]
 fn session_navigation_and_query() {
     let mut s = Session::from_sources(&sources(&[("flashlight.sysml", FLASHLIGHT)])).unwrap();
@@ -557,7 +572,7 @@ fn edit_batch_moves_members() {
     let body_at = post.find("part body : Body;").unwrap();
     assert!(battery_at < body_at, "not reordered:\n{post}");
     // Named members chain past their membership's ordinal (IDS.md,
-    // id scheme 1): reordering named siblings moves no ids, so
+    // id scheme 2): reordering named siblings moves no ids, so
     // the report's id map is empty and host selections survive as-is.
     assert!(
         report["idMap"].as_array().is_some_and(|m| m.is_empty()),
@@ -750,7 +765,7 @@ fn verify_reports_verdicts_and_narrowed_ranges() {
     // the "why") — the solverless `verify --ranges` pipeline.
     let src = "package P {\n\
                \x20   attribute def Real;\n\
-               \x20   attribute wingSpan : Real;\n\
+               \x20   attribute wingSpan : Real[1];\n\
                \x20   attribute margin : Real = 1;\n\
                \x20   assert constraint span { wingSpan >= 10 }\n\
                \x20   assert constraint bad { 1 > 2 }\n\
@@ -1252,271 +1267,10 @@ fn canonical_name_spells_like_the_printer() {
     assert_eq!(s.name(&e).unwrap().as_deref(), Some("part"));
 }
 
-/// The generated Web platform library, as committed.
-const WEB_LIBRARY: &str = include_str!("../../../local-packages/Web.sysml");
-const TEMPLATE_LIBRARY: &str = include_str!("../../../local-packages/Template.sysml");
-const SVELTE_LIBRARY: &str = include_str!("../../../local-packages/Svelte.sysml");
-
-/// An imported document stores structural
-/// ownership only; the DOM navigation API is constructed from it on
-/// query. Order is membership order, `children` is element-only, `Attr`
-/// parts feed `attributes` and never the tree, and the parent/sibling
-/// views come from the owner's membership.
+/// The ambient library loads with any directory library (interim
+/// mechanism) — no file needs naming, and it stays library content.
 #[test]
-fn dom_navigation_is_constructed_from_ownership() {
-    let abox = r#"package View {
-    private import Web::HTML::Elements::*;
-
-    part <n1> shell : Div {
-        :>> id = "shell";
-
-        part <n1_data_qn> : Web::DOM::Attr {
-            :>> localName = "data-qn";
-            :>> value = "q";
-        }
-
-        part <n2> : Web::DOM::Text {
-            :>> data = "lead";
-        }
-
-        part <n3> : Main {
-            part <n4> : Section;
-        }
-
-        part <n5> : Web::DOM::Comment {
-            :>> data = "c";
-        }
-
-        part <n6> : Span;
-    }
-}
-"#;
-    let src = sources(&[("Web.sysml", WEB_LIBRARY), ("view.sysml", abox)]);
-    let mut s = Session::from_sources(&src).unwrap();
-    let names = |json: String| -> Vec<String> {
-        let v: serde_json::Value = serde_json::from_str(&json).unwrap();
-        let one = |x: &serde_json::Value| match x {
-            serde_json::Value::String(s) => s.clone(),
-            _ => x["qualifiedName"]
-                .as_str()
-                .map(|q| q.rsplit("::").next().unwrap().to_string())
-                .unwrap_or_else(|| x.to_string()),
-        };
-        match v.as_array() {
-            Some(items) => items.iter().map(one).collect(),
-            None => vec![one(&v)],
-        }
-    };
-    let q = |s: &mut Session, e: &str| names(s.query(e).unwrap());
-    assert_eq!(
-        q(&mut s, "View::shell.childNodes"),
-        ["n2", "n3", "n5", "n6"]
-    );
-    assert_eq!(q(&mut s, "View::shell.children"), ["n3", "n6"]);
-    assert_eq!(q(&mut s, "View::shell.firstChild"), ["n2"]);
-    assert_eq!(q(&mut s, "View::shell.lastChild"), ["n6"]);
-    assert_eq!(q(&mut s, "View::shell.firstElementChild"), ["n3"]);
-    assert_eq!(q(&mut s, "View::shell.lastElementChild"), ["n6"]);
-    assert_eq!(q(&mut s, "View::shell.childElementCount"), ["2"]);
-    assert_eq!(q(&mut s, "View::shell.attributes"), ["n1_data_qn"]);
-    assert_eq!(q(&mut s, "View::shell::n3.parentNode"), ["shell"]);
-    assert_eq!(q(&mut s, "View::shell::n3.parentElement"), ["shell"]);
-    assert_eq!(q(&mut s, "View::shell::n3.previousSibling"), ["n2"]);
-    assert_eq!(q(&mut s, "View::shell::n3.nextSibling"), ["n5"]);
-    assert_eq!(
-        q(&mut s, "View::shell::n3.previousElementSibling"),
-        [] as [String; 0]
-    );
-    assert_eq!(q(&mut s, "View::shell::n3.nextElementSibling"), ["n6"]);
-    assert_eq!(q(&mut s, "View::shell::n3.children"), ["n4"]);
-    assert_eq!(
-        q(&mut s, "View::shell::n3::n4.childNodes"),
-        [] as [String; 0]
-    );
-    assert_eq!(
-        q(&mut s, "View::shell::n3::n4.parentNode.parentNode"),
-        ["shell"]
-    );
-    // A package-level node has no DOM parent; an Attr is never a child.
-    assert_eq!(q(&mut s, "View::shell.parentNode"), [] as [String; 0]);
-    assert_eq!(
-        q(&mut s, "View::shell::n1_data_qn.parentNode"),
-        [] as [String; 0]
-    );
-    // Nested chains compose with the constructed views.
-    assert_eq!(
-        q(&mut s, "View::shell.children.localName"),
-        ["main", "span"]
-    );
-    assert_eq!(q(&mut s, "View::shell.firstChild.data"), ["lead"]);
-}
-
-/// Template nodes: block slots and a component's `props` are transparent
-/// to the constructed views, a template
-/// element's redefined `attributes` view is constructed like the DOM
-/// one, and a node's parent is the block owning the slot it sits in.
-#[test]
-fn dom_navigation_projects_through_template_slots() {
-    let abox = r#"package View {
-    private import Svelte::*;
-    private import Web::HTML::Elements::*;
-
-    part <r> root : Root {
-        part <r_env> :>> environment : Environment {
-            :>> implementation = "svelte";
-        }
-
-        part <e1> : EachBlock {
-            attribute :>> expression : TypeScript = "items";
-
-            part <e1_body> :>> body {
-                part <h> heading : RegularElement, H3 {
-                    :>> id = "heading";
-
-                    part <h_t> : ExpressionTag {
-                        attribute :>> expression : TypeScript = "name";
-                    }
-                }
-
-                part <s> : RegularElement, Section {
-                    part <s_id> : Attribute {
-                        :>> localName = "id";
-
-                        part <s_id_e> : ExpressionTag {
-                            attribute :>> expression : TypeScript = "item.id";
-                        }
-                    }
-
-                    part <s_p> : RegularElement, P;
-                }
-            }
-
-            part <e1_fb> :>> fallback {
-                part <fb_p> : RegularElement, P;
-            }
-        }
-
-        part <c> : Component {
-            :>> name = "Card";
-
-            part <c_props> :>> props {
-                part <c_title> : Attribute {
-                    :>> localName = "title";
-                    :>> value = "T";
-                }
-            }
-
-            part <c_p> : RegularElement, P;
-        }
-    }
-}
-"#;
-    let src = sources(&[
-        ("Web.sysml", WEB_LIBRARY),
-        ("Template.sysml", TEMPLATE_LIBRARY),
-        ("Svelte.sysml", SVELTE_LIBRARY),
-        ("view.sysml", abox),
-    ]);
-    let mut s = Session::from_sources(&src).unwrap();
-    let names = |json: String| -> Vec<String> {
-        let v: serde_json::Value = serde_json::from_str(&json).unwrap();
-        let one = |x: &serde_json::Value| match x {
-            serde_json::Value::String(s) => s.clone(),
-            _ => x["qualifiedName"]
-                .as_str()
-                .map(|q| q.rsplit("::").next().unwrap().to_string())
-                .unwrap_or_else(|| x.to_string()),
-        };
-        match v.as_array() {
-            Some(items) => items.iter().map(one).collect(),
-            None => vec![one(&v)],
-        }
-    };
-    let q = |s: &mut Session, e: &str| names(s.query(e).unwrap());
-    // Root: the environment is not a node; the block and component are.
-    assert_eq!(q(&mut s, "View::root.childNodes"), ["e1", "c"]);
-    // Block traversal flattens body then fallback; the named slots
-    // themselves answer with their owned nodes.
-    assert_eq!(
-        q(&mut s, "View::root.e1.childNodes"),
-        ["heading", "s", "fb_p"]
-    );
-    assert_eq!(q(&mut s, "View::root.e1.firstChild"), ["heading"]);
-    assert_eq!(q(&mut s, "View::root.e1.lastChild"), ["fb_p"]);
-    assert_eq!(q(&mut s, "View::root.e1.body"), ["heading", "s"]);
-    assert_eq!(q(&mut s, "View::root.e1.fallback"), ["fb_p"]);
-    // A slot is a fragment: the element-only views live there.
-    assert_eq!(
-        q(&mut s, "View::root.e1.e1_body.children"),
-        ["heading", "s"]
-    );
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.childElementCount"), ["2"]);
-    assert_eq!(
-        q(&mut s, "View::root.e1.e1_body.firstElementChild"),
-        ["heading"]
-    );
-    // Parent and siblings see through the slot.
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.s.parentNode"), ["e1"]);
-    assert_eq!(
-        q(&mut s, "View::root.e1.e1_body.s.previousSibling"),
-        ["heading"]
-    );
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.s.nextSibling"), ["fb_p"]);
-    assert_eq!(
-        q(&mut s, "View::root.e1.e1_body.heading.previousSibling"),
-        [] as [String; 0]
-    );
-    // A template element's attributes view: reified attribute-likes only, never children.
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.s.attributes"), ["s_id"]);
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.s.childNodes"), ["s_p"]);
-    assert_eq!(
-        q(&mut s, "View::root.e1.e1_body.s.attributes.localName"),
-        ["id"]
-    );
-    // The gates: ordered traversal, `H3.localName`, the static
-    // reflected id, and the dynamic id as an unevaluated typed source.
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.heading.localName"), ["h3"]);
-    assert_eq!(q(&mut s, "View::root.e1.e1_body.heading.id"), ["heading"]);
-    assert_eq!(
-        q(
-            &mut s,
-            "View::root.e1.e1_body.s.attributes.s_id_e.expression"
-        ),
-        ["item.id"]
-    );
-    let expr = s
-        .resolve("View::root::e1::e1_body::s::s_id::s_id_e")
-        .unwrap();
-    let members = s.members(&expr).unwrap();
-    let mut typed = None;
-    for m in members {
-        let typings = s.typings(&m).unwrap();
-        let mut is_ts = false;
-        for t in &typings {
-            if s.qualified_name(t).unwrap().as_deref() == Some("Svelte::TypeScript") {
-                is_ts = true;
-            }
-        }
-        if is_ts {
-            typed = Some(m);
-        }
-    }
-    let tag_expr = typed.expect("the expression attribute is typed Svelte::TypeScript");
-    assert_eq!(s.evaluate(&tag_expr).unwrap(), "\"item.id\"");
-    // A component's props slot answers with its attribute-likes, its content is the tree.
-    assert_eq!(q(&mut s, "View::root.c.props"), ["c_title"]);
-    assert_eq!(q(&mut s, "View::root.c.props.localName"), ["title"]);
-    assert_eq!(q(&mut s, "View::root.c.childNodes"), ["c_p"]);
-    assert_eq!(
-        q(&mut s, "View::root.c.c_props.c_title.parentNode"),
-        [] as [String; 0]
-    );
-}
-
-/// The ambient libraries load with any directory library (interim
-/// mechanism) — no file needs naming.
-#[test]
-fn ambient_libraries_load_with_a_directory_library() {
+fn ambient_library_loads_with_a_directory_library() {
     let dir = std::env::temp_dir().join(format!("sysmlv2-ambient-{}", std::process::id()));
     std::fs::create_dir_all(&dir).unwrap();
     std::fs::write(
@@ -1524,178 +1278,26 @@ fn ambient_libraries_load_with_a_directory_library() {
         "library package Tiny { part def T; }\n",
     )
     .unwrap();
-    let user = "package M {\n    private import Web::HTML::Elements::*;\n    part d : Div;\n    part t : Template::Text;\n    part k : Svelte::KeyBlock;\n    part y : Tiny::T;\n}\n";
+    let user =
+        "package M {\n    metadata tag : TransformMeta::Generated;\n    part y : Tiny::T;\n}\n";
     let mut session =
         sysmlv2_transform::Session::from_sources(vec![("m.sysml".into(), user.into())])
             .unwrap()
             .with_library(&dir)
             .unwrap();
     let r = session.resolved();
-    for qn in [
-        "Web::DOM::Node",
-        "Web::HTML::Elements::Div",
-        "Template::Root",
-        "Svelte::RegularElement",
-        "TransformMeta::Generated",
-        "Tiny::T",
-    ] {
-        assert!(r.resolve_qualified(qn).is_some(), "{qn} resolves ambiently");
-    }
-    let d = r.resolve_qualified("M::d").unwrap();
-    let node = r.resolve_qualified("Web::DOM::Node").unwrap();
-    assert!(r.is_library_element(node));
-    assert!(!r.is_library_element(d));
+    let generated = r
+        .resolve_qualified("TransformMeta::Generated")
+        .expect("TransformMeta resolves ambiently");
+    assert!(r.is_library_element(generated));
+    let tag = r.resolve_qualified("M::tag").unwrap();
+    assert_eq!(r.typings(tag), [generated]);
+    assert!(r.resolve_qualified("Tiny::T").is_some());
+    let y = r.resolve_qualified("M::y").unwrap();
+    assert!(!r.is_library_element(y));
     std::fs::remove_dir_all(&dir).ok();
 }
 
-/// Semantic mode: a view usage's exposed slice renders
-/// through the rendering definition's template; the model is untouched.
-#[test]
-fn render_view_evaluates_a_template_over_the_exposed_slice() {
-    let component = r#"package Listing {
-    private import Svelte::*;
-    private import Web::HTML::Elements::*;
-
-    rendering def ListingRendering {
-        part <r> root : Root {
-            part <r_env> :>> environment : Environment {
-                :>> implementation = "svelte";
-                part <r_inputs> :>> inputs {
-                    part <r_in1> : InputBinding {
-                        :>> name = "things";
-                    }
-                }
-            }
-
-            part <e1> : EachBlock {
-                attribute :>> expression : JavaScript = "things";
-                attribute :>> kerml : KerML = "things";
-                attribute :>> context : JavaScript = "t";
-                attribute :>> kermlContext : KerML = "t = 'item'";
-
-                part <e1_body> :>> body {
-                    part <li> : RegularElement, Li {
-                        :>> className = "thing";
-
-                        part <li_t> : ExpressionTag {
-                            attribute :>> expression : JavaScript = "t.name";
-                            attribute :>> kerml : KerML = "declaredName(t)";
-                        }
-                    }
-                }
-
-                part <e1_fb> :>> fallback {
-                    part <p> : RegularElement, P {
-                        part <p_t> : Text {
-                            :>> data = "nothing";
-                        }
-                    }
-                }
-            }
-
-            part <input> : RegularElement, Input {
-                :>> id = "false";
-                :>> title = "true";
-                :>> draggable = false;
-                :>> disabled = false;
-                :>> checked = true;
-            }
-        }
-    }
-
-    view def ListingView {
-        rendering 'rendering' : ListingRendering;
-        render 'rendering';
-    }
-}
-"#;
-    let model = "package Meta {\n    metadata def Hidden;\n}\npackage M {\n    part def A;\n    part def B;\n    part def C;\n}\n";
-    // A resolvable filter nothing satisfies exposes an empty slice.
-    let site = "package S {\n    private import Listing::*;\n    view every : ListingView {\n        expose M::*;\n    }\n    view none : ListingView {\n        expose M::*;\n        filter @Meta::Hidden;\n    }\n}\n";
-    let src = sources(&[
-        ("Web.sysml", WEB_LIBRARY),
-        ("Template.sysml", TEMPLATE_LIBRARY),
-        ("Svelte.sysml", SVELTE_LIBRARY),
-        ("listing.sysml", component),
-        ("m.sysml", model),
-        ("s.sysml", site),
-    ]);
-    let mut s = Session::from_sources(&src).unwrap();
-    let before = s.to_compact_json();
-    let html = s.render_view("S::every", Some("html".into())).unwrap();
-    assert_eq!(
-        html,
-        "<li class=\"thing\">A</li><li class=\"thing\">B</li><li class=\"thing\">C</li><input id=\"false\" title=\"true\" draggable=\"false\" checked>"
-    );
-    let json: serde_json::Value =
-        serde_json::from_str(&s.render_view("S::every", None).unwrap()).unwrap();
-    assert_eq!(json.as_array().unwrap().len(), 4);
-    assert_eq!(json[0]["properties"]["className"], "thing");
-    assert_eq!(json[0]["children"][0]["data"], "A");
-    assert_eq!(
-        s.render_view("S::none", Some("html".into())).unwrap(),
-        "<p>nothing</p><input id=\"false\" title=\"true\" draggable=\"false\" checked>"
-    );
-    assert_eq!(
-        s.to_compact_json(),
-        before,
-        "rendering writes nothing into the model"
-    );
-    assert!(s.render_view("S::missing", None).is_err());
-}
-
-/// A rendering written in plain DOM parts — `Web::HTML::Elements` types,
-/// anonymous, no template `Root` — renders like a template: the
-/// rendering definition is the root and its element parts are elements.
-#[test]
-fn render_view_accepts_plain_dom_parts_without_a_template_root() {
-    let view = r#"package BrowserViews {
-    private import Web::DOM::*;
-    private import Web::HTML::Elements::*;
-
-    rendering def SummaryRendering {
-        part : Article {
-            part : H2 {
-                part : Text {
-                    :>> data = "Overview";
-                }
-            }
-
-            part : P {
-                :>> className = "lead";
-                part : Text {
-                    :>> data = "A rendered view.";
-                }
-            }
-        }
-    }
-
-    view def SummaryView {
-        rendering 'rendering' : SummaryRendering;
-        render 'rendering';
-    }
-
-    view summary : SummaryView {
-        expose M::*;
-    }
-}
-"#;
-    let model = "package M {\n    part def A;\n}\n";
-    let src = sources(&[
-        ("Web.sysml", WEB_LIBRARY),
-        ("Template.sysml", TEMPLATE_LIBRARY),
-        ("Svelte.sysml", SVELTE_LIBRARY),
-        ("views.sysml", view),
-        ("m.sysml", model),
-    ]);
-    let mut s = Session::from_sources(&src).unwrap();
-    assert_eq!(
-        s.render_view("BrowserViews::summary", Some("html".into()))
-            .unwrap(),
-        "<article><h2>Overview</h2><p class=\"lead\">A rendered view.</p></article>"
-    );
-}
-
 #[test]
 fn anonymous_graph_elements_are_reachable_by_id() {
     let source = "package P { action a; action b; succession first a then b; constraint { true } }";
@@ -1769,8 +1371,8 @@ fn id_lookup_preserves_library_read_only_and_handle_generation() {
 }
 
 /// A stand-in for the standard `Views` library package, loaded as a
-/// library so that `asElementTable` is a library element — referenced
-/// by spelling, never by id, exactly as the shipped library is.
+/// library so that `asElementTable` is a library element, exactly as the
+/// shipped library is.
 const VIEWS_LIBRARY: &str = "standard library package Views {\n    rendering def Rendering;\n    rendering def TabularRendering :> Rendering;\n    rendering asElementTable : TabularRendering;\n}\n";
 
 /// A matrix-view fixture over [`VIEWS_LIBRARY`]: the generated support
@@ -1835,7 +1437,7 @@ fn view_info_reports_exposure_rendering_and_metadata() {
     assert!(columns["views"].as_array().unwrap().is_empty());
     let masses: serde_json::Value =
         serde_json::from_str(&s.view_info("S::masses").unwrap()).unwrap();
-    // The standard rendering is a library element: found by its spelling.
+    // The standard rendering is a library element.
     assert_eq!(masses["rendering"], "asElementTable");
     // The reported name is the model's canonical spelling, whatever the
     // caller quoted.
@@ -1857,6 +1459,34 @@ fn view_info_reports_exposure_rendering_and_metadata() {
     assert_eq!(s.to_compact_json(), before, "reading a view writes nothing");
 }
 
+/// A view usage without a `render` member of its own reports the
+/// rendering it inherits: from the definition that types it, or through
+/// a view usage it specializes. The inherited rendering resolves where
+/// its definition declares it, here through an import only that
+/// definition's package has. A view's own `render` member takes
+/// precedence over an inherited one.
+#[test]
+fn view_info_reports_an_inherited_rendering() {
+    let mut s = Session::from_sources(&sources(&[(
+        "views.sysml",
+        "package M {\n    part a;\n    part b;\n}\npackage Defs {\n    private import Views::*;\n    view def Listing { render asElementTable; }\n}\npackage S {\n    rendering asOutline : Views::Rendering;\n    view def TV { render Views::asElementTable; }\n    view v : TV { expose M::*; }\n    view listed : Defs::Listing { expose M::*; }\n    view outlined : TV {\n        expose M::*;\n        render asOutline;\n    }\n    view narrowed :> v;\n}\n",
+    )]))
+    .unwrap();
+    s.load_library_sources(&sources(&[("Views.sysml", VIEWS_LIBRARY)]), None)
+        .unwrap();
+    let before = s.to_compact_json();
+    let info = |s: &mut Session, view: &str| -> serde_json::Value {
+        serde_json::from_str(&s.view_info(view).unwrap()).unwrap()
+    };
+    let v = info(&mut s, "S::v");
+    assert_eq!(v["rendering"], "asElementTable");
+    assert_eq!(exposed_names(&v), ["M::a", "M::b"]);
+    assert_eq!(info(&mut s, "S::listed")["rendering"], "asElementTable");
+    assert_eq!(info(&mut s, "S::outlined")["rendering"], "asOutline");
+    assert_eq!(info(&mut s, "S::narrowed")["rendering"], "asElementTable");
+    assert_eq!(s.to_compact_json(), before, "reading a view writes nothing");
+}
+
 #[test]
 fn view_directed_diagrams_show_the_exposure() {
     let mut s = matrix_view_session();
diff --git a/crates/sysmlv2-wasm/tests/implied_conformance.rs b/crates/sysmlv2-wasm/tests/implied_conformance.rs
new file mode 100644
index 0000000..45131b5
--- /dev/null
+++ b/crates/sysmlv2-wasm/tests/implied_conformance.rs
@@ -0,0 +1,17 @@
+use sysmlv2_wasm::Session;
+
+#[test]
+fn implied_conformance_is_additive_and_guards_both_arguments() {
+    let users = r#"[{"name":"p.sysml","text":"package P { part def Box; }"}]"#;
+    let library =
+        r#"[{"name":"Parts.kerml","text":"standard library package Parts { class Part; }"}]"#;
+    let mut session = Session::from_sources_with_library(users, None, None).unwrap();
+    let stale = session.resolve("P::Box").unwrap();
+    session.load_library_sources(library, None).unwrap();
+    let source = session.resolve("P::Box").unwrap();
+    let target = session.resolve("Parts::Part").unwrap();
+    assert!(!session.conforms(&source, &target).unwrap());
+    assert!(session.conforms_with_implied(&source, &target).unwrap());
+    assert!(session.conforms_with_implied(&stale, &target).is_err());
+    assert!(session.conforms_with_implied(&source, &stale).is_err());
+}
diff --git a/crates/sysmlv2-wasm/tests/prepared_library.rs b/crates/sysmlv2-wasm/tests/prepared_library.rs
index 968b072..aa07713 100644
--- a/crates/sysmlv2-wasm/tests/prepared_library.rs
+++ b/crates/sysmlv2-wasm/tests/prepared_library.rs
@@ -1,5 +1,5 @@
 //! Shared libraries preserve the source-library API's graph and edit behavior.
-use sysmlv2_wasm::{PreparedLibrary, Session};
+use sysmlv2_wasm::{LspServer, PreparedLibrary, Session};
 
 fn sources(units: &[(&str, &str)]) -> String {
     serde_json::to_string(
@@ -128,6 +128,38 @@ fn prepared_sources_reject_stale_corrupt_and_truncated_recordings() {
     );
 }
 
+/// A prepared library keeps the snapshot it was prepared with, or the
+/// recording it made while preparing, and a workspace that must resolve
+/// the library together with its own units answers as a session on the
+/// sources does: one that supplies a root name the library looked up and
+/// missed replays the recording's outcomes, one with a root filter takes
+/// its element identities and resolves the library's references again,
+/// and one with a root declaration named like the library's resolves the
+/// library afresh.
+#[test]
+fn joint_builds_on_a_prepared_library_answer_like_its_sources() {
+    let lib = [(
+        "lib.sysml",
+        "package L { part def A; part def B :> A { attribute x : Measured; } }",
+    )];
+    let mut model = sysmlv2_model::model::Model::new();
+    for (name, text) in lib {
+        model.add_library_source(name, text);
+    }
+    model.record_library_cache();
+    let _ = sysmlv2_model::json::ResolvedModel::build(&model);
+    let snapshot = model.take_recorded_library_cache().unwrap().to_bytes();
+    for user in [
+        "package L { part def Z; } package U { part b : L::B; }",
+        "attribute def Measured; package U { part b : L::B; attribute y :> b.x; }",
+        "filter true; package U { part b : L::B; }",
+    ] {
+        for snapshot in [None, Some(snapshot.clone())] {
+            parity(&lib, &[("user.sysml", user)], snapshot);
+        }
+    }
+}
+
 #[test]
 fn sessions_retain_shared_library_and_isolate_edits() {
     let text = "package L { part def A; attribute value = 3; }";
@@ -176,3 +208,95 @@ fn prepared_library_supports_interchange_and_attachment() {
     assert!(attached.metaclass(&stale).is_err());
     assert_eq!(attached.to_compact_json(), original.to_compact_json());
 }
+
+/// A language server over a prepared library answers as one over the same
+/// sources and snapshot, and outlives the prepared library's handle.
+#[test]
+fn language_server_on_a_prepared_library_answers_like_its_sources() {
+    let unit = (
+        "MiniLib.sysml",
+        "package MiniLib {\n    part def Widget;\n    part def Gadget :> Widget;\n}\n",
+    );
+    let library = sources(&[unit]);
+    let conversation = |mut lsp: LspServer| {
+        let mut out = Vec::new();
+        for message in [
+            r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{"general":{"positionEncodings":["utf-8"]}}}}"#,
+            r#"{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///w/m.sysml","languageId":"sysml","version":1,"text":"package P {\n    private import MiniLib::*;\n    part g : Gadget;\n    part def X;\n}\n"}}}"#,
+            r#"{"jsonrpc":"2.0","id":2,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:///w/m.sysml"},"position":{"line":3,"character":4}}}"#,
+            r#"{"jsonrpc":"2.0","id":3,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///w/m.sysml"},"position":{"line":2,"character":14}}}"#,
+            r#"{"jsonrpc":"2.0","id":4,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///w/m.sysml"},"position":{"line":2,"character":14}}}"#,
+        ] {
+            out.push(lsp.handle(message).unwrap());
+        }
+        out
+    };
+    let mut model = sysmlv2_model::model::Model::new();
+    model.add_library_source(unit.0, unit.1);
+    model.record_library_cache();
+    let _ = sysmlv2_model::json::ResolvedModel::build(&model);
+    let snapshot = model.take_recorded_library_cache().unwrap().to_bytes();
+    for snapshot in [None, Some(snapshot)] {
+        let expected = conversation(LspServer::with_library(&library, snapshot.clone()).unwrap());
+        let prepared = PreparedLibrary::new(&library, snapshot).unwrap();
+        let lsp = LspServer::with_prepared_library(&prepared);
+        drop(prepared);
+        assert_eq!(conversation(lsp), expected);
+        assert!(
+            expected[4][0].contains("MiniLib.sysml"),
+            "{:?}",
+            expected[4]
+        );
+    }
+}
+
+/// A handle decoded from a prepared snapshot of the bundle equals one prepared
+/// from the bundle's source; a snapshot of other units, or garbage, is refused.
+#[test]
+fn snapshot_handles_match_source_handles_and_refuse_other_units() {
+    let lib = [(
+        "lib.sysml",
+        "package L { part def A; part def B :> A; attribute def M; }",
+    )];
+    let users = [("user.sysml", "package U { part a : L::A; part b : L::B; }")];
+    let library = sources(&lib);
+    let users = sources(&users);
+    let units: Vec<(String, String)> = lib
+        .iter()
+        .map(|(n, t)| (n.to_string(), t.to_string()))
+        .collect();
+    let (snapshot, recording) =
+        match sysmlv2_transform::Library::prepared_sources(units.clone(), None).unwrap() {
+            sysmlv2_transform::Library::Prepared(prepared) => {
+                let key = sysmlv2_model::libcache::hash_units(
+                    units.iter().map(|(n, t)| (n.as_str(), t.as_str())),
+                );
+                (prepared.to_bytes(key).unwrap(), prepared.recording_bytes())
+            }
+            _ => unreachable!(),
+        };
+    let decoded = PreparedLibrary::from_snapshot(snapshot.clone(), &library, recording).unwrap();
+    let prepared = PreparedLibrary::new(&library, None).unwrap();
+    let mut a = Session::from_sources_with_prepared_library(&users, &decoded).unwrap();
+    let mut b = Session::from_sources_with_prepared_library(&users, &prepared).unwrap();
+    assert_eq!(a.to_compact_json(), b.to_compact_json());
+    assert_eq!(a.check(), b.check());
+    assert_eq!(a.units(), b.units());
+    let other = sources(&[("lib.sysml", "package L { part def A; }")]);
+    assert!(
+        PreparedLibrary::from_snapshot(snapshot.clone(), &other, None).is_err(),
+        "other units"
+    );
+    assert!(
+        PreparedLibrary::from_snapshot(snapshot[..snapshot.len() / 2].to_vec(), &library, None)
+            .is_err(),
+        "truncated"
+    );
+    let mut corrupt = snapshot;
+    let last = corrupt.len() - 1;
+    corrupt[last] ^= 0xff;
+    assert!(
+        PreparedLibrary::from_snapshot(corrupt, &library, None).is_err(),
+        "corrupt"
+    );
+}
diff --git a/crates/sysmlv2-wasm/tests/settled.rs b/crates/sysmlv2-wasm/tests/settled.rs
new file mode 100644
index 0000000..48fe565
--- /dev/null
+++ b/crates/sysmlv2-wasm/tests/settled.rs
@@ -0,0 +1,309 @@
+//! A session started from the outcomes a previous session settled on
+//! answers as a session built cold does, after every kind of edit a host
+//! makes between builds, and the outcomes outlive the session that
+//! produced them.
+use std::path::{Path, PathBuf};
+use sysmlv2_wasm::{PreparedLibrary, Session, SettledOutcomes};
+
+type Units = Vec<(String, String)>;
+
+fn owned(units: &[(&str, &str)]) -> Units {
+    units
+        .iter()
+        .map(|(name, text)| (name.to_string(), text.to_string()))
+        .collect()
+}
+
+fn sources(units: &[(String, String)]) -> String {
+    serde_json::to_string(
+        &units
+            .iter()
+            .map(|(name, text)| serde_json::json!({"name": name, "text": text}))
+            .collect::<Vec<_>>(),
+    )
+    .unwrap()
+}
+
+/// What a session answers: its compact and full interchange documents,
+/// its findings, warnings, units and unresolved count.
+fn answers(session: &mut Session) -> String {
+    [
+        session.to_compact_json(),
+        session.to_full_json(true),
+        session.check(),
+        session.warnings(),
+        session.units(),
+        session.unresolved_count().to_string(),
+    ]
+    .join("\n")
+}
+
+/// The edits a host makes between builds, each over `units`: a comment
+/// appended to a unit, a unit emptied, a declaration inserted at the top
+/// of a unit (every reference after it shifts), a unit dropped, a unit
+/// added, and the units in reverse order.
+fn edits(units: &[(String, String)]) -> Vec<(String, Units)> {
+    let mut out = Vec::new();
+    for (i, (name, _)) in units.iter().enumerate() {
+        let mut commented = units.to_vec();
+        commented[i].1.push_str("\n// edited\n");
+        out.push((format!("{name} commented"), commented));
+        let mut emptied = units.to_vec();
+        emptied[i].1 = "package Edited;".to_string();
+        out.push((format!("{name} emptied"), emptied));
+        let mut shifted = units.to_vec();
+        let inserted = if name.ends_with(".kerml") {
+            "package Inserted { class Fresh; }\n"
+        } else {
+            "package Inserted { part def Fresh; }\n"
+        };
+        shifted[i].1.insert_str(0, inserted);
+        out.push((format!("{name} shifted"), shifted));
+        let mut dropped = units.to_vec();
+        dropped.remove(i);
+        out.push((format!("{name} dropped"), dropped));
+    }
+    let mut added = units.to_vec();
+    added.push((
+        "added.sysml".to_string(),
+        "package Added { part def Extra; part extra : Extra; }".to_string(),
+    ));
+    out.push(("a unit added".to_string(), added));
+    let mut reversed = units.to_vec();
+    reversed.reverse();
+    out.push(("units reversed".to_string(), reversed));
+    out
+}
+
+/// `units` with `from` respelled `to` in `unit`: a rename that unresolves
+/// the references other units make to the renamed element.
+fn renamed(units: &[(String, String)], unit: &str, from: &str, to: &str) -> (String, Units) {
+    let mut renamed = units.to_vec();
+    let (_, text) = renamed
+        .iter_mut()
+        .find(|(name, _)| name == unit)
+        .expect("the renamed unit exists");
+    assert!(text.contains(from), "{unit} spells {from}");
+    *text = text.replace(from, to);
+    (format!("{unit}: {from} renamed to {to}"), renamed)
+}
+
+/// A cold build on `library` keeps its outcomes; a build started from
+/// them answers as the cold one over the same units and over every edit
+/// in `edited_sets`, as does a build started from a seeded build's
+/// outcomes, and a build of the original units started from an edited
+/// build's.
+fn seeded_answers_as_cold(
+    library: &PreparedLibrary,
+    units: &Units,
+    edited_sets: Vec<(String, Units)>,
+) {
+    let mut cold = Session::from_sources_with_prepared_library(&sources(units), library).unwrap();
+    let before = answers(&mut cold);
+    let settled: SettledOutcomes = cold
+        .settled_outcomes()
+        .expect("a cold build on the prepared library settles");
+    assert_eq!(settled.unit_count(), units.len());
+    // the outcomes outlive the session that produced them
+    drop(cold);
+    let mut same = Session::from_sources_settled(&sources(units), library, &settled).unwrap();
+    assert_eq!(answers(&mut same), before, "the same units again");
+    let same_settled = same
+        .settled_outcomes()
+        .expect("a seeded build on the prepared library settles");
+    assert_eq!(same_settled.unit_count(), units.len());
+
+    for (label, edited) in edited_sets {
+        let mut cold =
+            Session::from_sources_with_prepared_library(&sources(&edited), library).unwrap();
+        let expected = answers(&mut cold);
+        // from the unedited build's outcomes
+        let mut seeded =
+            Session::from_sources_settled(&sources(&edited), library, &settled).unwrap();
+        assert_eq!(answers(&mut seeded), expected, "{label}");
+        // from a seeded build's own outcomes
+        let mut chained =
+            Session::from_sources_settled(&sources(&edited), library, &same_settled).unwrap();
+        assert_eq!(answers(&mut chained), expected, "{label}, chained");
+        // and back to the original units from the edited build's, when it kept any
+        if let Some(edited_settled) = seeded.settled_outcomes() {
+            let mut back =
+                Session::from_sources_settled(&sources(units), library, &edited_settled).unwrap();
+            assert_eq!(answers(&mut back), before, "{label}, back");
+        }
+    }
+}
+
+#[test]
+fn a_seeded_session_answers_as_a_cold_one_on_a_small_library() {
+    let library = PreparedLibrary::new(
+        &sources(&owned(&[(
+            "lib.kerml",
+            "package L { class A { feature x; } class B :> A { feature :>> x; } alias C for B; }",
+        )])),
+        None,
+    )
+    .unwrap();
+    let units = owned(&[
+        (
+            "u1.kerml",
+            "package U { private import L::*; feature a : C; feature x chains a.x; }",
+        ),
+        (
+            "u2.kerml",
+            "package V { private import U::*; feature b :> a; feature y chains b.x; }",
+        ),
+        (
+            "u3.sysml",
+            "package W { private import V::*; part def P; part p : P { attribute z = y; } }",
+        ),
+    ]);
+    let mut edited_sets = edits(&units);
+    edited_sets.push(renamed(&units, "u1.kerml", "feature a :", "feature aa :"));
+    seeded_answers_as_cold(&library, &units, edited_sets);
+}
+
+#[test]
+fn outcomes_are_kept_only_by_a_build_on_a_prepared_library() {
+    let library = sources(&owned(&[(
+        "lib.kerml",
+        "package L { class A { feature x; } class B :> A { feature :>> x; } }",
+    )]));
+    let units = sources(&owned(&[(
+        "u.kerml",
+        "package U { private import L::*; feature a : B; feature x chains a.x; }",
+    )]));
+    // no library: nothing to start a next build on
+    assert!(
+        Session::from_sources(&units)
+            .unwrap()
+            .settled_outcomes()
+            .is_none()
+    );
+    // the library resolved together with the units: a joint build keeps none
+    assert!(
+        Session::from_sources_with_library(&units, Some(library.clone()), None)
+            .unwrap()
+            .settled_outcomes()
+            .is_none()
+    );
+    let prepared = PreparedLibrary::new(&library, None).unwrap();
+    let mut session = Session::from_sources_with_prepared_library(&units, &prepared).unwrap();
+    let settled = session
+        .settled_outcomes()
+        .expect("kept on a prepared library");
+    assert_eq!(settled.unit_count(), 1);
+    // a rebuild keeps the latest build's outcomes
+    session
+        .edit(r#"[{"op":"rename","target":"U::a","newName":"b"}]"#)
+        .unwrap();
+    let after = session.settled_outcomes().expect("kept across an edit");
+    assert_eq!(after.unit_count(), 1);
+}
+
+/// The units under `dir`, by path.
+fn units_under(dir: &Path) -> Units {
+    let mut files = Vec::new();
+    let mut stack = vec![dir.to_path_buf()];
+    while let Some(dir) = stack.pop() {
+        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                stack.push(path);
+            } else if matches!(
+                path.extension().and_then(|e| e.to_str()),
+                Some("sysml" | "kerml")
+            ) {
+                files.push(path);
+            }
+        }
+    }
+    files.sort();
+    files
+        .into_iter()
+        .map(|p| {
+            let name = p.strip_prefix(dir).unwrap().display().to_string();
+            (name, std::fs::read_to_string(&p).unwrap())
+        })
+        .collect()
+}
+
+/// The standard library's directory: `SYSMLV2_LIBRARY`, as the package
+/// build reads it, else the corpus checkout; `None` when neither exists.
+fn standard_library_dir() -> Option<PathBuf> {
+    let dir = match std::env::var_os("SYSMLV2_LIBRARY") {
+        Some(dir) => PathBuf::from(dir),
+        None => Path::new(env!("CARGO_MANIFEST_DIR"))
+            .ancestors()
+            .nth(2)
+            .expect("crates/sysmlv2-wasm sits two levels below the root")
+            .join("spec-refs/SysML-v2-Release/sysml.library"),
+    };
+    if dir.join("Kernel Libraries").is_dir() {
+        Some(dir)
+    } else {
+        eprintln!("standard library not found at {}; skipping", dir.display());
+        None
+    }
+}
+
+#[test]
+fn a_seeded_session_answers_as_a_cold_one_on_the_standard_library() {
+    let Some(dir) = standard_library_dir() else {
+        return;
+    };
+    let mut library = units_under(&dir);
+    library.extend(sysmlv2_model::ambient::units());
+    let library = PreparedLibrary::new(&sources(&library), None).unwrap();
+    let units = owned(&[
+        (
+            "defs.sysml",
+            "package VehicleDefs {
+                private import ISQ::*;
+                part def Vehicle { attribute mass : MassValue; part engine : Engine; part wheels : Wheel[4]; }
+                part def Engine { attribute power : PowerValue; port fuelIn : FuelPort; }
+                part def Wheel { attribute diameter : LengthValue; }
+                port def FuelPort { in item fuel : Fuel; }
+                item def Fuel;
+                calc def KineticEnergy { in m : MassValue; in v : SpeedValue; return : EnergyValue = 0.5 * m * v ** 2; }
+            }",
+        ),
+        (
+            "usage.sysml",
+            "package VehicleUsage {
+                private import VehicleDefs::*;
+                private import ISQ::*;
+                private import SI::*;
+                part car : Vehicle {
+                    attribute :>> mass = 1500 [kg];
+                    part :>> engine { attribute :>> power = 150000 [W]; }
+                    part :>> wheels { attribute :>> diameter = 0.6 [m]; }
+                }
+                part tank { port fuelOut : ~FuelPort; }
+                connect tank.fuelOut to car.engine.fuelIn;
+                attribute ke : EnergyValue = KineticEnergy(car.mass, 30 [m/s]);
+            }",
+        ),
+        (
+            "views.sysml",
+            "package VehicleViews {
+                private import VehicleUsage::*;
+                private import Views::*;
+                view def PartTree;
+                view carTree : PartTree { expose car::**; render asTreeDiagram; }
+            }",
+        ),
+    ]);
+    // a sample of the matrix: a build on the standard library costs seconds unoptimized
+    let mut edited_sets: Vec<(String, Units)> = edits(&units)
+        .into_iter()
+        .filter(|(label, _)| {
+            label == "usage.sysml commented"
+                || label == "defs.sysml shifted"
+                || label == "views.sysml dropped"
+        })
+        .collect();
+    assert_eq!(edited_sets.len(), 3);
+    edited_sets.push(renamed(&units, "usage.sysml", "part car :", "part truck :"));
+    seeded_answers_as_cold(&library, &units, edited_sets);
+}
diff --git a/local-packages/README.md b/local-packages/README.md
index 1b158e7..f12aee4 100644
--- a/local-packages/README.md
+++ b/local-packages/README.md
@@ -1,29 +1,9 @@
-# Generated SysML libraries
+# Ambient library
 
-Every `.sysml` file here is a library the toolkit carries **ambiently**: `sysmlv2 check --lib`, `lint`, `query`, the language server, and the browser kernel's standard-library bundle load them after the standard library, so a model may reference `Web::DOM::Element`, `Web::HTML::Elements::Div`, `Template::EachBlock` or `Svelte::OnDirective` without naming a file. Only `TransformMeta.sysml` is maintained by hand.
+`TransformMeta.sysml` is a library the toolkit carries **ambiently**: `sysmlv2 check --lib`, `lint`, `query`, the language server, and the browser kernel's standard-library bundle load it after the standard library, so a model may reference `TransformMeta::Generated` or `TransformMeta::TransformProvenance` without naming the file. It is the metadata vocabulary that generated elements and their provenance records are annotated with (`#TransformMeta::Generated` on a generated element, `#TransformMeta::ProvenanceStore` on the package holding the records); the lint's generated-element checks read these annotations. It is maintained by hand.
 
-| file | contents | generated from |
-|---|---|---|
-| `Web.sysml` | `Web::DOM`, `Web::HTML`, `Web::HTML::Elements` | the standards' machine-readable WebIDL corpus and HTML element metadata (`@webref/idl`, `@webref/elements`, pinned in the generator's `package.json`) |
-| `Template.sysml` | the engine-neutral template core | the component-template compiler's public AST declarations (`svelte`, pinned) through the generator's core schema (`src/template.mjs`) |
-| `Svelte.sysml` | the compiler's overlay | the same declarations, mechanically |
-| `WebApp.sysml` | the framework-neutral application layer (entries, assets, navigation) | the generator's application schema (`src/template.mjs`) |
-| `SvelteKit.sysml` | the route/SSR overlay (route tree, roles and loci, declared render policies, hooks, matchers, boundary diagnostics, adapter) | the generator's route schema (`src/template.mjs`) |
-| `*.provenance.json` | per-element provenance (spec, interface, member, URL, IDL type, dataset revisions) | the generator |
-
-Never edit the generated files: regenerate them.
-
-## Using and validating the libraries
-
-The generated sources and provenance sidecars are included in this repository. No generator is needed to use them. Dataset revisions and per-element origins are recorded in the file headers and sidecars; do not edit generated sources by hand. The generation tool is not distributed with this repository.
-
-With the standard-library submodule initialized, validate the checked-in sources locally:
+`SYSMLV2_AMBIENT=off` keeps the built-in copy out of a run, so an edited copy can be checked as a candidate without the two colliding:
 
 ```sh
-SYSMLV2_AMBIENT=off cargo run --release -p sysmlv2-cli -- check --strict --lib spec-refs/SysML-v2-Release/sysml.library local-packages/Web.sysml local-packages/Template.sysml local-packages/Svelte.sysml local-packages/WebApp.sysml local-packages/SvelteKit.sysml
-cargo run --release -p sysmlv2-cli -- fmt --check local-packages/Web.sysml local-packages/Template.sysml local-packages/Svelte.sysml local-packages/WebApp.sysml local-packages/SvelteKit.sysml
+SYSMLV2_AMBIENT=off cargo run --release -p sysmlv2-cli -- check --strict --lib spec-refs/SysML-v2-Release/sysml.library local-packages/TransformMeta.sysml
 ```
-
-Both commands pass clean. Two earlier candidate-validation failures are closed — the `Base::Anything` attribute typings, and an operation repeating a name inherited through a mixin, which the generator now leaves to the inherited declaration and records in the sidecar's omission ledger. Do not suppress a check or patch generated files by hand: correct the generator, then regenerate sources and provenance together. Library-mode loading suppresses library diagnostics, so ordinary consumers never see a candidate-validation failure.
-
-`SYSMLV2_AMBIENT=off` keeps the toolkit’s built-in copies out of a check, so these files are validated as candidates. It also allows analysis against a bare standard library.
diff --git a/local-packages/Svelte.provenance.json b/local-packages/Svelte.provenance.json
deleted file mode 100644
index 750fc46..0000000
--- a/local-packages/Svelte.provenance.json
+++ /dev/null
@@ -1,802 +0,0 @@
-{
-  "generator": {
-    "name": "@sysml/web",
-    "version": "0.8.0"
-  },
-  "dataset": {
-    "svelte (declarations)": "5.57.0"
-  },
-  "kernel": "0.8.0",
-  "library": "Svelte",
-  "elements": {
-    "Svelte::Svelte::AnimateDirective": {
-      "spec": "svelte",
-      "interface": "AnimateDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::AnimateDirective::expression": {
-      "spec": "svelte",
-      "interface": "AnimateDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "null | Expression",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::AttachTag": {
-      "spec": "svelte",
-      "interface": "AttachTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "TemplateNode"
-      ]
-    },
-    "Svelte::Svelte::AttachTag::expression": {
-      "spec": "svelte",
-      "interface": "AttachTag",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::AwaitBlock": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Block"
-      ]
-    },
-    "Svelte::Svelte::AwaitBlock::catch": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "catch",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Fragment",
-      "idlType": "Fragment | null",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::AwaitBlock::error": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "error",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Pattern | null",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::AwaitBlock::expression": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::AwaitBlock::pending": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "pending",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Fragment",
-      "idlType": "Fragment | null",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::AwaitBlock::then": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "then",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Fragment",
-      "idlType": "Fragment | null",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::AwaitBlock::value": {
-      "spec": "svelte",
-      "interface": "AwaitBlock",
-      "member": "value",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Pattern | null",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::BindDirective": {
-      "spec": "svelte",
-      "interface": "BindDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::BindDirective::expression": {
-      "spec": "svelte",
-      "interface": "BindDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Identifier | MemberExpression | SequenceExpression"
-    },
-    "Svelte::Svelte::ClassDirective": {
-      "spec": "svelte",
-      "interface": "ClassDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::ClassDirective::expression": {
-      "spec": "svelte",
-      "interface": "ClassDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::ClassDirective::localName": {
-      "spec": "svelte",
-      "interface": "ClassDirective",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"class\"",
-      "redefines": true,
-      "value": "class"
-    },
-    "Svelte::Svelte::ConstTag": {
-      "spec": "svelte",
-      "interface": "ConstTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "TemplateNode"
-      ]
-    },
-    "Svelte::Svelte::ConstTag::declaration": {
-      "spec": "svelte",
-      "interface": "ConstTag",
-      "member": "declaration",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "VariableDeclaration"
-    },
-    "Svelte::Svelte::DebugTag": {
-      "spec": "svelte",
-      "interface": "DebugTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "TemplateNode"
-      ]
-    },
-    "Svelte::Svelte::DebugTag::identifiers": {
-      "spec": "svelte",
-      "interface": "DebugTag",
-      "member": "identifiers",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Identifier[]",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Svelte::Svelte::DeclarationTag": {
-      "spec": "svelte",
-      "interface": "DeclarationTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "TemplateNode"
-      ]
-    },
-    "Svelte::Svelte::DeclarationTag::declaration": {
-      "spec": "svelte",
-      "interface": "DeclarationTag",
-      "member": "declaration",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "VariableDeclaration"
-    },
-    "Svelte::Svelte::Directive": {
-      "spec": "svelte",
-      "interface": "Directive",
-      "version": "5.57.0",
-      "idlKind": "union",
-      "kind": "part",
-      "abstract": "abstract-kind",
-      "generalizations": [
-        "AttributeLike"
-      ]
-    },
-    "Svelte::Svelte::Environment": {
-      "spec": "svelte",
-      "idlKind": "datatype",
-      "kind": "part",
-      "generalizations": [
-        "ExpressionEnvironment"
-      ]
-    },
-    "Svelte::Svelte::JavaScript": {
-      "spec": "svelte",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "SourceExpression"
-      ]
-    },
-    "Svelte::Svelte::KeyBlock": {
-      "spec": "svelte",
-      "interface": "KeyBlock",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Block"
-      ]
-    },
-    "Svelte::Svelte::KeyBlock::body": {
-      "spec": "svelte",
-      "interface": "KeyBlock",
-      "member": "fragment",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Fragment",
-      "idlType": "Fragment"
-    },
-    "Svelte::Svelte::KeyBlock::expression": {
-      "spec": "svelte",
-      "interface": "KeyBlock",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::LetDirective": {
-      "spec": "svelte",
-      "interface": "LetDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::LetDirective::expression": {
-      "spec": "svelte",
-      "interface": "LetDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "null | Identifier | ArrayExpression | ObjectExpression",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::OnDirective": {
-      "spec": "svelte",
-      "interface": "OnDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::OnDirective::expression": {
-      "spec": "svelte",
-      "interface": "OnDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "null | Expression",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::OnDirective::modifiers": {
-      "spec": "svelte",
-      "interface": "OnDirective",
-      "member": "modifiers",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "Array<\n\t\t\t\t| 'capture'\n\t\t\t\t| 'nonpassive'\n\t\t\t\t| 'once'\n\t\t\t\t| 'passive'\n\t\t\t\t| 'preventDefault'\n\t\t\t\t| 'self'\n\t\t\t\t| 'stopImmediatePropagation'\n\t\t\t\t| 'stopPropagation'\n\t\t\t\t| 'trusted'\n\t\t\t>",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "enumerated:\"capture\"|\"nonpassive\"|\"once\"|\"passive\"|\"preventDefault\"|\"self\"|\"stopImmediatePropagation\"|\"stopPropagation\"|\"trusted\""
-      ]
-    },
-    "Svelte::Svelte::RegularElement": {
-      "spec": "svelte",
-      "interface": "RegularElement",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::RenderTag": {
-      "spec": "svelte",
-      "interface": "RenderTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "TemplateNode"
-      ]
-    },
-    "Svelte::Svelte::RenderTag::expression": {
-      "spec": "svelte",
-      "interface": "RenderTag",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "SimpleCallExpression | (ChainExpression & { expression: SimpleCallExpression })"
-    },
-    "Svelte::Svelte::SlotElement": {
-      "spec": "svelte",
-      "interface": "SlotElement",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SlotElement::localName": {
-      "spec": "svelte",
-      "interface": "SlotElement",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"slot\"",
-      "redefines": true,
-      "value": "slot"
-    },
-    "Svelte::Svelte::SnippetBlock": {
-      "spec": "svelte",
-      "interface": "SnippetBlock",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Block"
-      ]
-    },
-    "Svelte::Svelte::SnippetBlock::body": {
-      "spec": "svelte",
-      "interface": "SnippetBlock",
-      "member": "body",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Fragment",
-      "idlType": "Fragment"
-    },
-    "Svelte::Svelte::SnippetBlock::expression": {
-      "spec": "svelte",
-      "interface": "SnippetBlock",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Identifier"
-    },
-    "Svelte::Svelte::SnippetBlock::parameters": {
-      "spec": "svelte",
-      "interface": "SnippetBlock",
-      "member": "parameters",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Pattern[]",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Svelte::Svelte::SnippetBlock::typeParams": {
-      "spec": "svelte",
-      "interface": "SnippetBlock",
-      "member": "typeParams",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::StyleDirective": {
-      "spec": "svelte",
-      "interface": "StyleDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::StyleDirective::modifiers": {
-      "spec": "svelte",
-      "interface": "StyleDirective",
-      "member": "modifiers",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "Array<'important'>",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "literal:\"important\""
-      ]
-    },
-    "Svelte::Svelte::StyleDirective::value": {
-      "spec": "svelte",
-      "interface": "StyleDirective",
-      "member": "value",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "TemplateNode",
-      "idlType": "true | ExpressionTag | Array<ExpressionTag | Text>",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "presence:true"
-      ]
-    },
-    "Svelte::Svelte::SvelteBody": {
-      "spec": "svelte",
-      "interface": "SvelteBody",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteBody::localName": {
-      "spec": "svelte",
-      "interface": "SvelteBody",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:body\"",
-      "redefines": true,
-      "value": "svelte:body"
-    },
-    "Svelte::Svelte::SvelteBoundary": {
-      "spec": "svelte",
-      "interface": "SvelteBoundary",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteBoundary::localName": {
-      "spec": "svelte",
-      "interface": "SvelteBoundary",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:boundary\"",
-      "redefines": true,
-      "value": "svelte:boundary"
-    },
-    "Svelte::Svelte::SvelteComponent": {
-      "spec": "svelte",
-      "interface": "SvelteComponent",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteComponent::expression": {
-      "spec": "svelte",
-      "interface": "SvelteComponent",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::SvelteComponent::localName": {
-      "spec": "svelte",
-      "interface": "SvelteComponent",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:component\"",
-      "redefines": true,
-      "value": "svelte:component"
-    },
-    "Svelte::Svelte::SvelteDocument": {
-      "spec": "svelte",
-      "interface": "SvelteDocument",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteDocument::localName": {
-      "spec": "svelte",
-      "interface": "SvelteDocument",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:document\"",
-      "redefines": true,
-      "value": "svelte:document"
-    },
-    "Svelte::Svelte::SvelteElement": {
-      "spec": "svelte",
-      "interface": "SvelteElement",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteElement::localName": {
-      "spec": "svelte",
-      "interface": "SvelteElement",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:element\"",
-      "redefines": true,
-      "value": "svelte:element"
-    },
-    "Svelte::Svelte::SvelteElement::tag": {
-      "spec": "svelte",
-      "interface": "SvelteElement",
-      "member": "tag",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "Expression"
-    },
-    "Svelte::Svelte::SvelteFragment": {
-      "spec": "svelte",
-      "interface": "SvelteFragment",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteFragment::localName": {
-      "spec": "svelte",
-      "interface": "SvelteFragment",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:fragment\"",
-      "redefines": true,
-      "value": "svelte:fragment"
-    },
-    "Svelte::Svelte::SvelteHead": {
-      "spec": "svelte",
-      "interface": "SvelteHead",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteHead::localName": {
-      "spec": "svelte",
-      "interface": "SvelteHead",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:head\"",
-      "redefines": true,
-      "value": "svelte:head"
-    },
-    "Svelte::Svelte::SvelteOptions": {
-      "spec": "svelte",
-      "interface": "SvelteOptionsRaw",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteOptions::localName": {
-      "spec": "svelte",
-      "interface": "SvelteOptionsRaw",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:options\"",
-      "redefines": true,
-      "value": "svelte:options"
-    },
-    "Svelte::Svelte::SvelteSelf": {
-      "spec": "svelte",
-      "interface": "SvelteSelf",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteSelf::localName": {
-      "spec": "svelte",
-      "interface": "SvelteSelf",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:self\"",
-      "redefines": true,
-      "value": "svelte:self"
-    },
-    "Svelte::Svelte::SvelteWindow": {
-      "spec": "svelte",
-      "interface": "SvelteWindow",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::SvelteWindow::localName": {
-      "spec": "svelte",
-      "interface": "SvelteWindow",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"svelte:window\"",
-      "redefines": true,
-      "value": "svelte:window"
-    },
-    "Svelte::Svelte::TitleElement": {
-      "spec": "svelte",
-      "interface": "TitleElement",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Element"
-      ]
-    },
-    "Svelte::Svelte::TitleElement::localName": {
-      "spec": "svelte",
-      "interface": "TitleElement",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "\"title\"",
-      "redefines": true,
-      "value": "title"
-    },
-    "Svelte::Svelte::TransitionDirective": {
-      "spec": "svelte",
-      "interface": "TransitionDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::TransitionDirective::expression": {
-      "spec": "svelte",
-      "interface": "TransitionDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "null | Expression",
-      "multiplicity": "[0..1]"
-    },
-    "Svelte::Svelte::TransitionDirective::intro": {
-      "spec": "svelte",
-      "interface": "TransitionDirective",
-      "member": "intro",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Svelte::Svelte::TransitionDirective::modifiers": {
-      "spec": "svelte",
-      "interface": "TransitionDirective",
-      "member": "modifiers",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "Array<'local' | 'global'>",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "enumerated:\"local\"|\"global\""
-      ]
-    },
-    "Svelte::Svelte::TransitionDirective::outro": {
-      "spec": "svelte",
-      "interface": "TransitionDirective",
-      "member": "outro",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Svelte::Svelte::TypeScript": {
-      "spec": "svelte",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "Svelte::Svelte::JavaScript"
-      ]
-    },
-    "Svelte::Svelte::UseDirective": {
-      "spec": "svelte",
-      "interface": "UseDirective",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Svelte::Svelte::Directive"
-      ]
-    },
-    "Svelte::Svelte::UseDirective::expression": {
-      "spec": "svelte",
-      "interface": "UseDirective",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "idlType": "null | Expression",
-      "multiplicity": "[0..1]"
-    }
-  },
-  "omitted": {}
-}
diff --git a/local-packages/Svelte.sysml b/local-packages/Svelte.sysml
deleted file mode 100644
index 19172de..0000000
--- a/local-packages/Svelte.sysml
+++ /dev/null
@@ -1,147 +0,0 @@
-library package Svelte {
-    doc /* Overlay for the component-template compiler's AST: its node kinds specialize the
-       core; only engine-specific kinds are new. GENERATED from the compiler's public AST
-       declarations (see the .provenance.json sidecar) - do not edit.
-       */
-    private import ScalarValues::*;
-    public import Template::*;
-
-    part def AttachTag :> TemplateNode {
-        attribute expression : SourceExpression;
-    }
-
-    part def AwaitBlock :> Block {
-        attribute expression : SourceExpression;
-        attribute value : SourceExpression[0..1];
-        attribute error : SourceExpression[0..1];
-        part pending : Fragment[0..1];
-        part 'then' : Fragment[0..1];
-        part catch : Fragment[0..1];
-    }
-
-    part def ConstTag :> TemplateNode {
-        attribute declaration : SourceExpression;
-    }
-
-    part def DebugTag :> TemplateNode {
-        attribute identifiers : SourceExpression[0..*] ordered;
-    }
-
-    part def DeclarationTag :> TemplateNode {
-        attribute declaration : SourceExpression;
-    }
-
-    abstract part def Directive :> AttributeLike;
-
-    part def AnimateDirective :> Directive {
-        attribute expression : SourceExpression[0..1];
-    }
-
-    part def BindDirective :> Directive {
-        attribute expression : SourceExpression;
-    }
-
-    part def ClassDirective :> Directive {
-        :>> localName = "class";
-        attribute expression : SourceExpression;
-    }
-
-    part def Environment :> ExpressionEnvironment;
-
-    attribute def JavaScript :> SourceExpression;
-
-    part def KeyBlock :> Block {
-        attribute expression : SourceExpression;
-        part body : Fragment;
-    }
-
-    part def LetDirective :> Directive {
-        attribute expression : SourceExpression[0..1];
-    }
-
-    part def OnDirective :> Directive {
-        attribute expression : SourceExpression[0..1];
-        attribute modifiers : String[0..*] ordered;
-    }
-
-    part def RegularElement :> Element;
-
-    part def RenderTag :> TemplateNode {
-        attribute expression : SourceExpression;
-    }
-
-    part def SlotElement :> Element {
-        :>> localName = "slot";
-    }
-
-    part def SnippetBlock :> Block {
-        attribute expression : SourceExpression;
-        attribute parameters : SourceExpression[0..*] ordered;
-        attribute typeParams : String[0..1];
-        part body : Fragment;
-    }
-
-    part def StyleDirective :> Directive {
-        part value : TemplateNode[0..*] ordered;
-        attribute modifiers : String[0..*] ordered;
-    }
-
-    part def SvelteBody :> Element {
-        :>> localName = "svelte:body";
-    }
-
-    part def SvelteBoundary :> Element {
-        :>> localName = "svelte:boundary";
-    }
-
-    part def SvelteComponent :> Element {
-        :>> localName = "svelte:component";
-        attribute expression : SourceExpression;
-    }
-
-    part def SvelteDocument :> Element {
-        :>> localName = "svelte:document";
-    }
-
-    part def SvelteElement :> Element {
-        :>> localName = "svelte:element";
-        attribute tag : SourceExpression;
-    }
-
-    part def SvelteFragment :> Element {
-        :>> localName = "svelte:fragment";
-    }
-
-    part def SvelteHead :> Element {
-        :>> localName = "svelte:head";
-    }
-
-    part def SvelteOptions :> Element {
-        :>> localName = "svelte:options";
-    }
-
-    part def SvelteSelf :> Element {
-        :>> localName = "svelte:self";
-    }
-
-    part def SvelteWindow :> Element {
-        :>> localName = "svelte:window";
-    }
-
-    part def TitleElement :> Element {
-        :>> localName = "title";
-    }
-
-    part def TransitionDirective :> Directive {
-        attribute expression : SourceExpression[0..1];
-        attribute modifiers : String[0..*] ordered;
-        attribute intro : Boolean;
-        attribute outro : Boolean;
-    }
-
-    attribute def TypeScript :> JavaScript;
-
-    part def UseDirective :> Directive {
-        attribute expression : SourceExpression[0..1];
-    }
-}
diff --git a/local-packages/SvelteKit.provenance.json b/local-packages/SvelteKit.provenance.json
deleted file mode 100644
index 4c39d1e..0000000
--- a/local-packages/SvelteKit.provenance.json
+++ /dev/null
@@ -1,227 +0,0 @@
-{
-  "generator": {
-    "name": "@sysml/web",
-    "version": "0.8.0"
-  },
-  "dataset": {},
-  "kernel": "0.8.0",
-  "library": "SvelteKit",
-  "elements": {
-    "SvelteKit::SvelteKit::BoundaryViolation": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::BoundaryViolation::imported": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::BoundaryViolation::module": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::BoundaryViolation::path": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::BoundaryViolation::reason": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::Hook": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::Hook::exports": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::Hook::file": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::Hook::locus": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::KitProject": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::KitProject::adapter": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::KitProject::hooks": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::Hook",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::KitProject::matchers": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::Matcher",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::KitProject::routes": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::RouteSegment"
-    },
-    "SvelteKit::SvelteKit::KitProject::routesDir": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::KitProject::violations": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::BoundaryViolation",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::Matcher": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::Matcher::file": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::Matcher::name": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RenderPolicy": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::RenderPolicy::csr": {
-      "kind": "attribute",
-      "type": "Boolean",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RenderPolicy::prerender": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RenderPolicy::ssr": {
-      "kind": "attribute",
-      "type": "Boolean",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RenderPolicy::trailingSlash": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RouteFile": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::RouteFile::actions": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteFile::component": {
-      "kind": "reference",
-      "type": "ComponentDefinition",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RouteFile::exports": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteFile::locus": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteFile::methods": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteFile::name": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteFile::reset": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RouteFile::role": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteFile::uri": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteSegment": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "SvelteKit::SvelteKit::RouteSegment::children": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::RouteSegment",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteSegment::contentNegotiation": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "SvelteKit::SvelteKit::RouteSegment::files": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::RouteFile",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteSegment::id": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteSegment::kind": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "SvelteKit::SvelteKit::RouteSegment::matchers": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteSegment::parameters": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "SvelteKit::SvelteKit::RouteSegment::policy": {
-      "kind": "part",
-      "type": "SvelteKit::SvelteKit::RenderPolicy",
-      "multiplicity": "[0..1]"
-    },
-    "SvelteKit::SvelteKit::RouteSegment::segment": {
-      "kind": "attribute",
-      "type": "String"
-    }
-  },
-  "omitted": {}
-}
diff --git a/local-packages/SvelteKit.sysml b/local-packages/SvelteKit.sysml
deleted file mode 100644
index 6a3a24e..0000000
--- a/local-packages/SvelteKit.sysml
+++ /dev/null
@@ -1,69 +0,0 @@
-library package SvelteKit {
-    doc /* SvelteKit route/SSR overlay: the source route tree (segments, files with roles and
-       execution loci, declared render policies), hooks, parameter matchers, server-boundary
-       diagnostics and the deployment adapter. Effective layout chains, page policies and
-       adapter requirements are constructed from route ancestry, never repeated here.
-       GENERATED from the generator's application schema - do not edit; regenerate with
-       the websysml generator.
-       */
-    private import ScalarValues::*;
-    private import Template::*;
-
-    part def BoundaryViolation {
-        attribute module : String;
-        attribute imported : String;
-        attribute path : String[0..*] ordered;
-        attribute reason : String;
-    }
-
-    part def Hook {
-        attribute file : String;
-        attribute locus : String;
-        attribute exports : String[0..*] ordered;
-    }
-
-    part def KitProject {
-        attribute routesDir : String;
-        attribute adapter : String[0..1];
-        part hooks : Hook[0..*] ordered;
-        part matchers : Matcher[0..*] ordered;
-        part routes : RouteSegment;
-        part violations : BoundaryViolation[0..*] ordered;
-    }
-
-    part def Matcher {
-        attribute name : String;
-        attribute file : String;
-    }
-
-    part def RenderPolicy {
-        attribute ssr : Boolean[0..1];
-        attribute csr : Boolean[0..1];
-        attribute prerender : String[0..1];
-        attribute trailingSlash : String[0..1];
-    }
-
-    part def RouteFile {
-        attribute name : String;
-        attribute uri : String;
-        attribute role : String;
-        attribute locus : String;
-        attribute reset : String[0..1];
-        attribute exports : String[0..*] ordered;
-        attribute actions : String[0..*] ordered;
-        attribute methods : String[0..*] ordered;
-        ref part component : ComponentDefinition[0..1];
-    }
-
-    part def RouteSegment {
-        attribute segment : String;
-        attribute id : String;
-        attribute kind : String;
-        attribute parameters : String[0..*] ordered;
-        attribute matchers : String[0..*] ordered;
-        attribute contentNegotiation : Boolean;
-        part files : RouteFile[0..*] ordered;
-        part policy : RenderPolicy[0..1];
-        part children : RouteSegment[0..*] ordered;
-    }
-}
diff --git a/local-packages/Template.provenance.json b/local-packages/Template.provenance.json
deleted file mode 100644
index 18c502b..0000000
--- a/local-packages/Template.provenance.json
+++ /dev/null
@@ -1,612 +0,0 @@
-{
-  "generator": {
-    "name": "@sysml/web",
-    "version": "0.8.0"
-  },
-  "dataset": {
-    "svelte (declarations)": "5.57.0"
-  },
-  "kernel": "0.8.0",
-  "library": "Template",
-  "elements": {
-    "Template::Template::Attribute": {
-      "spec": "svelte",
-      "interface": "Attribute",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::AttributeLike"
-      ]
-    },
-    "Template::Template::AttributeLike": {
-      "spec": "template-core",
-      "idlKind": "abstract",
-      "kind": "part",
-      "abstract": "abstract-kind",
-      "generalizations": [
-        "Web::DOM::Attr"
-      ]
-    },
-    "Template::Template::Block": {
-      "spec": "template-core",
-      "idlKind": "abstract",
-      "kind": "part",
-      "abstract": "abstract-kind",
-      "generalizations": [
-        "Template::Template::TemplateNode"
-      ]
-    },
-    "Template::Template::Comment": {
-      "spec": "svelte",
-      "interface": "Comment",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode",
-        "Web::DOM::Comment"
-      ]
-    },
-    "Template::Template::Component": {
-      "spec": "svelte",
-      "interface": "Component",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode"
-      ]
-    },
-    "Template::Template::Component::name": {
-      "spec": "svelte",
-      "interface": "Component",
-      "member": "name",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::Component::props": {
-      "spec": "svelte",
-      "interface": "Component",
-      "member": "attributes",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Template::Template::AttributeLike",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ComponentDefinition": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "Template::Template::ComponentDefinition::contentHash": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::ComponentDefinition::dependencies": {
-      "kind": "part",
-      "type": "Template::Template::SourceDependency",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ComponentDefinition::export": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::ComponentDefinition::module": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::ComponentDefinition::props": {
-      "kind": "part",
-      "type": "Template::Template::PropDeclaration",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ComponentDefinition::restProps": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Template::Template::ComponentDefinition::root": {
-      "kind": "reference",
-      "type": "Template::Template::Root",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ComponentDefinition::uri": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::EachBlock": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::Block"
-      ]
-    },
-    "Template::Template::EachBlock::body": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "body",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Template::Template::Fragment",
-      "idlType": "Fragment"
-    },
-    "Template::Template::EachBlock::context": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "context",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Pattern | null",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::expression": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression"
-    },
-    "Template::Template::EachBlock::fallback": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "fallback",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Template::Template::Fragment",
-      "idlType": "Fragment",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::index": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "index",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::kerml": {
-      "spec": "template-core",
-      "member": "kerml",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::kermlContext": {
-      "spec": "template-core",
-      "member": "kermlContext",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::kermlKey": {
-      "spec": "template-core",
-      "member": "kermlKey",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::EachBlock::key": {
-      "spec": "svelte",
-      "interface": "EachBlock",
-      "member": "key",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::Element": {
-      "spec": "svelte",
-      "interface": "RegularElement",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode",
-        "Web::DOM::Element"
-      ]
-    },
-    "Template::Template::Element::attributes": {
-      "spec": "svelte",
-      "interface": "RegularElement",
-      "member": "attributes",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::AttributeLike",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "redefines": true
-    },
-    "Template::Template::ExpressionEnvironment": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "Template::Template::ExpressionEnvironment::bindings": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ExpressionEnvironment::capabilities": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ExpressionEnvironment::dependencies": {
-      "kind": "part",
-      "type": "Template::Template::SourceDependency",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ExpressionEnvironment::implementation": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::ExpressionEnvironment::imports": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ExpressionEnvironment::inputs": {
-      "kind": "part",
-      "type": "Template::Template::InputBinding",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::ExpressionEnvironment::module": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionEnvironment::scope": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionEnvironment::version": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionTag": {
-      "spec": "svelte",
-      "interface": "ExpressionTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode"
-      ]
-    },
-    "Template::Template::ExpressionTag::embedded": {
-      "spec": "template-core",
-      "member": "embedded",
-      "kind": "part",
-      "type": "Template::Template::TemplateNode",
-      "multiplicity": "[0..*]"
-    },
-    "Template::Template::ExpressionTag::environment": {
-      "spec": "template-core",
-      "member": "environment",
-      "kind": "reference",
-      "type": "Template::Template::ExpressionEnvironment",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionTag::expression": {
-      "spec": "svelte",
-      "interface": "ExpressionTag",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression"
-    },
-    "Template::Template::ExpressionTag::kerml": {
-      "spec": "template-core",
-      "member": "kerml",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionTag::python": {
-      "spec": "template-core",
-      "member": "python",
-      "kind": "attribute",
-      "type": "Template::Template::Python",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionTag::sparql": {
-      "spec": "template-core",
-      "member": "sparql",
-      "kind": "attribute",
-      "type": "Template::Template::SPARQL",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::ExpressionTag::view": {
-      "spec": "template-core",
-      "member": "view",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::Fragment": {
-      "spec": "svelte",
-      "interface": "Fragment",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode",
-        "Web::DOM::DocumentFragment"
-      ]
-    },
-    "Template::Template::HtmlTag": {
-      "spec": "svelte",
-      "interface": "HtmlTag",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode"
-      ]
-    },
-    "Template::Template::HtmlTag::environment": {
-      "spec": "template-core",
-      "member": "environment",
-      "kind": "reference",
-      "type": "Template::Template::ExpressionEnvironment",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::HtmlTag::expression": {
-      "spec": "svelte",
-      "interface": "HtmlTag",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression"
-    },
-    "Template::Template::HtmlTag::kerml": {
-      "spec": "template-core",
-      "member": "kerml",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::HtmlTag::view": {
-      "spec": "template-core",
-      "member": "view",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::IfBlock": {
-      "spec": "svelte",
-      "interface": "IfBlock",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::Block"
-      ]
-    },
-    "Template::Template::IfBlock::alternate": {
-      "spec": "svelte",
-      "interface": "IfBlock",
-      "member": "alternate",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Template::Template::Fragment",
-      "idlType": "Fragment | null",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::IfBlock::consequent": {
-      "spec": "svelte",
-      "interface": "IfBlock",
-      "member": "consequent",
-      "version": "5.57.0",
-      "kind": "part",
-      "type": "Template::Template::Fragment",
-      "idlType": "Fragment"
-    },
-    "Template::Template::IfBlock::kerml": {
-      "spec": "template-core",
-      "member": "kerml",
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::IfBlock::test": {
-      "spec": "svelte",
-      "interface": "IfBlock",
-      "member": "test",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression"
-    },
-    "Template::Template::InputBinding": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "Template::Template::InputBinding::name": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::InputBinding::selection": {
-      "kind": "attribute",
-      "type": "Template::Template::KerML",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::KerML": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "Template::Template::SourceExpression"
-      ]
-    },
-    "Template::Template::PropDeclaration": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "Template::Template::PropDeclaration::bindable": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Template::Template::PropDeclaration::defaultValue": {
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::PropDeclaration::legacy": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Template::Template::PropDeclaration::modelType": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::PropDeclaration::name": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::PropDeclaration::required": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Template::Template::PropDeclaration::snippet": {
-      "kind": "attribute",
-      "type": "Boolean"
-    },
-    "Template::Template::PropDeclaration::typeText": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::Python": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "Template::Template::SourceExpression"
-      ]
-    },
-    "Template::Template::Root": {
-      "spec": "svelte",
-      "interface": "Root",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode"
-      ]
-    },
-    "Template::Template::Root::environment": {
-      "spec": "template-core",
-      "member": "environment",
-      "kind": "part",
-      "type": "Template::Template::ExpressionEnvironment"
-    },
-    "Template::Template::Root::queryEnvironments": {
-      "spec": "template-core",
-      "member": "queryEnvironments",
-      "kind": "part",
-      "type": "Template::Template::ExpressionEnvironment",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "Template::Template::SPARQL": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "Template::Template::SourceExpression"
-      ]
-    },
-    "Template::Template::SourceDependency": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "Template::Template::SourceDependency::contentHash": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::SourceDependency::resolvedUri": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "Template::Template::SourceDependency::specifier": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "Template::Template::SourceExpression": {
-      "spec": "template-core",
-      "idlKind": "datatype",
-      "kind": "attribute",
-      "generalizations": [
-        "String"
-      ]
-    },
-    "Template::Template::SpreadAttribute": {
-      "spec": "svelte",
-      "interface": "SpreadAttribute",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::AttributeLike"
-      ]
-    },
-    "Template::Template::SpreadAttribute::expression": {
-      "spec": "svelte",
-      "interface": "SpreadAttribute",
-      "member": "expression",
-      "version": "5.57.0",
-      "kind": "attribute",
-      "type": "Template::Template::SourceExpression",
-      "idlType": "Expression"
-    },
-    "Template::Template::TemplateNode": {
-      "spec": "template-core",
-      "idlKind": "abstract",
-      "kind": "part",
-      "abstract": "abstract-kind",
-      "generalizations": [
-        "Web::DOM::Node"
-      ]
-    },
-    "Template::Template::Text": {
-      "spec": "svelte",
-      "interface": "Text",
-      "version": "5.57.0",
-      "idlKind": "node",
-      "kind": "part",
-      "generalizations": [
-        "Template::Template::TemplateNode",
-        "Web::DOM::Text"
-      ]
-    }
-  },
-  "omitted": {}
-}
diff --git a/local-packages/Template.sysml b/local-packages/Template.sysml
deleted file mode 100644
index 8f45ff4..0000000
--- a/local-packages/Template.sysml
+++ /dev/null
@@ -1,129 +0,0 @@
-library package Template {
-    doc /* Engine-neutral template core: a DOM tree with extra node kinds. Engine overlays
-       specialize this package; expression sources retain an evaluator-specific datatype
-       and environment. GENERATED from a template compiler's public AST declarations
-       (see the .provenance.json sidecar) - do not edit; regenerate with the websysml generator.
-       */
-    private import ScalarValues::*;
-
-    abstract part def AttributeLike :> Web::DOM::Attr;
-
-    part def Attribute :> AttributeLike;
-
-    part def ComponentDefinition {
-        attribute uri : String;
-        attribute export : String;
-        attribute contentHash : String;
-        attribute module : String;
-        attribute restProps : Boolean;
-        part props : PropDeclaration[0..*] ordered;
-        ref part root : Root[0..1];
-        part dependencies : SourceDependency[0..*] ordered;
-    }
-
-    part def ExpressionEnvironment {
-        attribute implementation : String;
-        attribute version : String[0..1];
-        attribute module : String[0..1];
-        attribute scope : String[0..1];
-        attribute bindings : String[0..*] ordered;
-        attribute imports : String[0..*] ordered;
-        attribute capabilities : String[0..*] ordered;
-        part dependencies : SourceDependency[0..*] ordered;
-        part inputs : InputBinding[0..*] ordered;
-    }
-
-    part def InputBinding {
-        attribute name : String;
-        attribute selection : KerML[0..1];
-    }
-
-    part def PropDeclaration {
-        attribute name : String;
-        attribute typeText : String[0..1];
-        attribute defaultValue : SourceExpression[0..1];
-        attribute bindable : Boolean;
-        attribute snippet : Boolean;
-        attribute required : Boolean;
-        attribute legacy : Boolean;
-        attribute modelType : String[0..1];
-    }
-
-    part def SourceDependency {
-        attribute specifier : String;
-        attribute resolvedUri : String[0..1];
-        attribute contentHash : String[0..1];
-    }
-
-    attribute def SourceExpression :> String;
-
-    attribute def KerML :> SourceExpression;
-
-    attribute def Python :> SourceExpression;
-
-    attribute def SPARQL :> SourceExpression;
-
-    part def SpreadAttribute :> AttributeLike {
-        attribute expression : SourceExpression;
-    }
-
-    abstract part def TemplateNode :> Web::DOM::Node;
-
-    abstract part def Block :> TemplateNode;
-
-    part def Comment :> TemplateNode, Web::DOM::Comment;
-
-    part def Component :> TemplateNode {
-        attribute name : String;
-        part props : AttributeLike[0..*] ordered;
-    }
-
-    part def EachBlock :> Block {
-        attribute expression : SourceExpression;
-        attribute context : SourceExpression[0..1];
-        part body : Fragment;
-        part fallback : Fragment[0..1];
-        attribute index : String[0..1];
-        attribute key : SourceExpression[0..1];
-        attribute kerml : KerML[0..1];
-        attribute kermlContext : KerML[0..1];
-        attribute kermlKey : KerML[0..1];
-    }
-
-    part def Element :> TemplateNode, Web::DOM::Element {
-        :>> attributes : AttributeLike[0..*] ordered;
-    }
-
-    part def ExpressionTag :> TemplateNode {
-        attribute expression : SourceExpression;
-        part embedded : TemplateNode[0..*];
-        attribute kerml : KerML[0..1];
-        attribute python : Python[0..1];
-        attribute sparql : SPARQL[0..1];
-        attribute 'view' : KerML[0..1];
-        ref part environment : ExpressionEnvironment[0..1];
-    }
-
-    part def Fragment :> TemplateNode, Web::DOM::DocumentFragment;
-
-    part def HtmlTag :> TemplateNode {
-        attribute expression : SourceExpression;
-        attribute kerml : KerML[0..1];
-        attribute 'view' : KerML[0..1];
-        ref part environment : ExpressionEnvironment[0..1];
-    }
-
-    part def IfBlock :> Block {
-        attribute test : SourceExpression;
-        part consequent : Fragment;
-        part alternate : Fragment[0..1];
-        attribute kerml : KerML[0..1];
-    }
-
-    part def Root :> TemplateNode {
-        part environment : ExpressionEnvironment;
-        part queryEnvironments : ExpressionEnvironment[0..*] ordered;
-    }
-
-    part def Text :> TemplateNode, Web::DOM::Text;
-}
diff --git a/local-packages/Web.provenance.json b/local-packages/Web.provenance.json
deleted file mode 100644
index e6e32c8..0000000
--- a/local-packages/Web.provenance.json
+++ /dev/null
@@ -1,18337 +0,0 @@
-{
-  "generator": {
-    "name": "@sysml/web",
-    "version": "0.8.0"
-  },
-  "dataset": {
-    "@webref/idl": "3.83.0",
-    "@webref/elements": "2.8.0"
-  },
-  "kernel": "0.8.0",
-  "library": "Web",
-  "elements": {
-    "Web::DOM::AbstractRange": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "url": "https://dom.spec.whatwg.org/#abstractrange",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "declared-non-instantiable"
-    },
-    "Web::DOM::AbstractRange::collapsed": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "member": "collapsed",
-      "url": "https://dom.spec.whatwg.org/#dom-abstractrange-collapsed",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::AbstractRange::endContainer": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "member": "endContainer",
-      "url": "https://dom.spec.whatwg.org/#dom-abstractrange-endcontainer",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::AbstractRange::endOffset": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "member": "endOffset",
-      "url": "https://dom.spec.whatwg.org/#dom-abstractrange-endoffset",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::AbstractRange::startContainer": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "member": "startContainer",
-      "url": "https://dom.spec.whatwg.org/#dom-abstractrange-startcontainer",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::AbstractRange::startOffset": {
-      "spec": "dom",
-      "interface": "AbstractRange",
-      "member": "startOffset",
-      "url": "https://dom.spec.whatwg.org/#dom-abstractrange-startoffset",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::Attr": {
-      "spec": "dom",
-      "interface": "Attr",
-      "url": "https://dom.spec.whatwg.org/#attr",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::Node"
-      ]
-    },
-    "Web::DOM::Attr::localName": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "localName",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-localname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Attr::name": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "name",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Attr::namespaceURI": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "namespaceURI",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-namespaceuri",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Attr::ownerElement": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "ownerElement",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-ownerelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Attr::prefix": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "prefix",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-prefix",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Attr::specified": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "specified",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-specified",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Attr::value": {
-      "spec": "dom",
-      "interface": "Attr",
-      "member": "value",
-      "url": "https://dom.spec.whatwg.org/#dom-attr-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::CDATASection": {
-      "spec": "dom",
-      "interface": "CDATASection",
-      "url": "https://dom.spec.whatwg.org/#cdatasection",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::Text"
-      ]
-    },
-    "Web::DOM::CharacterData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "url": "https://dom.spec.whatwg.org/#characterdata",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "declared-non-instantiable",
-      "generalizations": [
-        "Web::DOM::Node",
-        "Web::DOM::NonDocumentTypeChildNode",
-        "Web::DOM::ChildNode"
-      ]
-    },
-    "Web::DOM::CharacterData::appendData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "appendData",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-appenddata",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::CharacterData::data": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "data",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-data",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::CharacterData::deleteData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "deleteData",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-deletedata",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "offset",
-          "type": "Natural"
-        },
-        {
-          "name": "count",
-          "type": "Natural"
-        }
-      ]
-    },
-    "Web::DOM::CharacterData::insertData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "insertData",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-insertdata",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "offset",
-          "type": "Natural"
-        },
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::CharacterData::length": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "length",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::CharacterData::replaceData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "replaceData",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-replacedata",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "offset",
-          "type": "Natural"
-        },
-        {
-          "name": "count",
-          "type": "Natural"
-        },
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::CharacterData::substringData": {
-      "spec": "dom",
-      "interface": "CharacterData",
-      "member": "substringData",
-      "url": "https://dom.spec.whatwg.org/#dom-characterdata-substringdata",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "offset",
-          "type": "Natural"
-        },
-        {
-          "name": "count",
-          "type": "Natural"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::ChildNode": {
-      "spec": "dom",
-      "interface": "ChildNode",
-      "url": "https://dom.spec.whatwg.org/#childnode",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::ChildNode::after": {
-      "spec": "dom",
-      "interface": "ChildNode",
-      "member": "after",
-      "url": "https://dom.spec.whatwg.org/#dom-childnode-after",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::ChildNode::before": {
-      "spec": "dom",
-      "interface": "ChildNode",
-      "member": "before",
-      "url": "https://dom.spec.whatwg.org/#dom-childnode-before",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::ChildNode::remove": {
-      "spec": "dom",
-      "interface": "ChildNode",
-      "member": "remove",
-      "url": "https://dom.spec.whatwg.org/#dom-childnode-remove",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::ChildNode::replaceWith": {
-      "spec": "dom",
-      "interface": "ChildNode",
-      "member": "replaceWith",
-      "url": "https://dom.spec.whatwg.org/#dom-childnode-replacewith",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::Comment": {
-      "spec": "dom",
-      "interface": "Comment",
-      "url": "https://dom.spec.whatwg.org/#comment",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::CharacterData"
-      ]
-    },
-    "Web::DOM::DOMImplementation": {
-      "spec": "dom",
-      "interface": "DOMImplementation",
-      "url": "https://dom.spec.whatwg.org/#domimplementation",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::DOM::DOMImplementation::createDocument": {
-      "spec": "dom",
-      "interface": "DOMImplementation",
-      "member": "createDocument",
-      "url": "https://dom.spec.whatwg.org/#dom-domimplementation-createdocument",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        },
-        {
-          "name": "doctype",
-          "type": "Web::DOM::DocumentType",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::XMLDocument"
-    },
-    "Web::DOM::DOMImplementation::createDocumentType": {
-      "spec": "dom",
-      "interface": "DOMImplementation",
-      "member": "createDocumentType",
-      "url": "https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        },
-        {
-          "name": "publicId",
-          "type": "String"
-        },
-        {
-          "name": "systemId",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::DocumentType"
-    },
-    "Web::DOM::DOMImplementation::createHTMLDocument": {
-      "spec": "dom",
-      "interface": "DOMImplementation",
-      "member": "createHTMLDocument",
-      "url": "https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "title",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Document"
-    },
-    "Web::DOM::DOMImplementation::hasFeature": {
-      "spec": "dom",
-      "interface": "DOMImplementation",
-      "member": "hasFeature",
-      "url": "https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document": {
-      "spec": "dom",
-      "interface": "Document",
-      "url": "https://dom.spec.whatwg.org/#document",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::Node",
-        "Web::DOM::NonElementParentNode",
-        "Web::DOM::DocumentOrShadowRoot",
-        "Web::DOM::ParentNode",
-        "Web::DOM::XPathEvaluatorBase",
-        "Web::HTML::GlobalEventHandlers"
-      ],
-      "flags": [
-        "static:parseHTMLUnsafe",
-        "static:parseHTML"
-      ]
-    },
-    "Web::DOM::Document::URL": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "URL",
-      "url": "https://dom.spec.whatwg.org/#dom-document-url",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::DOM::Document::adoptNode": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "adoptNode",
-      "url": "https://dom.spec.whatwg.org/#dom-document-adoptnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Document::alinkColor": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "alinkColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-alinkcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::all": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "all",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-all",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLAllCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLAllCollection"
-      ]
-    },
-    "Web::DOM::Document::anchors": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "anchors",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-anchors",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::applets": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "applets",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-applets",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::bgColor": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::body": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "body",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-body",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLElement",
-      "idlType": "HTMLElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Document::captureEvents": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "captureEvents",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-captureevents",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Document::characterSet": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "characterSet",
-      "url": "https://dom.spec.whatwg.org/#dom-document-characterset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::charset": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "charset",
-      "url": "https://dom.spec.whatwg.org/#dom-document-charset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::clear": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "clear",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-clear",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Document::close": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "close",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-close",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Document::compatMode": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "compatMode",
-      "url": "https://dom.spec.whatwg.org/#dom-document-compatmode",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::contentType": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "contentType",
-      "url": "https://dom.spec.whatwg.org/#dom-document-contenttype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::cookie": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "cookie",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-cookie",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::DOM::Document::createAttribute": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Document::createAttributeNS": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createAttributeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createattributens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Document::createCDATASection": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createCDATASection",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createcdatasection",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::CDATASection"
-    },
-    "Web::DOM::Document::createComment": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createComment",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createcomment",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Comment"
-    },
-    "Web::DOM::Document::createDocumentFragment": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createDocumentFragment",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createdocumentfragment",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::DocumentFragment"
-    },
-    "Web::DOM::Document::createElement": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createElement",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createelement",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "localName",
-          "type": "String"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Document::createElementNS": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createElementNS",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createelementns",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Document::createEvent": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createEvent",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createevent",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "interface",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Event"
-    },
-    "Web::DOM::Document::createNodeIterator": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createNodeIterator",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createnodeiterator",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "root",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "whatToShow",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "filter",
-          "type": "Web::DOM::NodeFilter",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::NodeIterator"
-    },
-    "Web::DOM::Document::createProcessingInstruction": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createProcessingInstruction",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "target",
-          "type": "String"
-        },
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::ProcessingInstruction"
-    },
-    "Web::DOM::Document::createRange": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createRange",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createrange",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Range"
-    },
-    "Web::DOM::Document::createTextNode": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createTextNode",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createtextnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Text"
-    },
-    "Web::DOM::Document::createTreeWalker": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "createTreeWalker",
-      "url": "https://dom.spec.whatwg.org/#dom-document-createtreewalker",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "root",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "whatToShow",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "filter",
-          "type": "Web::DOM::NodeFilter",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::TreeWalker"
-    },
-    "Web::DOM::Document::currentScript": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "currentScript",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-currentscript",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLOrSVGScriptElement?",
-      "multiplicity": "[0..1]",
-      "derived": true,
-      "flags": [
-        "union:(HTMLScriptElement or SVGScriptElement)"
-      ]
-    },
-    "Web::DOM::Document::designMode": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "designMode",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-designmode",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::dir": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "dir",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-dir",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::doctype": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "doctype",
-      "url": "https://dom.spec.whatwg.org/#dom-document-doctype",
-      "kind": "reference",
-      "type": "Web::DOM::DocumentType",
-      "idlType": "DocumentType?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Document::documentElement": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "documentElement",
-      "url": "https://dom.spec.whatwg.org/#dom-document-documentelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Document::documentURI": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "documentURI",
-      "url": "https://dom.spec.whatwg.org/#dom-document-documenturi",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::DOM::Document::domain": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "domain",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-domain",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::DOM::Document::embeds": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "embeds",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-embeds",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::execCommand": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "execCommand",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-execcommand",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        },
-        {
-          "name": "showUI",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "value",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::fgColor": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "fgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-fgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::forms": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "forms",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-forms",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::getElementsByClassName": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "getElementsByClassName",
-      "url": "https://dom.spec.whatwg.org/#dom-document-getelementsbyclassname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "classNames",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Document::getElementsByName": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "getElementsByName",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-getelementsbyname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "elementName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Document::getElementsByTagName": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "getElementsByTagName",
-      "url": "https://dom.spec.whatwg.org/#dom-document-getelementsbytagname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Document::getElementsByTagNameNS": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "getElementsByTagNameNS",
-      "url": "https://dom.spec.whatwg.org/#dom-document-getelementsbytagnamens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Document::hasFocus": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "hasFocus",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-hasfocus",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::head": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "head",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-head",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLHeadElement",
-      "idlType": "HTMLHeadElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Document::hidden": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "hidden",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-hidden",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Document::images": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "images",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-images",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::implementation": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "implementation",
-      "url": "https://dom.spec.whatwg.org/#dom-document-implementation",
-      "kind": "reference",
-      "type": "Web::DOM::DOMImplementation",
-      "idlType": "DOMImplementation",
-      "constant": true
-    },
-    "Web::DOM::Document::importNode": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "importNode",
-      "url": "https://dom.spec.whatwg.org/#dom-document-importnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Document::inputEncoding": {
-      "spec": "dom",
-      "interface": "Document",
-      "member": "inputEncoding",
-      "url": "https://dom.spec.whatwg.org/#dom-document-inputencoding",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::lastModified": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "lastModified",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-lastmodified",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Document::linkColor": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "linkColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-linkcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::links": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "links",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-links",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::location": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "location",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-location",
-      "kind": "reference",
-      "type": "Web::HTML::Location",
-      "idlType": "Location?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::DOM::Document::plugins": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "plugins",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-plugins",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::queryCommandEnabled": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "queryCommandEnabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-querycommandenabled",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::queryCommandIndeterm": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "queryCommandIndeterm",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-querycommandindeterm",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::queryCommandState": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "queryCommandState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-querycommandstate",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::queryCommandSupported": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "queryCommandSupported",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-querycommandsupported",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Document::queryCommandValue": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "queryCommandValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-querycommandvalue",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "commandId",
-          "type": "String"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Document::readyState": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "readyState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-readystate",
-      "kind": "attribute",
-      "type": "Web::HTML::DocumentReadyState",
-      "idlType": "DocumentReadyState",
-      "constant": true
-    },
-    "Web::DOM::Document::referrer": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "referrer",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-referrer",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::DOM::Document::releaseEvents": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "releaseEvents",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-releaseevents",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Document::scripts": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "scripts",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-scripts",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::Document::title": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "title",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-title",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::visibilityState": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "visibilityState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-visibilitystate",
-      "kind": "attribute",
-      "type": "Web::HTML::DocumentVisibilityState",
-      "idlType": "DocumentVisibilityState",
-      "constant": true
-    },
-    "Web::DOM::Document::vlinkColor": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "vlinkColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-vlinkcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::DOM::Document::write": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "write",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-write",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "text",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::Document::writeln": {
-      "spec": "html",
-      "interface": "Document",
-      "member": "writeln",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-document-writeln",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "text",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::DocumentFragment": {
-      "spec": "dom",
-      "interface": "DocumentFragment",
-      "url": "https://dom.spec.whatwg.org/#documentfragment",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::Node",
-        "Web::DOM::NonElementParentNode",
-        "Web::DOM::ParentNode"
-      ]
-    },
-    "Web::DOM::DocumentOrShadowRoot": {
-      "spec": "dom",
-      "interface": "DocumentOrShadowRoot",
-      "url": "https://dom.spec.whatwg.org/#documentorshadowroot",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::DocumentOrShadowRoot::activeElement": {
-      "spec": "html",
-      "interface": "DocumentOrShadowRoot",
-      "member": "activeElement",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentorshadowroot-activeelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::DocumentOrShadowRoot::customElementRegistry": {
-      "spec": "dom",
-      "interface": "DocumentOrShadowRoot",
-      "member": "customElementRegistry",
-      "url": "https://dom.spec.whatwg.org/#dom-documentorshadowroot-customelementregistry",
-      "kind": "reference",
-      "type": "Web::HTML::CustomElementRegistry",
-      "idlType": "CustomElementRegistry?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::DocumentType": {
-      "spec": "dom",
-      "interface": "DocumentType",
-      "url": "https://dom.spec.whatwg.org/#documenttype",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::Node",
-        "Web::DOM::ChildNode"
-      ]
-    },
-    "Web::DOM::DocumentType::name": {
-      "spec": "dom",
-      "interface": "DocumentType",
-      "member": "name",
-      "url": "https://dom.spec.whatwg.org/#dom-documenttype-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::DocumentType::publicId": {
-      "spec": "dom",
-      "interface": "DocumentType",
-      "member": "publicId",
-      "url": "https://dom.spec.whatwg.org/#dom-documenttype-publicid",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::DocumentType::systemId": {
-      "spec": "dom",
-      "interface": "DocumentType",
-      "member": "systemId",
-      "url": "https://dom.spec.whatwg.org/#dom-documenttype-systemid",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Element": {
-      "spec": "dom",
-      "interface": "Element",
-      "url": "https://dom.spec.whatwg.org/#element",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::Node",
-        "Web::DOM::ParentNode",
-        "Web::DOM::NonDocumentTypeChildNode",
-        "Web::DOM::ChildNode",
-        "Web::DOM::Slottable"
-      ]
-    },
-    "Web::DOM::Element::attachShadow": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "attachShadow",
-      "url": "https://dom.spec.whatwg.org/#dom-element-attachshadow",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "init",
-          "type": "Web::DOM::ShadowRootInit"
-        }
-      ],
-      "result": "Web::DOM::ShadowRoot"
-    },
-    "Web::DOM::Element::attributes": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "attributes",
-      "url": "https://dom.spec.whatwg.org/#dom-element-attributes",
-      "kind": "reference",
-      "type": "Web::DOM::Attr",
-      "idlType": "NamedNodeMap",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NamedNodeMap"
-      ]
-    },
-    "Web::DOM::Element::classList": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "classList",
-      "url": "https://dom.spec.whatwg.org/#dom-element-classlist",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::DOM::Element::className": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "className",
-      "url": "https://dom.spec.whatwg.org/#dom-element-classname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "class"
-      }
-    },
-    "Web::DOM::Element::closest": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "closest",
-      "url": "https://dom.spec.whatwg.org/#dom-element-closest",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "selectors",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Element::customElementRegistry": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "customElementRegistry",
-      "url": "https://dom.spec.whatwg.org/#dom-element-customelementregistry",
-      "kind": "reference",
-      "type": "Web::HTML::CustomElementRegistry",
-      "idlType": "CustomElementRegistry?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Element::getAttribute": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Element::getAttributeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getAttributeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getattributens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Element::getAttributeNames": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getAttributeNames",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getattributenames",
-      "kind": "operation",
-      "params": [],
-      "result": "String"
-    },
-    "Web::DOM::Element::getAttributeNode": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getAttributeNode",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getattributenode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Element::getAttributeNodeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getAttributeNodeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getattributenodens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Element::getElementsByClassName": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getElementsByClassName",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getelementsbyclassname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "classNames",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Element::getElementsByTagName": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getElementsByTagName",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getelementsbytagname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Element::getElementsByTagNameNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "getElementsByTagNameNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-getelementsbytagnamens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Element::getHTML": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "getHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-gethtml",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::GetHTMLOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Element::hasAttribute": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "hasAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-element-hasattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Element::hasAttributeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "hasAttributeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-hasattributens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Element::hasAttributes": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "hasAttributes",
-      "url": "https://dom.spec.whatwg.org/#dom-element-hasattributes",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::DOM::Element::id": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "id",
-      "url": "https://dom.spec.whatwg.org/#dom-element-id",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "id"
-      }
-    },
-    "Web::DOM::Element::innerHTML": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "innerHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-innerhtml",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(TrustedHTML or DOMString)",
-      "flags": [
-        "union-unmapped:(TrustedHTML or DOMString)"
-      ]
-    },
-    "Web::DOM::Element::insertAdjacentElement": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "insertAdjacentElement",
-      "url": "https://dom.spec.whatwg.org/#dom-element-insertadjacentelement",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "where",
-          "type": "String"
-        },
-        {
-          "name": "element",
-          "type": "Web::DOM::Element"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::Element::insertAdjacentHTML": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "insertAdjacentHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-insertadjacenthtml",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "position",
-          "type": "String"
-        },
-        {
-          "name": "string",
-          "type": "Base::Anything"
-        }
-      ]
-    },
-    "Web::DOM::Element::insertAdjacentText": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "insertAdjacentText",
-      "url": "https://dom.spec.whatwg.org/#dom-element-insertadjacenttext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "where",
-          "type": "String"
-        },
-        {
-          "name": "data",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::Element::localName": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "localName",
-      "url": "https://dom.spec.whatwg.org/#dom-element-localname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Element::matches": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "matches",
-      "url": "https://dom.spec.whatwg.org/#dom-element-matches",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "selectors",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Element::namespaceURI": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "namespaceURI",
-      "url": "https://dom.spec.whatwg.org/#dom-element-namespaceuri",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Element::outerHTML": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "outerHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-outerhtml",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(TrustedHTML or DOMString)",
-      "flags": [
-        "union-unmapped:(TrustedHTML or DOMString)"
-      ]
-    },
-    "Web::DOM::Element::part": {
-      "spec": "css-shadow",
-      "interface": "Element",
-      "member": "part",
-      "url": "https://drafts.csswg.org/css-shadow-1/#dom-element-part",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::DOM::Element::prefix": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "prefix",
-      "url": "https://dom.spec.whatwg.org/#dom-element-prefix",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Element::removeAttribute": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "removeAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-element-removeattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::Element::removeAttributeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "removeAttributeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-removeattributens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "localName",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::Element::removeAttributeNode": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "removeAttributeNode",
-      "url": "https://dom.spec.whatwg.org/#dom-element-removeattributenode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "attr",
-          "type": "Web::DOM::Attr"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Element::setAttribute": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "setAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-element-setattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        },
-        {
-          "name": "value",
-          "type": "Base::Anything"
-        }
-      ]
-    },
-    "Web::DOM::Element::setAttributeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "setAttributeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-setattributens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        },
-        {
-          "name": "value",
-          "type": "Base::Anything"
-        }
-      ]
-    },
-    "Web::DOM::Element::setAttributeNode": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "setAttributeNode",
-      "url": "https://dom.spec.whatwg.org/#dom-element-setattributenode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "attr",
-          "type": "Web::DOM::Attr"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Element::setAttributeNodeNS": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "setAttributeNodeNS",
-      "url": "https://dom.spec.whatwg.org/#dom-element-setattributenodens",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "attr",
-          "type": "Web::DOM::Attr"
-        }
-      ],
-      "result": "Web::DOM::Attr"
-    },
-    "Web::DOM::Element::setHTML": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "setHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-sethtml",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "html",
-          "type": "String"
-        },
-        {
-          "name": "options",
-          "type": "Web::HTML::SetHTMLOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::Element::setHTMLUnsafe": {
-      "spec": "html",
-      "interface": "Element",
-      "member": "setHTMLUnsafe",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-element-sethtmlunsafe",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "html",
-          "type": "Base::Anything"
-        },
-        {
-          "name": "options",
-          "type": "Web::HTML::SetHTMLUnsafeOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::Element::shadowRoot": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "shadowRoot",
-      "url": "https://dom.spec.whatwg.org/#dom-element-shadowroot",
-      "kind": "reference",
-      "type": "Web::DOM::ShadowRoot",
-      "idlType": "ShadowRoot?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Element::slot": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "slot",
-      "url": "https://dom.spec.whatwg.org/#dom-element-slot",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "slot"
-      }
-    },
-    "Web::DOM::Element::tagName": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "tagName",
-      "url": "https://dom.spec.whatwg.org/#dom-element-tagname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Element::toggleAttribute": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "toggleAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-element-toggleattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "qualifiedName",
-          "type": "String"
-        },
-        {
-          "name": "force",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Element::webkitMatchesSelector": {
-      "spec": "dom",
-      "interface": "Element",
-      "member": "webkitMatchesSelector",
-      "url": "https://dom.spec.whatwg.org/#dom-element-webkitmatchesselector",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "selectors",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Event": {
-      "spec": "dom",
-      "interface": "Event",
-      "url": "https://dom.spec.whatwg.org/#event",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor"
-    },
-    "Web::DOM::Event::AT_TARGET": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "AT_TARGET",
-      "url": "https://dom.spec.whatwg.org/#dom-event-at_target",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::DOM::Event::BUBBLING_PHASE": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "BUBBLING_PHASE",
-      "url": "https://dom.spec.whatwg.org/#dom-event-bubbling_phase",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::DOM::Event::CAPTURING_PHASE": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "CAPTURING_PHASE",
-      "url": "https://dom.spec.whatwg.org/#dom-event-capturing_phase",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::DOM::Event::NONE": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "NONE",
-      "url": "https://dom.spec.whatwg.org/#dom-event-none",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::DOM::Event::bubbles": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "bubbles",
-      "url": "https://dom.spec.whatwg.org/#dom-event-bubbles",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Event::cancelBubble": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "cancelBubble",
-      "url": "https://dom.spec.whatwg.org/#dom-event-cancelbubble",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::DOM::Event::cancelable": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "cancelable",
-      "url": "https://dom.spec.whatwg.org/#dom-event-cancelable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Event::composed": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "composed",
-      "url": "https://dom.spec.whatwg.org/#dom-event-composed",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Event::composedPath": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "composedPath",
-      "url": "https://dom.spec.whatwg.org/#dom-event-composedpath",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::EventTarget"
-    },
-    "Web::DOM::Event::currentTarget": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "currentTarget",
-      "url": "https://dom.spec.whatwg.org/#dom-event-currenttarget",
-      "kind": "reference",
-      "type": "Web::DOM::EventTarget",
-      "idlType": "EventTarget?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Event::defaultPrevented": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "defaultPrevented",
-      "url": "https://dom.spec.whatwg.org/#dom-event-defaultprevented",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Event::eventPhase": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "eventPhase",
-      "url": "https://dom.spec.whatwg.org/#dom-event-eventphase",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::DOM::Event::initEvent": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "initEvent",
-      "url": "https://dom.spec.whatwg.org/#dom-event-initevent",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "type",
-          "type": "String"
-        },
-        {
-          "name": "bubbles",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "cancelable",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::Event::isTrusted": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "isTrusted",
-      "url": "https://dom.spec.whatwg.org/#dom-event-istrusted",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Event::preventDefault": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "preventDefault",
-      "url": "https://dom.spec.whatwg.org/#dom-event-preventdefault",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Event::returnValue": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "returnValue",
-      "url": "https://dom.spec.whatwg.org/#dom-event-returnvalue",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::DOM::Event::srcElement": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "srcElement",
-      "url": "https://dom.spec.whatwg.org/#dom-event-srcelement",
-      "kind": "reference",
-      "type": "Web::DOM::EventTarget",
-      "idlType": "EventTarget?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Event::stopImmediatePropagation": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "stopImmediatePropagation",
-      "url": "https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Event::stopPropagation": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "stopPropagation",
-      "url": "https://dom.spec.whatwg.org/#dom-event-stoppropagation",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Event::target": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "target",
-      "url": "https://dom.spec.whatwg.org/#dom-event-target",
-      "kind": "reference",
-      "type": "Web::DOM::EventTarget",
-      "idlType": "EventTarget?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::DOM::Event::timeStamp": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "timeStamp",
-      "url": "https://dom.spec.whatwg.org/#dom-event-timestamp",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "DOMHighResTimeStamp",
-      "constant": true
-    },
-    "Web::DOM::Event::type": {
-      "spec": "dom",
-      "interface": "Event",
-      "member": "type",
-      "url": "https://dom.spec.whatwg.org/#dom-event-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::EventListener": {
-      "spec": "dom",
-      "interface": "EventListener",
-      "url": "https://dom.spec.whatwg.org/#eventlistener",
-      "idlKind": "callback interface",
-      "kind": "action",
-      "params": [
-        {
-          "name": "event",
-          "type": "Web::DOM::Event"
-        }
-      ]
-    },
-    "Web::DOM::EventTarget": {
-      "spec": "dom",
-      "interface": "EventTarget",
-      "url": "https://dom.spec.whatwg.org/#eventtarget",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor"
-    },
-    "Web::DOM::EventTarget::addEventListener": {
-      "spec": "dom",
-      "interface": "EventTarget",
-      "member": "addEventListener",
-      "url": "https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "type",
-          "type": "String"
-        },
-        {
-          "name": "callback",
-          "type": "Web::DOM::EventListener",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::EventTarget::dispatchEvent": {
-      "spec": "dom",
-      "interface": "EventTarget",
-      "member": "dispatchEvent",
-      "url": "https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "event",
-          "type": "Web::DOM::Event"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::EventTarget::removeEventListener": {
-      "spec": "dom",
-      "interface": "EventTarget",
-      "member": "removeEventListener",
-      "url": "https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "type",
-          "type": "String"
-        },
-        {
-          "name": "callback",
-          "type": "Web::DOM::EventListener",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::GetRootNodeOptions": {
-      "spec": "dom",
-      "interface": "GetRootNodeOptions",
-      "url": "https://dom.spec.whatwg.org/#getrootnodeoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::DOM::GetRootNodeOptions::composed": {
-      "spec": "dom",
-      "interface": "GetRootNodeOptions",
-      "member": "composed",
-      "url": "https://dom.spec.whatwg.org/#dom-getrootnodeoptions-composed",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::DOM::Node": {
-      "spec": "dom",
-      "interface": "Node",
-      "url": "https://dom.spec.whatwg.org/#node",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "declared-non-instantiable",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::DOM::Node::ATTRIBUTE_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "ATTRIBUTE_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-attribute_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::DOM::Node::CDATA_SECTION_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "CDATA_SECTION_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-cdata_section_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "4"
-    },
-    "Web::DOM::Node::COMMENT_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "COMMENT_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-comment_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "8"
-    },
-    "Web::DOM::Node::DOCUMENT_FRAGMENT_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_FRAGMENT_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_fragment_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "11"
-    },
-    "Web::DOM::Node::DOCUMENT_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "9"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_CONTAINED_BY": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_CONTAINED_BY",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_contained_by",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "16"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_CONTAINS": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_CONTAINS",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_contains",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "8"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_DISCONNECTED": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_DISCONNECTED",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_disconnected",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_FOLLOWING": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_FOLLOWING",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_following",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "4"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_implementation_specific",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "32"
-    },
-    "Web::DOM::Node::DOCUMENT_POSITION_PRECEDING": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_POSITION_PRECEDING",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_position_preceding",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::DOM::Node::DOCUMENT_TYPE_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "DOCUMENT_TYPE_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-document_type_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "10"
-    },
-    "Web::DOM::Node::ELEMENT_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "ELEMENT_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-element_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::DOM::Node::ENTITY_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "ENTITY_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-entity_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "6"
-    },
-    "Web::DOM::Node::ENTITY_REFERENCE_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "ENTITY_REFERENCE_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-entity_reference_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "5"
-    },
-    "Web::DOM::Node::NOTATION_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "NOTATION_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-notation_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "12"
-    },
-    "Web::DOM::Node::PROCESSING_INSTRUCTION_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "PROCESSING_INSTRUCTION_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-processing_instruction_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "7"
-    },
-    "Web::DOM::Node::TEXT_NODE": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "TEXT_NODE",
-      "url": "https://dom.spec.whatwg.org/#dom-node-text_node",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::DOM::Node::appendChild": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "appendChild",
-      "url": "https://dom.spec.whatwg.org/#dom-node-appendchild",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::baseURI": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "baseURI",
-      "url": "https://dom.spec.whatwg.org/#dom-node-baseuri",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::DOM::Node::childNodes": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "childNodes",
-      "url": "https://dom.spec.whatwg.org/#dom-node-childnodes",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::DOM::Node::cloneNode": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "cloneNode",
-      "url": "https://dom.spec.whatwg.org/#dom-node-clonenode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "subtree",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::compareDocumentPosition": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "compareDocumentPosition",
-      "url": "https://dom.spec.whatwg.org/#dom-node-comparedocumentposition",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "other",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Natural"
-    },
-    "Web::DOM::Node::contains": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "contains",
-      "url": "https://dom.spec.whatwg.org/#dom-node-contains",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "other",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Node::firstChild": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "firstChild",
-      "url": "https://dom.spec.whatwg.org/#dom-node-firstchild",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::getRootNode": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "getRootNode",
-      "url": "https://dom.spec.whatwg.org/#dom-node-getrootnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::DOM::GetRootNodeOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::hasChildNodes": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "hasChildNodes",
-      "url": "https://dom.spec.whatwg.org/#dom-node-haschildnodes",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::DOM::Node::insertBefore": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "insertBefore",
-      "url": "https://dom.spec.whatwg.org/#dom-node-insertbefore",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "child",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::isConnected": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "isConnected",
-      "url": "https://dom.spec.whatwg.org/#dom-node-isconnected",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::Node::isDefaultNamespace": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "isDefaultNamespace",
-      "url": "https://dom.spec.whatwg.org/#dom-node-isdefaultnamespace",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Node::isEqualNode": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "isEqualNode",
-      "url": "https://dom.spec.whatwg.org/#dom-node-isequalnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "otherNode",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Node::isSameNode": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "isSameNode",
-      "url": "https://dom.spec.whatwg.org/#dom-node-issamenode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "otherNode",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Node::lastChild": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "lastChild",
-      "url": "https://dom.spec.whatwg.org/#dom-node-lastchild",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::lookupNamespaceURI": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "lookupNamespaceURI",
-      "url": "https://dom.spec.whatwg.org/#dom-node-lookupnamespaceuri",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "prefix",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Node::lookupPrefix": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "lookupPrefix",
-      "url": "https://dom.spec.whatwg.org/#dom-node-lookupprefix",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "namespace",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::Node::nextSibling": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "nextSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-node-nextsibling",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::nodeName": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "nodeName",
-      "url": "https://dom.spec.whatwg.org/#dom-node-nodename",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::Node::nodeType": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "nodeType",
-      "url": "https://dom.spec.whatwg.org/#dom-node-nodetype",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::DOM::Node::nodeValue": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "nodeValue",
-      "url": "https://dom.spec.whatwg.org/#dom-node-nodevalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::DOM::Node::normalize": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "normalize",
-      "url": "https://dom.spec.whatwg.org/#dom-node-normalize",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Node::ownerDocument": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "ownerDocument",
-      "url": "https://dom.spec.whatwg.org/#dom-node-ownerdocument",
-      "kind": "reference",
-      "type": "Web::DOM::Document",
-      "idlType": "Document?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::parentElement": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "parentElement",
-      "url": "https://dom.spec.whatwg.org/#dom-node-parentelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::parentNode": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "parentNode",
-      "url": "https://dom.spec.whatwg.org/#dom-node-parentnode",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::previousSibling": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "previousSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-node-previoussibling",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Node::removeChild": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "removeChild",
-      "url": "https://dom.spec.whatwg.org/#dom-node-removechild",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "child",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::replaceChild": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "replaceChild",
-      "url": "https://dom.spec.whatwg.org/#dom-node-replacechild",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "child",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::Node::textContent": {
-      "spec": "dom",
-      "interface": "Node",
-      "member": "textContent",
-      "url": "https://dom.spec.whatwg.org/#dom-node-textcontent",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::DOM::NodeFilter": {
-      "spec": "dom",
-      "interface": "NodeFilter",
-      "url": "https://dom.spec.whatwg.org/#nodefilter",
-      "idlKind": "callback interface",
-      "kind": "action",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Natural"
-    },
-    "Web::DOM::NodeIterator": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "url": "https://dom.spec.whatwg.org/#nodeiterator",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::DOM::NodeIterator::detach": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "detach",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-detach",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::NodeIterator::nextNode": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "nextNode",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-nextnode",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::NodeIterator::pointerBeforeReferenceNode": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "pointerBeforeReferenceNode",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-pointerbeforereferencenode",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::NodeIterator::previousNode": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "previousNode",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-previousnode",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::NodeIterator::referenceNode": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "referenceNode",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-referencenode",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::NodeIterator::root": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "root",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-root",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::NodeIterator::whatToShow": {
-      "spec": "dom",
-      "interface": "NodeIterator",
-      "member": "whatToShow",
-      "url": "https://dom.spec.whatwg.org/#dom-nodeiterator-whattoshow",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::NonDocumentTypeChildNode": {
-      "spec": "dom",
-      "interface": "NonDocumentTypeChildNode",
-      "url": "https://dom.spec.whatwg.org/#nondocumenttypechildnode",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::NonDocumentTypeChildNode::nextElementSibling": {
-      "spec": "dom",
-      "interface": "NonDocumentTypeChildNode",
-      "member": "nextElementSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-nextelementsibling",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::NonDocumentTypeChildNode::previousElementSibling": {
-      "spec": "dom",
-      "interface": "NonDocumentTypeChildNode",
-      "member": "previousElementSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-nondocumenttypechildnode-previouselementsibling",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::NonElementParentNode": {
-      "spec": "dom",
-      "interface": "NonElementParentNode",
-      "url": "https://dom.spec.whatwg.org/#nonelementparentnode",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::NonElementParentNode::getElementById": {
-      "spec": "dom",
-      "interface": "NonElementParentNode",
-      "member": "getElementById",
-      "url": "https://dom.spec.whatwg.org/#dom-nonelementparentnode-getelementbyid",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "elementId",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::ParentNode": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "url": "https://dom.spec.whatwg.org/#parentnode",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::ParentNode::append": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "append",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-append",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::ParentNode::childElementCount": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "childElementCount",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-childelementcount",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::ParentNode::children": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "children",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-children",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::DOM::ParentNode::firstElementChild": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "firstElementChild",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-firstelementchild",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::ParentNode::lastElementChild": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "lastElementChild",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-lastelementchild",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::ParentNode::moveBefore": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "moveBefore",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-movebefore",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "child",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..1]"
-        }
-      ]
-    },
-    "Web::DOM::ParentNode::prepend": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "prepend",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-prepend",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::ParentNode::querySelector": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "querySelector",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-queryselector",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "selectors",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::DOM::ParentNode::querySelectorAll": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "querySelectorAll",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "selectors",
-          "type": "String"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::ParentNode::replaceChildren": {
-      "spec": "dom",
-      "interface": "ParentNode",
-      "member": "replaceChildren",
-      "url": "https://dom.spec.whatwg.org/#dom-parentnode-replacechildren",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Base::Anything",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::DOM::ProcessingInstruction": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "url": "https://dom.spec.whatwg.org/#processinginstruction",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::CharacterData"
-      ]
-    },
-    "Web::DOM::ProcessingInstruction::getAttribute": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "getAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-getattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::ProcessingInstruction::getAttributeNames": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "getAttributeNames",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-getattributenames",
-      "kind": "operation",
-      "params": [],
-      "result": "String"
-    },
-    "Web::DOM::ProcessingInstruction::hasAttribute": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "hasAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-hasattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::ProcessingInstruction::hasAttributes": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "hasAttributes",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-hasattributes",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::DOM::ProcessingInstruction::removeAttribute": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "removeAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-removeattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::ProcessingInstruction::setAttribute": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "setAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-setattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        },
-        {
-          "name": "value",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::DOM::ProcessingInstruction::target": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "target",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-target",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::ProcessingInstruction::toggleAttribute": {
-      "spec": "dom",
-      "interface": "ProcessingInstruction",
-      "member": "toggleAttribute",
-      "url": "https://dom.spec.whatwg.org/#dom-processinginstruction-toggleattribute",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        },
-        {
-          "name": "force",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Range": {
-      "spec": "dom",
-      "interface": "Range",
-      "url": "https://dom.spec.whatwg.org/#range",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::AbstractRange"
-      ]
-    },
-    "Web::DOM::Range::END_TO_END": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "END_TO_END",
-      "url": "https://dom.spec.whatwg.org/#dom-range-end_to_end",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::DOM::Range::END_TO_START": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "END_TO_START",
-      "url": "https://dom.spec.whatwg.org/#dom-range-end_to_start",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::DOM::Range::START_TO_END": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "START_TO_END",
-      "url": "https://dom.spec.whatwg.org/#dom-range-start_to_end",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::DOM::Range::START_TO_START": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "START_TO_START",
-      "url": "https://dom.spec.whatwg.org/#dom-range-start_to_start",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::DOM::Range::cloneContents": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "cloneContents",
-      "url": "https://dom.spec.whatwg.org/#dom-range-clonecontents",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::DocumentFragment"
-    },
-    "Web::DOM::Range::cloneRange": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "cloneRange",
-      "url": "https://dom.spec.whatwg.org/#dom-range-clonerange",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Range"
-    },
-    "Web::DOM::Range::collapse": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "collapse",
-      "url": "https://dom.spec.whatwg.org/#dom-range-collapse",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "toStart",
-          "type": "Boolean",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::Range::commonAncestorContainer": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "commonAncestorContainer",
-      "url": "https://dom.spec.whatwg.org/#dom-range-commonancestorcontainer",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::Range::compareBoundaryPoints": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "compareBoundaryPoints",
-      "url": "https://dom.spec.whatwg.org/#dom-range-compareboundarypoints",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "how",
-          "type": "Natural"
-        },
-        {
-          "name": "sourceRange",
-          "type": "Web::DOM::Range"
-        }
-      ],
-      "result": "Integer"
-    },
-    "Web::DOM::Range::comparePoint": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "comparePoint",
-      "url": "https://dom.spec.whatwg.org/#dom-range-comparepoint",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "offset",
-          "type": "Natural"
-        }
-      ],
-      "result": "Integer"
-    },
-    "Web::DOM::Range::createContextualFragment": {
-      "spec": "html",
-      "interface": "Range",
-      "member": "createContextualFragment",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-range-createcontextualfragment",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "string",
-          "type": "Base::Anything"
-        }
-      ],
-      "result": "Web::DOM::DocumentFragment"
-    },
-    "Web::DOM::Range::deleteContents": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "deleteContents",
-      "url": "https://dom.spec.whatwg.org/#dom-range-deletecontents",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Range::detach": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "detach",
-      "url": "https://dom.spec.whatwg.org/#dom-range-detach",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::DOM::Range::extractContents": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "extractContents",
-      "url": "https://dom.spec.whatwg.org/#dom-range-extractcontents",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::DocumentFragment"
-    },
-    "Web::DOM::Range::insertNode": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "insertNode",
-      "url": "https://dom.spec.whatwg.org/#dom-range-insertnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::intersectsNode": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "intersectsNode",
-      "url": "https://dom.spec.whatwg.org/#dom-range-intersectsnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Range::isPointInRange": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "isPointInRange",
-      "url": "https://dom.spec.whatwg.org/#dom-range-ispointinrange",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "offset",
-          "type": "Natural"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::DOM::Range::selectNode": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "selectNode",
-      "url": "https://dom.spec.whatwg.org/#dom-range-selectnode",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::selectNodeContents": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "selectNodeContents",
-      "url": "https://dom.spec.whatwg.org/#dom-range-selectnodecontents",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::setEnd": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setEnd",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setend",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "offset",
-          "type": "Natural"
-        }
-      ]
-    },
-    "Web::DOM::Range::setEndAfter": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setEndAfter",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setendafter",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::setEndBefore": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setEndBefore",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setendbefore",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::setStart": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setStart",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setstart",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "offset",
-          "type": "Natural"
-        }
-      ]
-    },
-    "Web::DOM::Range::setStartAfter": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setStartAfter",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setstartafter",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::setStartBefore": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "setStartBefore",
-      "url": "https://dom.spec.whatwg.org/#dom-range-setstartbefore",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "node",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::Range::surroundContents": {
-      "spec": "dom",
-      "interface": "Range",
-      "member": "surroundContents",
-      "url": "https://dom.spec.whatwg.org/#dom-range-surroundcontents",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "newParent",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::DOM::ShadowRoot": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "url": "https://dom.spec.whatwg.org/#shadowroot",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::DocumentFragment",
-        "Web::DOM::DocumentOrShadowRoot"
-      ]
-    },
-    "Web::DOM::ShadowRoot::clonable": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "clonable",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-clonable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::ShadowRoot::delegatesFocus": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "delegatesFocus",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-delegatesfocus",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::ShadowRoot::getHTML": {
-      "spec": "html",
-      "interface": "ShadowRoot",
-      "member": "getHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-shadowroot-gethtml",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::GetHTMLOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::ShadowRoot::host": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "host",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-host",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element",
-      "derived": true
-    },
-    "Web::DOM::ShadowRoot::innerHTML": {
-      "spec": "html",
-      "interface": "ShadowRoot",
-      "member": "innerHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-shadowroot-innerhtml",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(TrustedHTML or DOMString)",
-      "flags": [
-        "union-unmapped:(TrustedHTML or DOMString)"
-      ]
-    },
-    "Web::DOM::ShadowRoot::mode": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "mode",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-mode",
-      "kind": "attribute",
-      "type": "Web::DOM::ShadowRootMode",
-      "idlType": "ShadowRootMode",
-      "constant": true
-    },
-    "Web::DOM::ShadowRoot::serializable": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "serializable",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-serializable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::ShadowRoot::setHTML": {
-      "spec": "html",
-      "interface": "ShadowRoot",
-      "member": "setHTML",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-shadowroot-sethtml",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "html",
-          "type": "String"
-        },
-        {
-          "name": "options",
-          "type": "Web::HTML::SetHTMLOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::ShadowRoot::setHTMLUnsafe": {
-      "spec": "html",
-      "interface": "ShadowRoot",
-      "member": "setHTMLUnsafe",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-shadowroot-sethtmlunsafe",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "html",
-          "type": "Base::Anything"
-        },
-        {
-          "name": "options",
-          "type": "Web::HTML::SetHTMLUnsafeOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::DOM::ShadowRoot::slotAssignment": {
-      "spec": "dom",
-      "interface": "ShadowRoot",
-      "member": "slotAssignment",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowroot-slotassignment",
-      "kind": "attribute",
-      "type": "Web::DOM::SlotAssignmentMode",
-      "idlType": "SlotAssignmentMode",
-      "constant": true
-    },
-    "Web::DOM::ShadowRootInit": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "url": "https://dom.spec.whatwg.org/#shadowrootinit",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::DOM::ShadowRootInit::clonable": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "clonable",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-clonable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::DOM::ShadowRootInit::customElementRegistry": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "customElementRegistry",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-customelementregistry",
-      "kind": "reference",
-      "type": "Web::HTML::CustomElementRegistry",
-      "idlType": "CustomElementRegistry?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::DOM::ShadowRootInit::delegatesFocus": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "delegatesFocus",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-delegatesfocus",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::DOM::ShadowRootInit::mode": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "mode",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-mode",
-      "kind": "attribute",
-      "type": "Web::DOM::ShadowRootMode",
-      "idlType": "ShadowRootMode"
-    },
-    "Web::DOM::ShadowRootInit::serializable": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "serializable",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-serializable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::DOM::ShadowRootInit::slotAssignment": {
-      "spec": "dom",
-      "interface": "ShadowRootInit",
-      "member": "slotAssignment",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootinit-slotassignment",
-      "kind": "attribute",
-      "type": "Web::DOM::SlotAssignmentMode",
-      "idlType": "SlotAssignmentMode",
-      "multiplicity": "[0..1]",
-      "default": "named"
-    },
-    "Web::DOM::ShadowRootMode": {
-      "spec": "dom",
-      "interface": "ShadowRootMode",
-      "url": "https://dom.spec.whatwg.org/#shadowrootmode",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::DOM::ShadowRootMode::closed": {
-      "spec": "dom",
-      "interface": "ShadowRootMode",
-      "member": "closed",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootmode-closed"
-    },
-    "Web::DOM::ShadowRootMode::open": {
-      "spec": "dom",
-      "interface": "ShadowRootMode",
-      "member": "open",
-      "url": "https://dom.spec.whatwg.org/#dom-shadowrootmode-open"
-    },
-    "Web::DOM::SlotAssignmentMode": {
-      "spec": "dom",
-      "interface": "SlotAssignmentMode",
-      "url": "https://dom.spec.whatwg.org/#slotassignmentmode",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::DOM::SlotAssignmentMode::manual": {
-      "spec": "dom",
-      "interface": "SlotAssignmentMode",
-      "member": "manual",
-      "url": "https://dom.spec.whatwg.org/#dom-slotassignmentmode-manual"
-    },
-    "Web::DOM::SlotAssignmentMode::named": {
-      "spec": "dom",
-      "interface": "SlotAssignmentMode",
-      "member": "named",
-      "url": "https://dom.spec.whatwg.org/#dom-slotassignmentmode-named"
-    },
-    "Web::DOM::Slottable": {
-      "spec": "dom",
-      "interface": "Slottable",
-      "url": "https://dom.spec.whatwg.org/#slottable",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::Slottable::assignedSlot": {
-      "spec": "dom",
-      "interface": "Slottable",
-      "member": "assignedSlot",
-      "url": "https://dom.spec.whatwg.org/#dom-slottable-assignedslot",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLSlotElement",
-      "idlType": "HTMLSlotElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::Text": {
-      "spec": "dom",
-      "interface": "Text",
-      "url": "https://dom.spec.whatwg.org/#text",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::CharacterData",
-        "Web::DOM::Slottable"
-      ]
-    },
-    "Web::DOM::Text::splitText": {
-      "spec": "dom",
-      "interface": "Text",
-      "member": "splitText",
-      "url": "https://dom.spec.whatwg.org/#dom-text-splittext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "offset",
-          "type": "Natural"
-        }
-      ],
-      "result": "Web::DOM::Text"
-    },
-    "Web::DOM::Text::wholeText": {
-      "spec": "dom",
-      "interface": "Text",
-      "member": "wholeText",
-      "url": "https://dom.spec.whatwg.org/#dom-text-wholetext",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::DOM::TreeWalker": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "url": "https://dom.spec.whatwg.org/#treewalker",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::DOM::TreeWalker::currentNode": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "currentNode",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-currentnode",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::TreeWalker::firstChild": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "firstChild",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-firstchild",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::lastChild": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "lastChild",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-lastchild",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::nextNode": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "nextNode",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-nextnode",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::nextSibling": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "nextSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-nextsibling",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::parentNode": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "parentNode",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-parentnode",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::previousNode": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "previousNode",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-previousnode",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::previousSibling": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "previousSibling",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-previoussibling",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::TreeWalker::root": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "root",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-root",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node",
-      "derived": true
-    },
-    "Web::DOM::TreeWalker::whatToShow": {
-      "spec": "dom",
-      "interface": "TreeWalker",
-      "member": "whatToShow",
-      "url": "https://dom.spec.whatwg.org/#dom-treewalker-whattoshow",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::XMLDocument": {
-      "spec": "dom",
-      "interface": "XMLDocument",
-      "url": "https://dom.spec.whatwg.org/#xmldocument",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::Document"
-      ]
-    },
-    "Web::DOM::XPathEvaluatorBase": {
-      "spec": "dom",
-      "interface": "XPathEvaluatorBase",
-      "url": "https://dom.spec.whatwg.org/#xpathevaluatorbase",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::DOM::XPathEvaluatorBase::createExpression": {
-      "spec": "dom",
-      "interface": "XPathEvaluatorBase",
-      "member": "createExpression",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathevaluatorbase-createexpression",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "expression",
-          "type": "String"
-        },
-        {
-          "name": "resolver",
-          "type": "Web::DOM::XPathNSResolver",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::XPathExpression"
-    },
-    "Web::DOM::XPathEvaluatorBase::createNSResolver": {
-      "spec": "dom",
-      "interface": "XPathEvaluatorBase",
-      "member": "createNSResolver",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathevaluatorbase-creatensresolver",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodeResolver",
-          "type": "Web::DOM::Node"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::XPathEvaluatorBase::evaluate": {
-      "spec": "dom",
-      "interface": "XPathEvaluatorBase",
-      "member": "evaluate",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathevaluatorbase-evaluate",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "expression",
-          "type": "String"
-        },
-        {
-          "name": "contextNode",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "resolver",
-          "type": "Web::DOM::XPathNSResolver",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "type",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "result",
-          "type": "Web::DOM::XPathResult",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::XPathResult",
-      "resultName": "return"
-    },
-    "Web::DOM::XPathExpression": {
-      "spec": "dom",
-      "interface": "XPathExpression",
-      "url": "https://dom.spec.whatwg.org/#xpathexpression",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::DOM::XPathExpression::evaluate": {
-      "spec": "dom",
-      "interface": "XPathExpression",
-      "member": "evaluate",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathexpression-evaluate",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "contextNode",
-          "type": "Web::DOM::Node"
-        },
-        {
-          "name": "type",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "result",
-          "type": "Web::DOM::XPathResult",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::XPathResult",
-      "resultName": "return"
-    },
-    "Web::DOM::XPathNSResolver": {
-      "spec": "dom",
-      "interface": "XPathNSResolver",
-      "url": "https://dom.spec.whatwg.org/#xpathnsresolver",
-      "idlKind": "callback interface",
-      "kind": "action",
-      "params": [
-        {
-          "name": "prefix",
-          "type": "String",
-          "multiplicity": "[0..1]"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::DOM::XPathResult": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "url": "https://dom.spec.whatwg.org/#xpathresult",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::DOM::XPathResult::ANY_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "ANY_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-any_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::DOM::XPathResult::ANY_UNORDERED_NODE_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "ANY_UNORDERED_NODE_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-any_unordered_node_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "8"
-    },
-    "Web::DOM::XPathResult::BOOLEAN_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "BOOLEAN_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-boolean_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::DOM::XPathResult::FIRST_ORDERED_NODE_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "FIRST_ORDERED_NODE_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-first_ordered_node_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "9"
-    },
-    "Web::DOM::XPathResult::NUMBER_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "NUMBER_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-number_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::DOM::XPathResult::ORDERED_NODE_ITERATOR_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "ORDERED_NODE_ITERATOR_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-ordered_node_iterator_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "5"
-    },
-    "Web::DOM::XPathResult::ORDERED_NODE_SNAPSHOT_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "ORDERED_NODE_SNAPSHOT_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-ordered_node_snapshot_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "7"
-    },
-    "Web::DOM::XPathResult::STRING_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "STRING_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-string_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::DOM::XPathResult::UNORDERED_NODE_ITERATOR_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "UNORDERED_NODE_ITERATOR_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-unordered_node_iterator_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "4"
-    },
-    "Web::DOM::XPathResult::UNORDERED_NODE_SNAPSHOT_TYPE": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "UNORDERED_NODE_SNAPSHOT_TYPE",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-unordered_node_snapshot_type",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "6"
-    },
-    "Web::DOM::XPathResult::booleanValue": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "booleanValue",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-booleanvalue",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::XPathResult::invalidIteratorState": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "invalidIteratorState",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-invaliditeratorstate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::DOM::XPathResult::iterateNext": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "iterateNext",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-iteratenext",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::XPathResult::numberValue": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "numberValue",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-numbervalue",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "unrestricted double",
-      "constant": true
-    },
-    "Web::DOM::XPathResult::resultType": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "resultType",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-resulttype",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::DOM::XPathResult::singleNodeValue": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "singleNodeValue",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-singlenodevalue",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "Node?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::DOM::XPathResult::snapshotItem": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "snapshotItem",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-snapshotitem",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Natural"
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::DOM::XPathResult::snapshotLength": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "snapshotLength",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-snapshotlength",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::DOM::XPathResult::stringValue": {
-      "spec": "dom",
-      "interface": "XPathResult",
-      "member": "stringValue",
-      "url": "https://dom.spec.whatwg.org/#dom-xpathresult-stringvalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::AssignedNodesOptions": {
-      "spec": "html",
-      "interface": "AssignedNodesOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#assignednodesoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::AssignedNodesOptions::flatten": {
-      "spec": "html",
-      "interface": "AssignedNodesOptions",
-      "member": "flatten",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-assignednodesoptions-flatten",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::AudioTrack": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "url": "https://html.spec.whatwg.org/multipage/#audiotrack",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::AudioTrack::enabled": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "member": "enabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotrack-enabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::AudioTrack::id": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "member": "id",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotrack-id",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::AudioTrack::kind": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "member": "kind",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotrack-kind",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::AudioTrack::label": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotrack-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::AudioTrack::language": {
-      "spec": "html",
-      "interface": "AudioTrack",
-      "member": "language",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotrack-language",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::AudioTrackList": {
-      "spec": "html",
-      "interface": "AudioTrackList",
-      "url": "https://html.spec.whatwg.org/multipage/#audiotracklist",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::AudioTrackList::getTrackById": {
-      "spec": "html",
-      "interface": "AudioTrackList",
-      "member": "getTrackById",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotracklist-gettrackbyid",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "id",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::AudioTrack"
-    },
-    "Web::HTML::AudioTrackList::length": {
-      "spec": "html",
-      "interface": "AudioTrackList",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-audiotracklist-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::BlobCallback": {
-      "spec": "html",
-      "interface": "BlobCallback",
-      "url": "https://html.spec.whatwg.org/multipage/#blobcallback",
-      "idlKind": "callback",
-      "kind": "action",
-      "flags": [
-        "signature-omitted:external-type:Blob"
-      ]
-    },
-    "Web::HTML::CanPlayTypeResult": {
-      "spec": "html",
-      "interface": "CanPlayTypeResult",
-      "url": "https://html.spec.whatwg.org/multipage/#canplaytyperesult",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::CanPlayTypeResult::maybe": {
-      "spec": "html",
-      "interface": "CanPlayTypeResult",
-      "member": "maybe",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-canplaytyperesult-maybe"
-    },
-    "Web::HTML::CanPlayTypeResult::probably": {
-      "spec": "html",
-      "interface": "CanPlayTypeResult",
-      "member": "probably",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-canplaytyperesult-probably"
-    },
-    "Web::HTML::CustomElementConstructor": {
-      "spec": "html",
-      "interface": "CustomElementConstructor",
-      "url": "https://html.spec.whatwg.org/multipage/#customelementconstructor",
-      "idlKind": "callback",
-      "kind": "action",
-      "params": [],
-      "result": "Web::HTML::HTMLElement"
-    },
-    "Web::HTML::CustomElementRegistry": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "url": "https://html.spec.whatwg.org/multipage/#customelementregistry",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor"
-    },
-    "Web::HTML::CustomElementRegistry::define": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "member": "define",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-customelementregistry-define",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        },
-        {
-          "name": "constructor",
-          "type": "Web::HTML::CustomElementConstructor"
-        },
-        {
-          "name": "options",
-          "type": "Web::HTML::ElementDefinitionOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::CustomElementRegistry::getName": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "member": "getName",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-customelementregistry-getname",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "constructor",
-          "type": "Web::HTML::CustomElementConstructor"
-        }
-      ],
-      "result": "String"
-    },
-    "Web::HTML::CustomElementRegistry::initialize": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "member": "initialize",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-customelementregistry-initialize",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "root",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::HTML::CustomElementRegistry::upgrade": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "member": "upgrade",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-customelementregistry-upgrade",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "root",
-          "type": "Web::DOM::Node"
-        }
-      ]
-    },
-    "Web::HTML::CustomElementRegistry::whenDefined": {
-      "spec": "html",
-      "interface": "CustomElementRegistry",
-      "member": "whenDefined",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-customelementregistry-whendefined",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::CustomElementConstructor",
-      "async": true
-    },
-    "Web::HTML::CustomStateSet": {
-      "spec": "html",
-      "interface": "CustomStateSet",
-      "url": "https://html.spec.whatwg.org/multipage/#customstateset",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::DOMStringList": {
-      "spec": "html",
-      "interface": "DOMStringList",
-      "url": "https://html.spec.whatwg.org/multipage/#domstringlist",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::DOMStringList::contains": {
-      "spec": "html",
-      "interface": "DOMStringList",
-      "member": "contains",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-domstringlist-contains",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "string",
-          "type": "String"
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::HTML::DOMStringList::item": {
-      "spec": "html",
-      "interface": "DOMStringList",
-      "member": "item",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-domstringlist-item",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Natural"
-        }
-      ],
-      "result": "String",
-      "flags": [
-        "special:getter"
-      ]
-    },
-    "Web::HTML::DOMStringList::length": {
-      "spec": "html",
-      "interface": "DOMStringList",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-domstringlist-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::DocumentReadyState": {
-      "spec": "html",
-      "interface": "DocumentReadyState",
-      "url": "https://html.spec.whatwg.org/multipage/#documentreadystate",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::DocumentReadyState::complete": {
-      "spec": "html",
-      "interface": "DocumentReadyState",
-      "member": "complete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentreadystate-complete"
-    },
-    "Web::HTML::DocumentReadyState::interactive": {
-      "spec": "html",
-      "interface": "DocumentReadyState",
-      "member": "interactive",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentreadystate-interactive"
-    },
-    "Web::HTML::DocumentReadyState::loading": {
-      "spec": "html",
-      "interface": "DocumentReadyState",
-      "member": "loading",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentreadystate-loading"
-    },
-    "Web::HTML::DocumentVisibilityState": {
-      "spec": "html",
-      "interface": "DocumentVisibilityState",
-      "url": "https://html.spec.whatwg.org/multipage/#documentvisibilitystate",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::DocumentVisibilityState::hidden": {
-      "spec": "html",
-      "interface": "DocumentVisibilityState",
-      "member": "hidden",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentvisibilitystate-hidden"
-    },
-    "Web::HTML::DocumentVisibilityState::visible": {
-      "spec": "html",
-      "interface": "DocumentVisibilityState",
-      "member": "visible",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-documentvisibilitystate-visible"
-    },
-    "Web::HTML::ElementContentEditable": {
-      "spec": "html",
-      "interface": "ElementContentEditable",
-      "url": "https://html.spec.whatwg.org/multipage/#elementcontenteditable",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::ElementContentEditable::contentEditable": {
-      "spec": "html",
-      "interface": "ElementContentEditable",
-      "member": "contentEditable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementcontenteditable-contenteditable",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::ElementContentEditable::enterKeyHint": {
-      "spec": "html",
-      "interface": "ElementContentEditable",
-      "member": "enterKeyHint",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementcontenteditable-enterkeyhint",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::ElementContentEditable::inputMode": {
-      "spec": "html",
-      "interface": "ElementContentEditable",
-      "member": "inputMode",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementcontenteditable-inputmode",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::ElementContentEditable::isContentEditable": {
-      "spec": "html",
-      "interface": "ElementContentEditable",
-      "member": "isContentEditable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementcontenteditable-iscontenteditable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ElementDefinitionOptions": {
-      "spec": "html",
-      "interface": "ElementDefinitionOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#elementdefinitionoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::ElementDefinitionOptions::extends": {
-      "spec": "html",
-      "interface": "ElementDefinitionOptions",
-      "member": "extends",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementdefinitionoptions-extends",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::ElementInternals": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "url": "https://html.spec.whatwg.org/multipage/#elementinternals",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "flags": [
-        "external-mixin:ARIAMixin"
-      ]
-    },
-    "Web::HTML::ElementInternals::checkValidity": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::ElementInternals::form": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::ElementInternals::labels": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::ElementInternals::reportValidity": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::ElementInternals::setFormValue": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "setFormValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-setformvalue",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "value",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]"
-        },
-        {
-          "name": "state",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::ElementInternals::setValidity": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "setValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-setvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "flags",
-          "type": "Web::HTML::ValidityStateFlags",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "message",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "anchor",
-          "type": "Web::HTML::HTMLElement",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::ElementInternals::shadowRoot": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "shadowRoot",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-shadowroot",
-      "kind": "reference",
-      "type": "Web::DOM::ShadowRoot",
-      "idlType": "ShadowRoot?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::ElementInternals::states": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "states",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-states",
-      "kind": "reference",
-      "type": "Web::HTML::CustomStateSet",
-      "idlType": "CustomStateSet",
-      "constant": true
-    },
-    "Web::HTML::ElementInternals::validationMessage": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::ElementInternals::validity": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::ElementInternals::willValidate": {
-      "spec": "html",
-      "interface": "ElementInternals",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-elementinternals-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::Elements::A": {
-      "spec": "html",
-      "element": "a",
-      "interface": "HTMLAnchorElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLAnchorElement"
-      ]
-    },
-    "Web::HTML::Elements::A::localName": {
-      "spec": "html",
-      "element": "a",
-      "interface": "HTMLAnchorElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "a"
-    },
-    "Web::HTML::Elements::Abbr": {
-      "spec": "html",
-      "element": "abbr",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-abbr-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Abbr::localName": {
-      "spec": "html",
-      "element": "abbr",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-abbr-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "abbr"
-    },
-    "Web::HTML::Elements::Acronym": {
-      "spec": "html",
-      "element": "acronym",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#acronym",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Acronym::localName": {
-      "spec": "html",
-      "element": "acronym",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#acronym",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "acronym"
-    },
-    "Web::HTML::Elements::Address": {
-      "spec": "html",
-      "element": "address",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-address-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Address::localName": {
-      "spec": "html",
-      "element": "address",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-address-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "address"
-    },
-    "Web::HTML::Elements::Applet": {
-      "spec": "html",
-      "element": "applet",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#applet",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Applet::localName": {
-      "spec": "html",
-      "element": "applet",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#applet",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "applet"
-    },
-    "Web::HTML::Elements::Area": {
-      "spec": "html",
-      "element": "area",
-      "interface": "HTMLAreaElement",
-      "url": "https://html.spec.whatwg.org/multipage/image-maps.html#the-area-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLAreaElement"
-      ]
-    },
-    "Web::HTML::Elements::Area::localName": {
-      "spec": "html",
-      "element": "area",
-      "interface": "HTMLAreaElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/image-maps.html#the-area-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "area"
-    },
-    "Web::HTML::Elements::Article": {
-      "spec": "html",
-      "element": "article",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-article-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Article::localName": {
-      "spec": "html",
-      "element": "article",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-article-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "article"
-    },
-    "Web::HTML::Elements::Aside": {
-      "spec": "html",
-      "element": "aside",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-aside-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Aside::localName": {
-      "spec": "html",
-      "element": "aside",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-aside-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "aside"
-    },
-    "Web::HTML::Elements::Audio": {
-      "spec": "html",
-      "element": "audio",
-      "interface": "HTMLAudioElement",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#audio",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLAudioElement"
-      ]
-    },
-    "Web::HTML::Elements::Audio::localName": {
-      "spec": "html",
-      "element": "audio",
-      "interface": "HTMLAudioElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#audio",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "audio"
-    },
-    "Web::HTML::Elements::B": {
-      "spec": "html",
-      "element": "b",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-b-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::B::localName": {
-      "spec": "html",
-      "element": "b",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-b-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "b"
-    },
-    "Web::HTML::Elements::Base": {
-      "spec": "html",
-      "element": "base",
-      "interface": "HTMLBaseElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-base-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLBaseElement"
-      ]
-    },
-    "Web::HTML::Elements::Base::localName": {
-      "spec": "html",
-      "element": "base",
-      "interface": "HTMLBaseElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-base-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "base"
-    },
-    "Web::HTML::Elements::Basefont": {
-      "spec": "html",
-      "element": "basefont",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#basefont",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Basefont::localName": {
-      "spec": "html",
-      "element": "basefont",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#basefont",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "basefont"
-    },
-    "Web::HTML::Elements::Bdi": {
-      "spec": "html",
-      "element": "bdi",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-bdi-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Bdi::localName": {
-      "spec": "html",
-      "element": "bdi",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-bdi-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "bdi"
-    },
-    "Web::HTML::Elements::Bdo": {
-      "spec": "html",
-      "element": "bdo",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-bdo-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Bdo::localName": {
-      "spec": "html",
-      "element": "bdo",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-bdo-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "bdo"
-    },
-    "Web::HTML::Elements::Bgsound": {
-      "spec": "html",
-      "element": "bgsound",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#bgsound",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Bgsound::localName": {
-      "spec": "html",
-      "element": "bgsound",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#bgsound",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "bgsound"
-    },
-    "Web::HTML::Elements::Big": {
-      "spec": "html",
-      "element": "big",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#big",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Big::localName": {
-      "spec": "html",
-      "element": "big",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#big",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "big"
-    },
-    "Web::HTML::Elements::Blink": {
-      "spec": "html",
-      "element": "blink",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#blink",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Blink::localName": {
-      "spec": "html",
-      "element": "blink",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#blink",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "blink"
-    },
-    "Web::HTML::Elements::Blockquote": {
-      "spec": "html",
-      "element": "blockquote",
-      "interface": "HTMLQuoteElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-blockquote-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLQuoteElement"
-      ]
-    },
-    "Web::HTML::Elements::Blockquote::localName": {
-      "spec": "html",
-      "element": "blockquote",
-      "interface": "HTMLQuoteElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-blockquote-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "blockquote"
-    },
-    "Web::HTML::Elements::Body": {
-      "spec": "html",
-      "element": "body",
-      "interface": "HTMLBodyElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-body-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLBodyElement"
-      ]
-    },
-    "Web::HTML::Elements::Body::localName": {
-      "spec": "html",
-      "element": "body",
-      "interface": "HTMLBodyElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-body-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "body"
-    },
-    "Web::HTML::Elements::Br": {
-      "spec": "html",
-      "element": "br",
-      "interface": "HTMLBRElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-br-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLBRElement"
-      ]
-    },
-    "Web::HTML::Elements::Br::localName": {
-      "spec": "html",
-      "element": "br",
-      "interface": "HTMLBRElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-br-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "br"
-    },
-    "Web::HTML::Elements::Button": {
-      "spec": "html",
-      "element": "button",
-      "interface": "HTMLButtonElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-button-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLButtonElement"
-      ]
-    },
-    "Web::HTML::Elements::Button::localName": {
-      "spec": "html",
-      "element": "button",
-      "interface": "HTMLButtonElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-button-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "button"
-    },
-    "Web::HTML::Elements::Canvas": {
-      "spec": "html",
-      "element": "canvas",
-      "interface": "HTMLCanvasElement",
-      "url": "https://html.spec.whatwg.org/multipage/canvas.html#canvas",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLCanvasElement"
-      ]
-    },
-    "Web::HTML::Elements::Canvas::localName": {
-      "spec": "html",
-      "element": "canvas",
-      "interface": "HTMLCanvasElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/canvas.html#canvas",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "canvas"
-    },
-    "Web::HTML::Elements::Caption": {
-      "spec": "html",
-      "element": "caption",
-      "interface": "HTMLTableCaptionElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-caption-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableCaptionElement"
-      ]
-    },
-    "Web::HTML::Elements::Caption::localName": {
-      "spec": "html",
-      "element": "caption",
-      "interface": "HTMLTableCaptionElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-caption-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "caption"
-    },
-    "Web::HTML::Elements::Center": {
-      "spec": "html",
-      "element": "center",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#center",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Center::localName": {
-      "spec": "html",
-      "element": "center",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#center",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "center"
-    },
-    "Web::HTML::Elements::Cite": {
-      "spec": "html",
-      "element": "cite",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-cite-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Cite::localName": {
-      "spec": "html",
-      "element": "cite",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-cite-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "cite"
-    },
-    "Web::HTML::Elements::Code": {
-      "spec": "html",
-      "element": "code",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-code-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Code::localName": {
-      "spec": "html",
-      "element": "code",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-code-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "code"
-    },
-    "Web::HTML::Elements::Col": {
-      "spec": "html",
-      "element": "col",
-      "interface": "HTMLTableColElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-col-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableColElement"
-      ]
-    },
-    "Web::HTML::Elements::Col::localName": {
-      "spec": "html",
-      "element": "col",
-      "interface": "HTMLTableColElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-col-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "col"
-    },
-    "Web::HTML::Elements::Colgroup": {
-      "spec": "html",
-      "element": "colgroup",
-      "interface": "HTMLTableColElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-colgroup-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableColElement"
-      ]
-    },
-    "Web::HTML::Elements::Colgroup::localName": {
-      "spec": "html",
-      "element": "colgroup",
-      "interface": "HTMLTableColElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-colgroup-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "colgroup"
-    },
-    "Web::HTML::Elements::Data": {
-      "spec": "html",
-      "element": "data",
-      "interface": "HTMLDataElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-data-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDataElement"
-      ]
-    },
-    "Web::HTML::Elements::Data::localName": {
-      "spec": "html",
-      "element": "data",
-      "interface": "HTMLDataElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-data-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "data"
-    },
-    "Web::HTML::Elements::Datalist": {
-      "spec": "html",
-      "element": "datalist",
-      "interface": "HTMLDataListElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-datalist-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDataListElement"
-      ]
-    },
-    "Web::HTML::Elements::Datalist::localName": {
-      "spec": "html",
-      "element": "datalist",
-      "interface": "HTMLDataListElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-datalist-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "datalist"
-    },
-    "Web::HTML::Elements::Dd": {
-      "spec": "html",
-      "element": "dd",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dd-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Dd::localName": {
-      "spec": "html",
-      "element": "dd",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dd-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dd"
-    },
-    "Web::HTML::Elements::Del": {
-      "spec": "html",
-      "element": "del",
-      "interface": "HTMLModElement",
-      "url": "https://html.spec.whatwg.org/multipage/edits.html#the-del-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLModElement"
-      ]
-    },
-    "Web::HTML::Elements::Del::localName": {
-      "spec": "html",
-      "element": "del",
-      "interface": "HTMLModElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/edits.html#the-del-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "del"
-    },
-    "Web::HTML::Elements::Details": {
-      "spec": "html",
-      "element": "details",
-      "interface": "HTMLDetailsElement",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-details-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDetailsElement"
-      ]
-    },
-    "Web::HTML::Elements::Details::localName": {
-      "spec": "html",
-      "element": "details",
-      "interface": "HTMLDetailsElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-details-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "details"
-    },
-    "Web::HTML::Elements::Dfn": {
-      "spec": "html",
-      "element": "dfn",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-dfn-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Dfn::localName": {
-      "spec": "html",
-      "element": "dfn",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-dfn-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dfn"
-    },
-    "Web::HTML::Elements::Dialog": {
-      "spec": "html",
-      "element": "dialog",
-      "interface": "HTMLDialogElement",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDialogElement"
-      ]
-    },
-    "Web::HTML::Elements::Dialog::localName": {
-      "spec": "html",
-      "element": "dialog",
-      "interface": "HTMLDialogElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dialog"
-    },
-    "Web::HTML::Elements::Dir": {
-      "spec": "html",
-      "element": "dir",
-      "interface": "HTMLDirectoryElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#dir",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDirectoryElement"
-      ]
-    },
-    "Web::HTML::Elements::Dir::localName": {
-      "spec": "html",
-      "element": "dir",
-      "interface": "HTMLDirectoryElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#dir",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dir"
-    },
-    "Web::HTML::Elements::Div": {
-      "spec": "html",
-      "element": "div",
-      "interface": "HTMLDivElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-div-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDivElement"
-      ]
-    },
-    "Web::HTML::Elements::Div::localName": {
-      "spec": "html",
-      "element": "div",
-      "interface": "HTMLDivElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-div-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "div"
-    },
-    "Web::HTML::Elements::Dl": {
-      "spec": "html",
-      "element": "dl",
-      "interface": "HTMLDListElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLDListElement"
-      ]
-    },
-    "Web::HTML::Elements::Dl::localName": {
-      "spec": "html",
-      "element": "dl",
-      "interface": "HTMLDListElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dl"
-    },
-    "Web::HTML::Elements::Dt": {
-      "spec": "html",
-      "element": "dt",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dt-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Dt::localName": {
-      "spec": "html",
-      "element": "dt",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-dt-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "dt"
-    },
-    "Web::HTML::Elements::Em": {
-      "spec": "html",
-      "element": "em",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-em-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Em::localName": {
-      "spec": "html",
-      "element": "em",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-em-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "em"
-    },
-    "Web::HTML::Elements::Embed": {
-      "spec": "html",
-      "element": "embed",
-      "interface": "HTMLEmbedElement",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLEmbedElement"
-      ]
-    },
-    "Web::HTML::Elements::Embed::localName": {
-      "spec": "html",
-      "element": "embed",
-      "interface": "HTMLEmbedElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "embed"
-    },
-    "Web::HTML::Elements::Fieldset": {
-      "spec": "html",
-      "element": "fieldset",
-      "interface": "HTMLFieldSetElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-fieldset-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLFieldSetElement"
-      ]
-    },
-    "Web::HTML::Elements::Fieldset::localName": {
-      "spec": "html",
-      "element": "fieldset",
-      "interface": "HTMLFieldSetElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-fieldset-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "fieldset"
-    },
-    "Web::HTML::Elements::Figcaption": {
-      "spec": "html",
-      "element": "figcaption",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-figcaption-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Figcaption::localName": {
-      "spec": "html",
-      "element": "figcaption",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-figcaption-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "figcaption"
-    },
-    "Web::HTML::Elements::Figure": {
-      "spec": "html",
-      "element": "figure",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-figure-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Figure::localName": {
-      "spec": "html",
-      "element": "figure",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-figure-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "figure"
-    },
-    "Web::HTML::Elements::Font": {
-      "spec": "html",
-      "element": "font",
-      "interface": "HTMLFontElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#font",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLFontElement"
-      ]
-    },
-    "Web::HTML::Elements::Font::localName": {
-      "spec": "html",
-      "element": "font",
-      "interface": "HTMLFontElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#font",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "font"
-    },
-    "Web::HTML::Elements::Footer": {
-      "spec": "html",
-      "element": "footer",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-footer-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Footer::localName": {
-      "spec": "html",
-      "element": "footer",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-footer-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "footer"
-    },
-    "Web::HTML::Elements::Form": {
-      "spec": "html",
-      "element": "form",
-      "interface": "HTMLFormElement",
-      "url": "https://html.spec.whatwg.org/multipage/forms.html#the-form-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLFormElement"
-      ]
-    },
-    "Web::HTML::Elements::Form::localName": {
-      "spec": "html",
-      "element": "form",
-      "interface": "HTMLFormElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/forms.html#the-form-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "form"
-    },
-    "Web::HTML::Elements::Frame": {
-      "spec": "html",
-      "element": "frame",
-      "interface": "HTMLFrameElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#frame",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLFrameElement"
-      ]
-    },
-    "Web::HTML::Elements::Frame::localName": {
-      "spec": "html",
-      "element": "frame",
-      "interface": "HTMLFrameElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#frame",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "frame"
-    },
-    "Web::HTML::Elements::Frameset": {
-      "spec": "html",
-      "element": "frameset",
-      "interface": "HTMLFrameSetElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#frameset",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLFrameSetElement"
-      ]
-    },
-    "Web::HTML::Elements::Frameset::localName": {
-      "spec": "html",
-      "element": "frameset",
-      "interface": "HTMLFrameSetElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#frameset",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "frameset"
-    },
-    "Web::HTML::Elements::H1": {
-      "spec": "html",
-      "element": "h1",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h1-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H1::localName": {
-      "spec": "html",
-      "element": "h1",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h1-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h1"
-    },
-    "Web::HTML::Elements::H2": {
-      "spec": "html",
-      "element": "h2",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h2-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H2::localName": {
-      "spec": "html",
-      "element": "h2",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h2-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h2"
-    },
-    "Web::HTML::Elements::H3": {
-      "spec": "html",
-      "element": "h3",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h3-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H3::localName": {
-      "spec": "html",
-      "element": "h3",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h3-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h3"
-    },
-    "Web::HTML::Elements::H4": {
-      "spec": "html",
-      "element": "h4",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h4-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H4::localName": {
-      "spec": "html",
-      "element": "h4",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h4-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h4"
-    },
-    "Web::HTML::Elements::H5": {
-      "spec": "html",
-      "element": "h5",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h5-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H5::localName": {
-      "spec": "html",
-      "element": "h5",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h5-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h5"
-    },
-    "Web::HTML::Elements::H6": {
-      "spec": "html",
-      "element": "h6",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h6-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadingElement"
-      ]
-    },
-    "Web::HTML::Elements::H6::localName": {
-      "spec": "html",
-      "element": "h6",
-      "interface": "HTMLHeadingElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-h6-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "h6"
-    },
-    "Web::HTML::Elements::Head": {
-      "spec": "html",
-      "element": "head",
-      "interface": "HTMLHeadElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-head-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHeadElement"
-      ]
-    },
-    "Web::HTML::Elements::Head::localName": {
-      "spec": "html",
-      "element": "head",
-      "interface": "HTMLHeadElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-head-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "head"
-    },
-    "Web::HTML::Elements::Header": {
-      "spec": "html",
-      "element": "header",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-header-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Header::localName": {
-      "spec": "html",
-      "element": "header",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-header-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "header"
-    },
-    "Web::HTML::Elements::Hgroup": {
-      "spec": "html",
-      "element": "hgroup",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-hgroup-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Hgroup::localName": {
-      "spec": "html",
-      "element": "hgroup",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-hgroup-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "hgroup"
-    },
-    "Web::HTML::Elements::Hr": {
-      "spec": "html",
-      "element": "hr",
-      "interface": "HTMLHRElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-hr-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHRElement"
-      ]
-    },
-    "Web::HTML::Elements::Hr::localName": {
-      "spec": "html",
-      "element": "hr",
-      "interface": "HTMLHRElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-hr-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "hr"
-    },
-    "Web::HTML::Elements::Html": {
-      "spec": "html",
-      "element": "html",
-      "interface": "HTMLHtmlElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-html-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLHtmlElement"
-      ]
-    },
-    "Web::HTML::Elements::Html::localName": {
-      "spec": "html",
-      "element": "html",
-      "interface": "HTMLHtmlElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-html-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "html"
-    },
-    "Web::HTML::Elements::I": {
-      "spec": "html",
-      "element": "i",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-i-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::I::localName": {
-      "spec": "html",
-      "element": "i",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-i-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "i"
-    },
-    "Web::HTML::Elements::Iframe": {
-      "spec": "html",
-      "element": "iframe",
-      "interface": "HTMLIFrameElement",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLIFrameElement"
-      ]
-    },
-    "Web::HTML::Elements::Iframe::localName": {
-      "spec": "html",
-      "element": "iframe",
-      "interface": "HTMLIFrameElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "iframe"
-    },
-    "Web::HTML::Elements::Img": {
-      "spec": "html",
-      "element": "img",
-      "interface": "HTMLImageElement",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLImageElement"
-      ]
-    },
-    "Web::HTML::Elements::Img::localName": {
-      "spec": "html",
-      "element": "img",
-      "interface": "HTMLImageElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "img"
-    },
-    "Web::HTML::Elements::Input": {
-      "spec": "html",
-      "element": "input",
-      "interface": "HTMLInputElement",
-      "url": "https://html.spec.whatwg.org/multipage/input.html#the-input-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLInputElement"
-      ]
-    },
-    "Web::HTML::Elements::Input::localName": {
-      "spec": "html",
-      "element": "input",
-      "interface": "HTMLInputElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/input.html#the-input-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "input"
-    },
-    "Web::HTML::Elements::Ins": {
-      "spec": "html",
-      "element": "ins",
-      "interface": "HTMLModElement",
-      "url": "https://html.spec.whatwg.org/multipage/edits.html#the-ins-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLModElement"
-      ]
-    },
-    "Web::HTML::Elements::Ins::localName": {
-      "spec": "html",
-      "element": "ins",
-      "interface": "HTMLModElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/edits.html#the-ins-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "ins"
-    },
-    "Web::HTML::Elements::Isindex": {
-      "spec": "html",
-      "element": "isindex",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#isindex",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Isindex::localName": {
-      "spec": "html",
-      "element": "isindex",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#isindex",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "isindex"
-    },
-    "Web::HTML::Elements::Kbd": {
-      "spec": "html",
-      "element": "kbd",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-kbd-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Kbd::localName": {
-      "spec": "html",
-      "element": "kbd",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-kbd-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "kbd"
-    },
-    "Web::HTML::Elements::Keygen": {
-      "spec": "html",
-      "element": "keygen",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#keygen",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Keygen::localName": {
-      "spec": "html",
-      "element": "keygen",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#keygen",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "keygen"
-    },
-    "Web::HTML::Elements::Label": {
-      "spec": "html",
-      "element": "label",
-      "interface": "HTMLLabelElement",
-      "url": "https://html.spec.whatwg.org/multipage/forms.html#the-label-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLLabelElement"
-      ]
-    },
-    "Web::HTML::Elements::Label::localName": {
-      "spec": "html",
-      "element": "label",
-      "interface": "HTMLLabelElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/forms.html#the-label-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "label"
-    },
-    "Web::HTML::Elements::Legend": {
-      "spec": "html",
-      "element": "legend",
-      "interface": "HTMLLegendElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-legend-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLLegendElement"
-      ]
-    },
-    "Web::HTML::Elements::Legend::localName": {
-      "spec": "html",
-      "element": "legend",
-      "interface": "HTMLLegendElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-legend-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "legend"
-    },
-    "Web::HTML::Elements::Li": {
-      "spec": "html",
-      "element": "li",
-      "interface": "HTMLLIElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-li-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLLIElement"
-      ]
-    },
-    "Web::HTML::Elements::Li::localName": {
-      "spec": "html",
-      "element": "li",
-      "interface": "HTMLLIElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-li-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "li"
-    },
-    "Web::HTML::Elements::Link": {
-      "spec": "html",
-      "element": "link",
-      "interface": "HTMLLinkElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-link-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLLinkElement"
-      ]
-    },
-    "Web::HTML::Elements::Link::localName": {
-      "spec": "html",
-      "element": "link",
-      "interface": "HTMLLinkElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-link-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "link"
-    },
-    "Web::HTML::Elements::Listing": {
-      "spec": "html",
-      "element": "listing",
-      "interface": "HTMLPreElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#listing",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLPreElement"
-      ]
-    },
-    "Web::HTML::Elements::Listing::localName": {
-      "spec": "html",
-      "element": "listing",
-      "interface": "HTMLPreElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#listing",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "listing"
-    },
-    "Web::HTML::Elements::Main": {
-      "spec": "html",
-      "element": "main",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-main-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Main::localName": {
-      "spec": "html",
-      "element": "main",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-main-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "main"
-    },
-    "Web::HTML::Elements::Map": {
-      "spec": "html",
-      "element": "map",
-      "interface": "HTMLMapElement",
-      "url": "https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLMapElement"
-      ]
-    },
-    "Web::HTML::Elements::Map::localName": {
-      "spec": "html",
-      "element": "map",
-      "interface": "HTMLMapElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "map"
-    },
-    "Web::HTML::Elements::Mark": {
-      "spec": "html",
-      "element": "mark",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-mark-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Mark::localName": {
-      "spec": "html",
-      "element": "mark",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-mark-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "mark"
-    },
-    "Web::HTML::Elements::Marquee": {
-      "spec": "html",
-      "element": "marquee",
-      "interface": "HTMLMarqueeElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#the-marquee-element",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLMarqueeElement"
-      ]
-    },
-    "Web::HTML::Elements::Marquee::localName": {
-      "spec": "html",
-      "element": "marquee",
-      "interface": "HTMLMarqueeElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#the-marquee-element",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "marquee"
-    },
-    "Web::HTML::Elements::Menu": {
-      "spec": "html",
-      "element": "menu",
-      "interface": "HTMLMenuElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#menus",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLMenuElement"
-      ]
-    },
-    "Web::HTML::Elements::Menu::localName": {
-      "spec": "html",
-      "element": "menu",
-      "interface": "HTMLMenuElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#menus",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "menu"
-    },
-    "Web::HTML::Elements::Menuitem": {
-      "spec": "html",
-      "element": "menuitem",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#menuitem",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Menuitem::localName": {
-      "spec": "html",
-      "element": "menuitem",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#menuitem",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "menuitem"
-    },
-    "Web::HTML::Elements::Meta": {
-      "spec": "html",
-      "element": "meta",
-      "interface": "HTMLMetaElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#meta",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLMetaElement"
-      ]
-    },
-    "Web::HTML::Elements::Meta::localName": {
-      "spec": "html",
-      "element": "meta",
-      "interface": "HTMLMetaElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#meta",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "meta"
-    },
-    "Web::HTML::Elements::Meter": {
-      "spec": "html",
-      "element": "meter",
-      "interface": "HTMLMeterElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-meter-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLMeterElement"
-      ]
-    },
-    "Web::HTML::Elements::Meter::localName": {
-      "spec": "html",
-      "element": "meter",
-      "interface": "HTMLMeterElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-meter-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "meter"
-    },
-    "Web::HTML::Elements::Multicol": {
-      "spec": "html",
-      "element": "multicol",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#multicol",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Multicol::localName": {
-      "spec": "html",
-      "element": "multicol",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#multicol",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "multicol"
-    },
-    "Web::HTML::Elements::Nav": {
-      "spec": "html",
-      "element": "nav",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-nav-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Nav::localName": {
-      "spec": "html",
-      "element": "nav",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-nav-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "nav"
-    },
-    "Web::HTML::Elements::Nextid": {
-      "spec": "html",
-      "element": "nextid",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#nextid",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Nextid::localName": {
-      "spec": "html",
-      "element": "nextid",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#nextid",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "nextid"
-    },
-    "Web::HTML::Elements::Nobr": {
-      "spec": "html",
-      "element": "nobr",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#nobr",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Nobr::localName": {
-      "spec": "html",
-      "element": "nobr",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#nobr",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "nobr"
-    },
-    "Web::HTML::Elements::Noembed": {
-      "spec": "html",
-      "element": "noembed",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#noembed",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Noembed::localName": {
-      "spec": "html",
-      "element": "noembed",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#noembed",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "noembed"
-    },
-    "Web::HTML::Elements::Noframes": {
-      "spec": "html",
-      "element": "noframes",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#noframes",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Noframes::localName": {
-      "spec": "html",
-      "element": "noframes",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#noframes",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "noframes"
-    },
-    "Web::HTML::Elements::Noscript": {
-      "spec": "html",
-      "element": "noscript",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-noscript-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Noscript::localName": {
-      "spec": "html",
-      "element": "noscript",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-noscript-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "noscript"
-    },
-    "Web::HTML::Elements::Object": {
-      "spec": "html",
-      "element": "object",
-      "interface": "HTMLObjectElement",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLObjectElement"
-      ]
-    },
-    "Web::HTML::Elements::Object::localName": {
-      "spec": "html",
-      "element": "object",
-      "interface": "HTMLObjectElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "object"
-    },
-    "Web::HTML::Elements::Ol": {
-      "spec": "html",
-      "element": "ol",
-      "interface": "HTMLOListElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-ol-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLOListElement"
-      ]
-    },
-    "Web::HTML::Elements::Ol::localName": {
-      "spec": "html",
-      "element": "ol",
-      "interface": "HTMLOListElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-ol-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "ol"
-    },
-    "Web::HTML::Elements::Optgroup": {
-      "spec": "html",
-      "element": "optgroup",
-      "interface": "HTMLOptGroupElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-optgroup-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLOptGroupElement"
-      ]
-    },
-    "Web::HTML::Elements::Optgroup::localName": {
-      "spec": "html",
-      "element": "optgroup",
-      "interface": "HTMLOptGroupElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-optgroup-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "optgroup"
-    },
-    "Web::HTML::Elements::Option": {
-      "spec": "html",
-      "element": "option",
-      "interface": "HTMLOptionElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-option-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLOptionElement"
-      ]
-    },
-    "Web::HTML::Elements::Option::localName": {
-      "spec": "html",
-      "element": "option",
-      "interface": "HTMLOptionElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-option-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "option"
-    },
-    "Web::HTML::Elements::Output": {
-      "spec": "html",
-      "element": "output",
-      "interface": "HTMLOutputElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-output-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLOutputElement"
-      ]
-    },
-    "Web::HTML::Elements::Output::localName": {
-      "spec": "html",
-      "element": "output",
-      "interface": "HTMLOutputElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-output-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "output"
-    },
-    "Web::HTML::Elements::P": {
-      "spec": "html",
-      "element": "p",
-      "interface": "HTMLParagraphElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-p-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLParagraphElement"
-      ]
-    },
-    "Web::HTML::Elements::P::localName": {
-      "spec": "html",
-      "element": "p",
-      "interface": "HTMLParagraphElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-p-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "p"
-    },
-    "Web::HTML::Elements::Param": {
-      "spec": "html",
-      "element": "param",
-      "interface": "HTMLParamElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#param",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLParamElement"
-      ]
-    },
-    "Web::HTML::Elements::Param::localName": {
-      "spec": "html",
-      "element": "param",
-      "interface": "HTMLParamElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#param",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "param"
-    },
-    "Web::HTML::Elements::Picture": {
-      "spec": "html",
-      "element": "picture",
-      "interface": "HTMLPictureElement",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-picture-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLPictureElement"
-      ]
-    },
-    "Web::HTML::Elements::Picture::localName": {
-      "spec": "html",
-      "element": "picture",
-      "interface": "HTMLPictureElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-picture-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "picture"
-    },
-    "Web::HTML::Elements::Plaintext": {
-      "spec": "html",
-      "element": "plaintext",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#plaintext",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Plaintext::localName": {
-      "spec": "html",
-      "element": "plaintext",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#plaintext",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "plaintext"
-    },
-    "Web::HTML::Elements::Pre": {
-      "spec": "html",
-      "element": "pre",
-      "interface": "HTMLPreElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLPreElement"
-      ]
-    },
-    "Web::HTML::Elements::Pre::localName": {
-      "spec": "html",
-      "element": "pre",
-      "interface": "HTMLPreElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "pre"
-    },
-    "Web::HTML::Elements::Progress": {
-      "spec": "html",
-      "element": "progress",
-      "interface": "HTMLProgressElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-progress-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLProgressElement"
-      ]
-    },
-    "Web::HTML::Elements::Progress::localName": {
-      "spec": "html",
-      "element": "progress",
-      "interface": "HTMLProgressElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-progress-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "progress"
-    },
-    "Web::HTML::Elements::Q": {
-      "spec": "html",
-      "element": "q",
-      "interface": "HTMLQuoteElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-q-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLQuoteElement"
-      ]
-    },
-    "Web::HTML::Elements::Q::localName": {
-      "spec": "html",
-      "element": "q",
-      "interface": "HTMLQuoteElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-q-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "q"
-    },
-    "Web::HTML::Elements::Rb": {
-      "spec": "html",
-      "element": "rb",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#rb",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Rb::localName": {
-      "spec": "html",
-      "element": "rb",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#rb",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "rb"
-    },
-    "Web::HTML::Elements::Rp": {
-      "spec": "html",
-      "element": "rp",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-rp-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Rp::localName": {
-      "spec": "html",
-      "element": "rp",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-rp-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "rp"
-    },
-    "Web::HTML::Elements::Rt": {
-      "spec": "html",
-      "element": "rt",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-rt-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Rt::localName": {
-      "spec": "html",
-      "element": "rt",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-rt-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "rt"
-    },
-    "Web::HTML::Elements::Rtc": {
-      "spec": "html",
-      "element": "rtc",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#rtc",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Rtc::localName": {
-      "spec": "html",
-      "element": "rtc",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#rtc",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "rtc"
-    },
-    "Web::HTML::Elements::Ruby": {
-      "spec": "html",
-      "element": "ruby",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-ruby-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Ruby::localName": {
-      "spec": "html",
-      "element": "ruby",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-ruby-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "ruby"
-    },
-    "Web::HTML::Elements::S": {
-      "spec": "html",
-      "element": "s",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-s-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::S::localName": {
-      "spec": "html",
-      "element": "s",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-s-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "s"
-    },
-    "Web::HTML::Elements::Samp": {
-      "spec": "html",
-      "element": "samp",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-samp-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Samp::localName": {
-      "spec": "html",
-      "element": "samp",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-samp-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "samp"
-    },
-    "Web::HTML::Elements::Script": {
-      "spec": "html",
-      "element": "script",
-      "interface": "HTMLScriptElement",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#script",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLScriptElement"
-      ]
-    },
-    "Web::HTML::Elements::Script::localName": {
-      "spec": "html",
-      "element": "script",
-      "interface": "HTMLScriptElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#script",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "script"
-    },
-    "Web::HTML::Elements::Search": {
-      "spec": "html",
-      "element": "search",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-search-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Search::localName": {
-      "spec": "html",
-      "element": "search",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-search-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "search"
-    },
-    "Web::HTML::Elements::Section": {
-      "spec": "html",
-      "element": "section",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-section-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Section::localName": {
-      "spec": "html",
-      "element": "section",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/sections.html#the-section-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "section"
-    },
-    "Web::HTML::Elements::Select": {
-      "spec": "html",
-      "element": "select",
-      "interface": "HTMLSelectElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-select-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLSelectElement"
-      ]
-    },
-    "Web::HTML::Elements::Select::localName": {
-      "spec": "html",
-      "element": "select",
-      "interface": "HTMLSelectElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-select-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "select"
-    },
-    "Web::HTML::Elements::Selectedcontent": {
-      "spec": "html",
-      "element": "selectedcontent",
-      "interface": "HTMLSelectedContentElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-selectedcontent-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLSelectedContentElement"
-      ]
-    },
-    "Web::HTML::Elements::Selectedcontent::localName": {
-      "spec": "html",
-      "element": "selectedcontent",
-      "interface": "HTMLSelectedContentElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-selectedcontent-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "selectedcontent"
-    },
-    "Web::HTML::Elements::Slot": {
-      "spec": "html",
-      "element": "slot",
-      "interface": "HTMLSlotElement",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-slot-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLSlotElement"
-      ]
-    },
-    "Web::HTML::Elements::Slot::localName": {
-      "spec": "html",
-      "element": "slot",
-      "interface": "HTMLSlotElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-slot-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "slot"
-    },
-    "Web::HTML::Elements::Small": {
-      "spec": "html",
-      "element": "small",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-small-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Small::localName": {
-      "spec": "html",
-      "element": "small",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-small-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "small"
-    },
-    "Web::HTML::Elements::Source": {
-      "spec": "html",
-      "element": "source",
-      "interface": "HTMLSourceElement",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-source-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLSourceElement"
-      ]
-    },
-    "Web::HTML::Elements::Source::localName": {
-      "spec": "html",
-      "element": "source",
-      "interface": "HTMLSourceElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/embedded-content.html#the-source-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "source"
-    },
-    "Web::HTML::Elements::Spacer": {
-      "spec": "html",
-      "element": "spacer",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#spacer",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUnknownElement"
-      ]
-    },
-    "Web::HTML::Elements::Spacer::localName": {
-      "spec": "html",
-      "element": "spacer",
-      "interface": "HTMLUnknownElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#spacer",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "spacer"
-    },
-    "Web::HTML::Elements::Span": {
-      "spec": "html",
-      "element": "span",
-      "interface": "HTMLSpanElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-span-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLSpanElement"
-      ]
-    },
-    "Web::HTML::Elements::Span::localName": {
-      "spec": "html",
-      "element": "span",
-      "interface": "HTMLSpanElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-span-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "span"
-    },
-    "Web::HTML::Elements::Strike": {
-      "spec": "html",
-      "element": "strike",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#strike",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Strike::localName": {
-      "spec": "html",
-      "element": "strike",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#strike",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "strike"
-    },
-    "Web::HTML::Elements::Strong": {
-      "spec": "html",
-      "element": "strong",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-strong-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Strong::localName": {
-      "spec": "html",
-      "element": "strong",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-strong-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "strong"
-    },
-    "Web::HTML::Elements::Style": {
-      "spec": "html",
-      "element": "style",
-      "interface": "HTMLStyleElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-style-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLStyleElement"
-      ]
-    },
-    "Web::HTML::Elements::Style::localName": {
-      "spec": "html",
-      "element": "style",
-      "interface": "HTMLStyleElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-style-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "style"
-    },
-    "Web::HTML::Elements::Sub": {
-      "spec": "html",
-      "element": "sub",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-sub-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Sub::localName": {
-      "spec": "html",
-      "element": "sub",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-sub-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "sub"
-    },
-    "Web::HTML::Elements::Summary": {
-      "spec": "html",
-      "element": "summary",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-summary-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Summary::localName": {
-      "spec": "html",
-      "element": "summary",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/interactive-elements.html#the-summary-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "summary"
-    },
-    "Web::HTML::Elements::Sup": {
-      "spec": "html",
-      "element": "sup",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-sup-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Sup::localName": {
-      "spec": "html",
-      "element": "sup",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-sup-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "sup"
-    },
-    "Web::HTML::Elements::Table": {
-      "spec": "html",
-      "element": "table",
-      "interface": "HTMLTableElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-table-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableElement"
-      ]
-    },
-    "Web::HTML::Elements::Table::localName": {
-      "spec": "html",
-      "element": "table",
-      "interface": "HTMLTableElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-table-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "table"
-    },
-    "Web::HTML::Elements::Tbody": {
-      "spec": "html",
-      "element": "tbody",
-      "interface": "HTMLTableSectionElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tbody-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableSectionElement"
-      ]
-    },
-    "Web::HTML::Elements::Tbody::localName": {
-      "spec": "html",
-      "element": "tbody",
-      "interface": "HTMLTableSectionElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tbody-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "tbody"
-    },
-    "Web::HTML::Elements::Td": {
-      "spec": "html",
-      "element": "td",
-      "interface": "HTMLTableCellElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-td-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableCellElement"
-      ]
-    },
-    "Web::HTML::Elements::Td::localName": {
-      "spec": "html",
-      "element": "td",
-      "interface": "HTMLTableCellElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-td-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "td"
-    },
-    "Web::HTML::Elements::Template": {
-      "spec": "html",
-      "element": "template",
-      "interface": "HTMLTemplateElement",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-template-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTemplateElement"
-      ]
-    },
-    "Web::HTML::Elements::Template::localName": {
-      "spec": "html",
-      "element": "template",
-      "interface": "HTMLTemplateElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/scripting.html#the-template-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "template"
-    },
-    "Web::HTML::Elements::Textarea": {
-      "spec": "html",
-      "element": "textarea",
-      "interface": "HTMLTextAreaElement",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-textarea-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTextAreaElement"
-      ]
-    },
-    "Web::HTML::Elements::Textarea::localName": {
-      "spec": "html",
-      "element": "textarea",
-      "interface": "HTMLTextAreaElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/form-elements.html#the-textarea-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "textarea"
-    },
-    "Web::HTML::Elements::Tfoot": {
-      "spec": "html",
-      "element": "tfoot",
-      "interface": "HTMLTableSectionElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tfoot-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableSectionElement"
-      ]
-    },
-    "Web::HTML::Elements::Tfoot::localName": {
-      "spec": "html",
-      "element": "tfoot",
-      "interface": "HTMLTableSectionElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tfoot-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "tfoot"
-    },
-    "Web::HTML::Elements::Th": {
-      "spec": "html",
-      "element": "th",
-      "interface": "HTMLTableCellElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-th-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableCellElement"
-      ]
-    },
-    "Web::HTML::Elements::Th::localName": {
-      "spec": "html",
-      "element": "th",
-      "interface": "HTMLTableCellElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-th-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "th"
-    },
-    "Web::HTML::Elements::Thead": {
-      "spec": "html",
-      "element": "thead",
-      "interface": "HTMLTableSectionElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-thead-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableSectionElement"
-      ]
-    },
-    "Web::HTML::Elements::Thead::localName": {
-      "spec": "html",
-      "element": "thead",
-      "interface": "HTMLTableSectionElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-thead-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "thead"
-    },
-    "Web::HTML::Elements::Time": {
-      "spec": "html",
-      "element": "time",
-      "interface": "HTMLTimeElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-time-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTimeElement"
-      ]
-    },
-    "Web::HTML::Elements::Time::localName": {
-      "spec": "html",
-      "element": "time",
-      "interface": "HTMLTimeElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-time-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "time"
-    },
-    "Web::HTML::Elements::Title": {
-      "spec": "html",
-      "element": "title",
-      "interface": "HTMLTitleElement",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-title-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTitleElement"
-      ]
-    },
-    "Web::HTML::Elements::Title::localName": {
-      "spec": "html",
-      "element": "title",
-      "interface": "HTMLTitleElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/semantics.html#the-title-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "title"
-    },
-    "Web::HTML::Elements::Tr": {
-      "spec": "html",
-      "element": "tr",
-      "interface": "HTMLTableRowElement",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tr-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTableRowElement"
-      ]
-    },
-    "Web::HTML::Elements::Tr::localName": {
-      "spec": "html",
-      "element": "tr",
-      "interface": "HTMLTableRowElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/tables.html#the-tr-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "tr"
-    },
-    "Web::HTML::Elements::Track": {
-      "spec": "html",
-      "element": "track",
-      "interface": "HTMLTrackElement",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#the-track-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLTrackElement"
-      ]
-    },
-    "Web::HTML::Elements::Track::localName": {
-      "spec": "html",
-      "element": "track",
-      "interface": "HTMLTrackElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#the-track-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "track"
-    },
-    "Web::HTML::Elements::Tt": {
-      "spec": "html",
-      "element": "tt",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#tt",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Tt::localName": {
-      "spec": "html",
-      "element": "tt",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#tt",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "tt"
-    },
-    "Web::HTML::Elements::U": {
-      "spec": "html",
-      "element": "u",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-u-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::U::localName": {
-      "spec": "html",
-      "element": "u",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-u-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "u"
-    },
-    "Web::HTML::Elements::Ul": {
-      "spec": "html",
-      "element": "ul",
-      "interface": "HTMLUListElement",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-ul-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLUListElement"
-      ]
-    },
-    "Web::HTML::Elements::Ul::localName": {
-      "spec": "html",
-      "element": "ul",
-      "interface": "HTMLUListElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/grouping-content.html#the-ul-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "ul"
-    },
-    "Web::HTML::Elements::Var": {
-      "spec": "html",
-      "element": "var",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-var-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Var::localName": {
-      "spec": "html",
-      "element": "var",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-var-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "var"
-    },
-    "Web::HTML::Elements::Video": {
-      "spec": "html",
-      "element": "video",
-      "interface": "HTMLVideoElement",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#video",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLVideoElement"
-      ]
-    },
-    "Web::HTML::Elements::Video::localName": {
-      "spec": "html",
-      "element": "video",
-      "interface": "HTMLVideoElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/media.html#video",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "video"
-    },
-    "Web::HTML::Elements::Wbr": {
-      "spec": "html",
-      "element": "wbr",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-wbr-element",
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::Elements::Wbr::localName": {
-      "spec": "html",
-      "element": "wbr",
-      "interface": "HTMLElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-wbr-element",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "wbr"
-    },
-    "Web::HTML::Elements::Xmp": {
-      "spec": "html",
-      "element": "xmp",
-      "interface": "HTMLPreElement",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#xmp",
-      "obsolete": true,
-      "idlKind": "element",
-      "kind": "part",
-      "generalizations": [
-        "Web::HTML::HTMLPreElement"
-      ]
-    },
-    "Web::HTML::Elements::Xmp::localName": {
-      "spec": "html",
-      "element": "xmp",
-      "interface": "HTMLPreElement",
-      "member": "localName",
-      "url": "https://html.spec.whatwg.org/multipage/obsolete.html#xmp",
-      "obsolete": true,
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "redefines": true,
-      "value": "xmp"
-    },
-    "Web::HTML::FocusOptions": {
-      "spec": "html",
-      "interface": "FocusOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#focusoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::FocusOptions::focusVisible": {
-      "spec": "html",
-      "interface": "FocusOptions",
-      "member": "focusVisible",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-focusoptions-focusvisible",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::FocusOptions::preventScroll": {
-      "spec": "html",
-      "interface": "FocusOptions",
-      "member": "preventScroll",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-focusoptions-preventscroll",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::GetHTMLOptions": {
-      "spec": "html",
-      "interface": "GetHTMLOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#gethtmloptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::GetHTMLOptions::serializableShadowRoots": {
-      "spec": "html",
-      "interface": "GetHTMLOptions",
-      "member": "serializableShadowRoots",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-gethtmloptions-serializableshadowroots",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::GetHTMLOptions::shadowRoots": {
-      "spec": "html",
-      "interface": "GetHTMLOptions",
-      "member": "shadowRoots",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-gethtmloptions-shadowroots",
-      "kind": "reference",
-      "type": "Web::DOM::ShadowRoot",
-      "idlType": "sequence<ShadowRoot>",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "default": "[]"
-    },
-    "Web::HTML::GlobalEventHandlers": {
-      "spec": "html",
-      "interface": "GlobalEventHandlers",
-      "url": "https://html.spec.whatwg.org/multipage/#globaleventhandlers",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::HTMLAnchorElement": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlanchorelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::HyperlinkElementUtils",
-        "Web::HTML::HTMLHyperlinkElementUtils"
-      ]
-    },
-    "Web::HTML::HTMLAnchorElement::charset": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "charset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-charset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charset"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::coords": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "coords",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-coords",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "coords"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::download": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "download",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-download",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "download"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::name": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::ping": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "ping",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-ping",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "ping"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLAnchorElement::rel": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "rel",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-rel",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::relList": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "relList",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-rellist",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLAnchorElement::rev": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "rev",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-rev",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rev"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::shape": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "shape",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-shape",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shape"
-      }
-    },
-    "Web::HTML::HTMLAnchorElement::text": {
-      "spec": "html",
-      "interface": "HTMLAnchorElement",
-      "member": "text",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlanchorelement-text",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLAreaElement": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlareaelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::HyperlinkElementUtils",
-        "Web::HTML::HTMLHyperlinkElementUtils"
-      ]
-    },
-    "Web::HTML::HTMLAreaElement::alt": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "alt",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-alt",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "alt"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::coords": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "coords",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-coords",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "coords"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::download": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "download",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-download",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "download"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::noHref": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "noHref",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-nohref",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "nohref"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::ping": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "ping",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-ping",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "ping"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLAreaElement::rel": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "rel",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-rel",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      }
-    },
-    "Web::HTML::HTMLAreaElement::relList": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "relList",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-rellist",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLAreaElement::shape": {
-      "spec": "html",
-      "interface": "HTMLAreaElement",
-      "member": "shape",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlareaelement-shape",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shape"
-      }
-    },
-    "Web::HTML::HTMLAudioElement": {
-      "spec": "html",
-      "interface": "HTMLAudioElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlaudioelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLMediaElement"
-      ]
-    },
-    "Web::HTML::HTMLBRElement": {
-      "spec": "html",
-      "interface": "HTMLBRElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlbrelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLBRElement::clear": {
-      "spec": "html",
-      "interface": "HTMLBRElement",
-      "member": "clear",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbrelement-clear",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "clear"
-      }
-    },
-    "Web::HTML::HTMLBaseElement": {
-      "spec": "html",
-      "interface": "HTMLBaseElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlbaseelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLBaseElement::href": {
-      "spec": "html",
-      "interface": "HTMLBaseElement",
-      "member": "href",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbaseelement-href",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "href"
-      }
-    },
-    "Web::HTML::HTMLBaseElement::target": {
-      "spec": "html",
-      "interface": "HTMLBaseElement",
-      "member": "target",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbaseelement-target",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "target"
-      }
-    },
-    "Web::HTML::HTMLBodyElement": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlbodyelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::WindowEventHandlers"
-      ]
-    },
-    "Web::HTML::HTMLBodyElement::aLink": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "aLink",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-alink",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "alink"
-      }
-    },
-    "Web::HTML::HTMLBodyElement::background": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "background",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-background",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "background"
-      }
-    },
-    "Web::HTML::HTMLBodyElement::bgColor": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "bgcolor"
-      }
-    },
-    "Web::HTML::HTMLBodyElement::link": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "link",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-link",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "link"
-      }
-    },
-    "Web::HTML::HTMLBodyElement::text": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "text",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-text",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "text"
-      }
-    },
-    "Web::HTML::HTMLBodyElement::vLink": {
-      "spec": "html",
-      "interface": "HTMLBodyElement",
-      "member": "vLink",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbodyelement-vlink",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "vlink"
-      }
-    },
-    "Web::HTML::HTMLButtonElement": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlbuttonelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::PopoverTargetAttributes"
-      ]
-    },
-    "Web::HTML::HTMLButtonElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLButtonElement::command": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "command",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-command",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "command"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::commandForElement": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "commandForElement",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-commandforelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "commandfor"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::form": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLButtonElement::formAction": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "formAction",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-formaction",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "formaction"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::formEnctype": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "formEnctype",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-formenctype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLButtonElement::formMethod": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "formMethod",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-formmethod",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLButtonElement::formNoValidate": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "formNoValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-formnovalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "formnovalidate"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::formTarget": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "formTarget",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-formtarget",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "formtarget"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::labels": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLButtonElement::name": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLButtonElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLButtonElement::type": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLButtonElement::validity": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLButtonElement::value": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLButtonElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLButtonElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlbuttonelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLCanvasElement": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlcanvaselement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLCanvasElement::getContext": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "getContext",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-getcontext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "contextId",
-          "type": "String"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Base::Anything"
-    },
-    "Web::HTML::HTMLCanvasElement::height": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLCanvasElement::toBlob": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "toBlob",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-toblob",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "callback",
-          "type": "Web::HTML::BlobCallback"
-        },
-        {
-          "name": "type",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "quality",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLCanvasElement::toDataURL": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "toDataURL",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-todataurl",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "type",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "quality",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "String"
-    },
-    "Web::HTML::HTMLCanvasElement::transferControlToOffscreen": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "transferControlToOffscreen",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-transfercontroltooffscreen",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::OffscreenCanvas"
-    },
-    "Web::HTML::HTMLCanvasElement::width": {
-      "spec": "html",
-      "interface": "HTMLCanvasElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlcanvaselement-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLDListElement": {
-      "spec": "html",
-      "interface": "HTMLDListElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldlistelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDListElement::compact": {
-      "spec": "html",
-      "interface": "HTMLDListElement",
-      "member": "compact",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldlistelement-compact",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "compact"
-      }
-    },
-    "Web::HTML::HTMLDataElement": {
-      "spec": "html",
-      "interface": "HTMLDataElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldataelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDataElement::value": {
-      "spec": "html",
-      "interface": "HTMLDataElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldataelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLDataListElement": {
-      "spec": "html",
-      "interface": "HTMLDataListElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldatalistelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDataListElement::options": {
-      "spec": "html",
-      "interface": "HTMLDataListElement",
-      "member": "options",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldatalistelement-options",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLDetailsElement": {
-      "spec": "html",
-      "interface": "HTMLDetailsElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldetailselement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDetailsElement::name": {
-      "spec": "html",
-      "interface": "HTMLDetailsElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldetailselement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLDetailsElement::open": {
-      "spec": "html",
-      "interface": "HTMLDetailsElement",
-      "member": "open",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldetailselement-open",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "open"
-      }
-    },
-    "Web::HTML::HTMLDialogElement": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldialogelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDialogElement::close": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "close",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-close",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "returnValue",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLDialogElement::closedBy": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "closedBy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-closedby",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "closedby"
-      }
-    },
-    "Web::HTML::HTMLDialogElement::open": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "open",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-open",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "open"
-      }
-    },
-    "Web::HTML::HTMLDialogElement::requestClose": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "requestClose",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-requestclose",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "returnValue",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLDialogElement::returnValue": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "returnValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-returnvalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLDialogElement::show": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "show",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-show",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLDialogElement::showModal": {
-      "spec": "html",
-      "interface": "HTMLDialogElement",
-      "member": "showModal",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldialogelement-showmodal",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLDirectoryElement": {
-      "spec": "html",
-      "interface": "HTMLDirectoryElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldirectoryelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDirectoryElement::compact": {
-      "spec": "html",
-      "interface": "HTMLDirectoryElement",
-      "member": "compact",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldirectoryelement-compact",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "compact"
-      }
-    },
-    "Web::HTML::HTMLDivElement": {
-      "spec": "html",
-      "interface": "HTMLDivElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmldivelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLDivElement::align": {
-      "spec": "html",
-      "interface": "HTMLDivElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmldivelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLElement": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::DOM::Element",
-        "Web::HTML::GlobalEventHandlers",
-        "Web::HTML::ElementContentEditable",
-        "Web::HTML::HTMLOrSVGOrMathMLElement"
-      ]
-    },
-    "Web::HTML::HTMLElement::accessKey": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "accessKey",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-accesskey",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "accesskey"
-      }
-    },
-    "Web::HTML::HTMLElement::accessKeyLabel": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "accessKeyLabel",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-accesskeylabel",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLElement::attachInternals": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "attachInternals",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-attachinternals",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::ElementInternals"
-    },
-    "Web::HTML::HTMLElement::autocapitalize": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "autocapitalize",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-autocapitalize",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "autocapitalize"
-      }
-    },
-    "Web::HTML::HTMLElement::autocorrect": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "autocorrect",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-autocorrect",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "autocorrect"
-      }
-    },
-    "Web::HTML::HTMLElement::click": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "click",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-click",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLElement::dir": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "dir",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-dir",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "dir"
-      }
-    },
-    "Web::HTML::HTMLElement::draggable": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "draggable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-draggable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "draggable"
-      }
-    },
-    "Web::HTML::HTMLElement::headingOffset": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "headingOffset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-headingoffset",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "headingoffset",
-        "range": [
-          "0",
-          "8"
-        ]
-      }
-    },
-    "Web::HTML::HTMLElement::headingReset": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "headingReset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-headingreset",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "headingreset"
-      }
-    },
-    "Web::HTML::HTMLElement::hidden": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "hidden",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-hidden",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(boolean or unrestricted double or DOMString)?",
-      "multiplicity": "[0..1]",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "hidden"
-      },
-      "flags": [
-        "union-unmapped:(boolean or unrestricted double or DOMString)?"
-      ]
-    },
-    "Web::HTML::HTMLElement::hidePopover": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "hidePopover",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-hidepopover",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLElement::inert": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "inert",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-inert",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "inert"
-      }
-    },
-    "Web::HTML::HTMLElement::innerText": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "innerText",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-innertext",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLElement::lang": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "lang",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-lang",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "lang"
-      }
-    },
-    "Web::HTML::HTMLElement::outerText": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "outerText",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-outertext",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLElement::popover": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "popover",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-popover",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "popover"
-      }
-    },
-    "Web::HTML::HTMLElement::showPopover": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "showPopover",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-showpopover",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::ShowPopoverOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLElement::spellcheck": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "spellcheck",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-spellcheck",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "spellcheck"
-      }
-    },
-    "Web::HTML::HTMLElement::title": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "title",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-title",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "title"
-      }
-    },
-    "Web::HTML::HTMLElement::togglePopover": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "togglePopover",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-togglepopover",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLElement::translate": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "translate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-translate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "translate"
-      }
-    },
-    "Web::HTML::HTMLElement::writingSuggestions": {
-      "spec": "html",
-      "interface": "HTMLElement",
-      "member": "writingSuggestions",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlelement-writingsuggestions",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "writingsuggestions"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlembedelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLEmbedElement::align": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement::getSVGDocument": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "getSVGDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-getsvgdocument",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Document"
-    },
-    "Web::HTML::HTMLEmbedElement::height": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-height",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement::name": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement::src": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement::type": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLEmbedElement::width": {
-      "spec": "html",
-      "interface": "HTMLEmbedElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlembedelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLFieldSetElement": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlfieldsetelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLFieldSetElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLFieldSetElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLFieldSetElement::elements": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "elements",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-elements",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLFieldSetElement::form": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLFieldSetElement::name": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLFieldSetElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLFieldSetElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLFieldSetElement::type": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLFieldSetElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLFieldSetElement::validity": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLFieldSetElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLFieldSetElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfieldsetelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLFontElement": {
-      "spec": "html",
-      "interface": "HTMLFontElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlfontelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLFontElement::color": {
-      "spec": "html",
-      "interface": "HTMLFontElement",
-      "member": "color",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfontelement-color",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "color"
-      }
-    },
-    "Web::HTML::HTMLFontElement::face": {
-      "spec": "html",
-      "interface": "HTMLFontElement",
-      "member": "face",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfontelement-face",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "face"
-      }
-    },
-    "Web::HTML::HTMLFontElement::size": {
-      "spec": "html",
-      "interface": "HTMLFontElement",
-      "member": "size",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlfontelement-size",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "size"
-      }
-    },
-    "Web::HTML::HTMLFormElement": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlformelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLFormElement::acceptCharset": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "acceptCharset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-acceptcharset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "accept-charset"
-      }
-    },
-    "Web::HTML::HTMLFormElement::action": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "action",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-action",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "action"
-      }
-    },
-    "Web::HTML::HTMLFormElement::autocomplete": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "autocomplete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-autocomplete",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLFormElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLFormElement::elements": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "elements",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-elements",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLFormControlsCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLFormControlsCollection"
-      ]
-    },
-    "Web::HTML::HTMLFormElement::encoding": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "encoding",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-encoding",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLFormElement::enctype": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "enctype",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-enctype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLFormElement::length": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLFormElement::method": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "method",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-method",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLFormElement::name": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLFormElement::noValidate": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "noValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-novalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "novalidate"
-      }
-    },
-    "Web::HTML::HTMLFormElement::rel": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "rel",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-rel",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      }
-    },
-    "Web::HTML::HTMLFormElement::relList": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "relList",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-rellist",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLFormElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLFormElement::requestSubmit": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "requestSubmit",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-requestsubmit",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "submitter",
-          "type": "Web::HTML::HTMLElement",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLFormElement::reset": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "reset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-reset",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLFormElement::submit": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "submit",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-submit",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLFormElement::target": {
-      "spec": "html",
-      "interface": "HTMLFormElement",
-      "member": "target",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlformelement-target",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "target"
-      }
-    },
-    "Web::HTML::HTMLFrameElement": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlframeelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLFrameElement::contentDocument": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "contentDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-contentdocument",
-      "kind": "reference",
-      "type": "Web::DOM::Document",
-      "idlType": "Document?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLFrameElement::frameBorder": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "frameBorder",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-frameborder",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "frameborder"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::longDesc": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "longDesc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-longdesc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "longdesc"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::marginHeight": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "marginHeight",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-marginheight",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "marginheight"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::marginWidth": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "marginWidth",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-marginwidth",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "marginwidth"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::name": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::noResize": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "noResize",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-noresize",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "noresize"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::scrolling": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "scrolling",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-scrolling",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "scrolling"
-      }
-    },
-    "Web::HTML::HTMLFrameElement::src": {
-      "spec": "html",
-      "interface": "HTMLFrameElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframeelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLFrameSetElement": {
-      "spec": "html",
-      "interface": "HTMLFrameSetElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlframesetelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::WindowEventHandlers"
-      ]
-    },
-    "Web::HTML::HTMLFrameSetElement::cols": {
-      "spec": "html",
-      "interface": "HTMLFrameSetElement",
-      "member": "cols",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframesetelement-cols",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "cols"
-      }
-    },
-    "Web::HTML::HTMLFrameSetElement::rows": {
-      "spec": "html",
-      "interface": "HTMLFrameSetElement",
-      "member": "rows",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlframesetelement-rows",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rows"
-      }
-    },
-    "Web::HTML::HTMLHRElement": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlhrelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLHRElement::align": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhrelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLHRElement::color": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "member": "color",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhrelement-color",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "color"
-      }
-    },
-    "Web::HTML::HTMLHRElement::noShade": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "member": "noShade",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhrelement-noshade",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "noshade"
-      }
-    },
-    "Web::HTML::HTMLHRElement::size": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "member": "size",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhrelement-size",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "size"
-      }
-    },
-    "Web::HTML::HTMLHRElement::width": {
-      "spec": "html",
-      "interface": "HTMLHRElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhrelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLHeadElement": {
-      "spec": "html",
-      "interface": "HTMLHeadElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlheadelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLHeadingElement": {
-      "spec": "html",
-      "interface": "HTMLHeadingElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlheadingelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLHeadingElement::align": {
-      "spec": "html",
-      "interface": "HTMLHeadingElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlheadingelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLHtmlElement": {
-      "spec": "html",
-      "interface": "HTMLHtmlElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlhtmlelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLHtmlElement::version": {
-      "spec": "html",
-      "interface": "HTMLHtmlElement",
-      "member": "version",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhtmlelement-version",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "version"
-      }
-    },
-    "Web::HTML::HTMLHyperlinkElementUtils": {
-      "spec": "html",
-      "interface": "HTMLHyperlinkElementUtils",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlhyperlinkelementutils",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::HTMLHyperlinkElementUtils::href": {
-      "spec": "html",
-      "interface": "HTMLHyperlinkElementUtils",
-      "member": "href",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhyperlinkelementutils-href",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "href"
-      }
-    },
-    "Web::HTML::HTMLHyperlinkElementUtils::target": {
-      "spec": "html",
-      "interface": "HTMLHyperlinkElementUtils",
-      "member": "target",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlhyperlinkelementutils-target",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "target"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmliframeelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLIFrameElement::align": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::allow": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "allow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-allow",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "allow"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::allowFullscreen": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "allowFullscreen",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-allowfullscreen",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "allowfullscreen"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::contentDocument": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "contentDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-contentdocument",
-      "kind": "reference",
-      "type": "Web::DOM::Document",
-      "idlType": "Document?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLIFrameElement::frameBorder": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "frameBorder",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-frameborder",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "frameborder"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::getSVGDocument": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "getSVGDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-getsvgdocument",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Document"
-    },
-    "Web::HTML::HTMLIFrameElement::height": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-height",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::loading": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "loading",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-loading",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLIFrameElement::longDesc": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "longDesc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-longdesc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "longdesc"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::marginHeight": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "marginHeight",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-marginheight",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "marginheight"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::marginWidth": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "marginWidth",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-marginwidth",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "marginwidth"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::name": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLIFrameElement::sandbox": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "sandbox",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-sandbox",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "sandbox"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLIFrameElement::scrolling": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "scrolling",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-scrolling",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "scrolling"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::src": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLIFrameElement::srcdoc": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "srcdoc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-srcdoc",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(TrustedHTML or DOMString)",
-      "flags": [
-        "union-unmapped:(TrustedHTML or DOMString)"
-      ]
-    },
-    "Web::HTML::HTMLIFrameElement::width": {
-      "spec": "html",
-      "interface": "HTMLIFrameElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmliframeelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLImageElement": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlimageelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLImageElement::align": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLImageElement::alt": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "alt",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-alt",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "alt"
-      }
-    },
-    "Web::HTML::HTMLImageElement::border": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "border",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-border",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "border"
-      }
-    },
-    "Web::HTML::HTMLImageElement::complete": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "complete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-complete",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLImageElement::controls": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "controls",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-controls",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "controls"
-      }
-    },
-    "Web::HTML::HTMLImageElement::crossOrigin": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "crossOrigin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-crossorigin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLImageElement::currentSrc": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "currentSrc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-currentsrc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::HTML::HTMLImageElement::decode": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "decode",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-decode",
-      "kind": "operation",
-      "params": [],
-      "async": true
-    },
-    "Web::HTML::HTMLImageElement::decoding": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "decoding",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-decoding",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLImageElement::fetchPriority": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "fetchPriority",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-fetchpriority",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLImageElement::height": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLImageElement::hspace": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "hspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-hspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "hspace"
-      }
-    },
-    "Web::HTML::HTMLImageElement::isMap": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "isMap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-ismap",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "ismap"
-      }
-    },
-    "Web::HTML::HTMLImageElement::loading": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "loading",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-loading",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLImageElement::longDesc": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "longDesc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-longdesc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "longdesc"
-      }
-    },
-    "Web::HTML::HTMLImageElement::lowsrc": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "lowsrc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-lowsrc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "lowsrc"
-      }
-    },
-    "Web::HTML::HTMLImageElement::name": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLImageElement::naturalHeight": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "naturalHeight",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-naturalheight",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLImageElement::naturalWidth": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "naturalWidth",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-naturalwidth",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLImageElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLImageElement::sizes": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "sizes",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-sizes",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "sizes"
-      }
-    },
-    "Web::HTML::HTMLImageElement::src": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLImageElement::srcset": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "srcset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-srcset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "srcset"
-      }
-    },
-    "Web::HTML::HTMLImageElement::useMap": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "useMap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-usemap",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "usemap"
-      }
-    },
-    "Web::HTML::HTMLImageElement::vspace": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "vspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-vspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "vspace"
-      }
-    },
-    "Web::HTML::HTMLImageElement::width": {
-      "spec": "html",
-      "interface": "HTMLImageElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlimageelement-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLInputElement": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlinputelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement",
-        "Web::HTML::PopoverTargetAttributes"
-      ]
-    },
-    "Web::HTML::HTMLInputElement::accept": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "accept",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-accept",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "accept"
-      }
-    },
-    "Web::HTML::HTMLInputElement::align": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLInputElement::alpha": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "alpha",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-alpha",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "alpha"
-      }
-    },
-    "Web::HTML::HTMLInputElement::alt": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "alt",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-alt",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "alt"
-      }
-    },
-    "Web::HTML::HTMLInputElement::autocomplete": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "autocomplete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-autocomplete",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "autocomplete"
-      }
-    },
-    "Web::HTML::HTMLInputElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLInputElement::checked": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "checked",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-checked",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLInputElement::colorSpace": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "colorSpace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-colorspace",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLInputElement::defaultChecked": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "defaultChecked",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-defaultchecked",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "checked"
-      }
-    },
-    "Web::HTML::HTMLInputElement::defaultValue": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "defaultValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-defaultvalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLInputElement::dirName": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "dirName",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-dirname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "dirname"
-      }
-    },
-    "Web::HTML::HTMLInputElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLInputElement::form": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLInputElement::formAction": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "formAction",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-formaction",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "formaction"
-      }
-    },
-    "Web::HTML::HTMLInputElement::formEnctype": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "formEnctype",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-formenctype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLInputElement::formMethod": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "formMethod",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-formmethod",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLInputElement::formNoValidate": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "formNoValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-formnovalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "formnovalidate"
-      }
-    },
-    "Web::HTML::HTMLInputElement::formTarget": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "formTarget",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-formtarget",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "formtarget"
-      }
-    },
-    "Web::HTML::HTMLInputElement::height": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLInputElement::indeterminate": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "indeterminate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-indeterminate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLInputElement::labels": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList?",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLInputElement::list": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "list",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-list",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLDataListElement",
-      "idlType": "HTMLDataListElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLInputElement::max": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "max",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-max",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "max"
-      }
-    },
-    "Web::HTML::HTMLInputElement::maxLength": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "maxLength",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-maxlength",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "ReflectNonNegative",
-        "contentName": "maxlength"
-      }
-    },
-    "Web::HTML::HTMLInputElement::min": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "min",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-min",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "min"
-      }
-    },
-    "Web::HTML::HTMLInputElement::minLength": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "minLength",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-minlength",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "ReflectNonNegative",
-        "contentName": "minlength"
-      }
-    },
-    "Web::HTML::HTMLInputElement::multiple": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "multiple",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-multiple",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "multiple"
-      }
-    },
-    "Web::HTML::HTMLInputElement::name": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLInputElement::pattern": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "pattern",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-pattern",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "pattern"
-      }
-    },
-    "Web::HTML::HTMLInputElement::placeholder": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "placeholder",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-placeholder",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "placeholder"
-      }
-    },
-    "Web::HTML::HTMLInputElement::readOnly": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "readOnly",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-readonly",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "readonly"
-      }
-    },
-    "Web::HTML::HTMLInputElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLInputElement::required": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "required",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-required",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "required"
-      }
-    },
-    "Web::HTML::HTMLInputElement::select": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "select",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-select",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLInputElement::selectionDirection": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "selectionDirection",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-selectiondirection",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLInputElement::selectionEnd": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "selectionEnd",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-selectionend",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLInputElement::selectionStart": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "selectionStart",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-selectionstart",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLInputElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLInputElement::setRangeText": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "setRangeText",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-setrangetext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "replacement",
-          "type": "String"
-        },
-        {
-          "name": "start",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "end",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "selectionMode",
-          "type": "Web::HTML::SelectionMode",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "overloads": 2
-    },
-    "Web::HTML::HTMLInputElement::setSelectionRange": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "setSelectionRange",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-setselectionrange",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "start",
-          "type": "Natural"
-        },
-        {
-          "name": "end",
-          "type": "Natural"
-        },
-        {
-          "name": "direction",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLInputElement::showPicker": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "showPicker",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-showpicker",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLInputElement::size": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "size",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-size",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "size"
-      }
-    },
-    "Web::HTML::HTMLInputElement::src": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLInputElement::step": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "step",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-step",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "step"
-      }
-    },
-    "Web::HTML::HTMLInputElement::stepDown": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "stepDown",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-stepdown",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "n",
-          "type": "Integer",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLInputElement::stepUp": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "stepUp",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-stepup",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "n",
-          "type": "Integer",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLInputElement::type": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Prose",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLInputElement::useMap": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "useMap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-usemap",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "usemap"
-      }
-    },
-    "Web::HTML::HTMLInputElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLInputElement::validity": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLInputElement::value": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLInputElement::valueAsDate": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "valueAsDate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-valueasdate",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "object?",
-      "multiplicity": "[0..1]",
-      "flags": [
-        "object"
-      ]
-    },
-    "Web::HTML::HTMLInputElement::valueAsNumber": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "valueAsNumber",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-valueasnumber",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "unrestricted double"
-    },
-    "Web::HTML::HTMLInputElement::width": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLInputElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLInputElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlinputelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLLIElement": {
-      "spec": "html",
-      "interface": "HTMLLIElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmllielement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLLIElement::type": {
-      "spec": "html",
-      "interface": "HTMLLIElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllielement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLLIElement::value": {
-      "spec": "html",
-      "interface": "HTMLLIElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllielement-value",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLLabelElement": {
-      "spec": "html",
-      "interface": "HTMLLabelElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmllabelelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLLabelElement::control": {
-      "spec": "html",
-      "interface": "HTMLLabelElement",
-      "member": "control",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllabelelement-control",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLElement",
-      "idlType": "HTMLElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLLabelElement::form": {
-      "spec": "html",
-      "interface": "HTMLLabelElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllabelelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLLabelElement::htmlFor": {
-      "spec": "html",
-      "interface": "HTMLLabelElement",
-      "member": "htmlFor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllabelelement-htmlfor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "for"
-      }
-    },
-    "Web::HTML::HTMLLegendElement": {
-      "spec": "html",
-      "interface": "HTMLLegendElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmllegendelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLLegendElement::align": {
-      "spec": "html",
-      "interface": "HTMLLegendElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllegendelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLLegendElement::form": {
-      "spec": "html",
-      "interface": "HTMLLegendElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllegendelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLLinkElement": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmllinkelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ],
-      "flags": [
-        "external-mixin:LinkStyle"
-      ]
-    },
-    "Web::HTML::HTMLLinkElement::as": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "as",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-as",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLLinkElement::blocking": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "blocking",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-blocking",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "blocking"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLLinkElement::charset": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "charset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-charset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charset"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::crossOrigin": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "crossOrigin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-crossorigin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLLinkElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::fetchPriority": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "fetchPriority",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-fetchpriority",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLLinkElement::href": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "href",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-href",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "href"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::hreflang": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "hreflang",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-hreflang",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "hreflang"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::imageSizes": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "imageSizes",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-imagesizes",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "imagesizes"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::imageSrcset": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "imageSrcset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-imagesrcset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "imagesrcset"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::integrity": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "integrity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-integrity",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "integrity"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::media": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "media",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-media",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "media"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLLinkElement::rel": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "rel",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-rel",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::relList": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "relList",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-rellist",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rel"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLLinkElement::rev": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "rev",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-rev",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rev"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::sizes": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "sizes",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-sizes",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "sizes"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLLinkElement::target": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "target",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-target",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "target"
-      }
-    },
-    "Web::HTML::HTMLLinkElement::type": {
-      "spec": "html",
-      "interface": "HTMLLinkElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmllinkelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLMapElement": {
-      "spec": "html",
-      "interface": "HTMLMapElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmapelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMapElement::areas": {
-      "spec": "html",
-      "interface": "HTMLMapElement",
-      "member": "areas",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmapelement-areas",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLMapElement::name": {
-      "spec": "html",
-      "interface": "HTMLMapElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmapelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmarqueeelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMarqueeElement::behavior": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "behavior",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-behavior",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "behavior"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::bgColor": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "bgcolor"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::direction": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "direction",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-direction",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "direction"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::height": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-height",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::hspace": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "hspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-hspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "hspace"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::loop": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "loop",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-loop",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long"
-    },
-    "Web::HTML::HTMLMarqueeElement::scrollAmount": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "scrollAmount",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-scrollamount",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "scrollamount",
-        "default": "6"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::scrollDelay": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "scrollDelay",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-scrolldelay",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "scrolldelay",
-        "default": "85"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::start": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "start",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-start",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLMarqueeElement::stop": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "stop",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-stop",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLMarqueeElement::trueSpeed": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "trueSpeed",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-truespeed",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "truespeed"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::vspace": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "vspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-vspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "vspace"
-      }
-    },
-    "Web::HTML::HTMLMarqueeElement::width": {
-      "spec": "html",
-      "interface": "HTMLMarqueeElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmarqueeelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLMediaElement": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmediaelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "declared-non-instantiable",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMediaElement::HAVE_CURRENT_DATA": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "HAVE_CURRENT_DATA",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-have_current_data",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::HTML::HTMLMediaElement::HAVE_ENOUGH_DATA": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "HAVE_ENOUGH_DATA",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-have_enough_data",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "4"
-    },
-    "Web::HTML::HTMLMediaElement::HAVE_FUTURE_DATA": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "HAVE_FUTURE_DATA",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-have_future_data",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::HTML::HTMLMediaElement::HAVE_METADATA": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "HAVE_METADATA",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-have_metadata",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::HTML::HTMLMediaElement::HAVE_NOTHING": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "HAVE_NOTHING",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-have_nothing",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::HTML::HTMLMediaElement::NETWORK_EMPTY": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "NETWORK_EMPTY",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-network_empty",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::HTML::HTMLMediaElement::NETWORK_IDLE": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "NETWORK_IDLE",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-network_idle",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::HTML::HTMLMediaElement::NETWORK_LOADING": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "NETWORK_LOADING",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-network_loading",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::HTML::HTMLMediaElement::NETWORK_NO_SOURCE": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "NETWORK_NO_SOURCE",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-network_no_source",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::HTML::HTMLMediaElement::addTextTrack": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "addTextTrack",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-addtexttrack",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "kind",
-          "type": "Web::HTML::TextTrackKind"
-        },
-        {
-          "name": "label",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "language",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::HTML::TextTrack"
-    },
-    "Web::HTML::HTMLMediaElement::audioTracks": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "audioTracks",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-audiotracks",
-      "kind": "reference",
-      "type": "Web::HTML::AudioTrackList",
-      "idlType": "AudioTrackList",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::autoplay": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "autoplay",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-autoplay",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "autoplay"
-      }
-    },
-    "Web::HTML::HTMLMediaElement::buffered": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "buffered",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-buffered",
-      "kind": "reference",
-      "type": "Web::HTML::TimeRanges",
-      "idlType": "TimeRanges",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::canPlayType": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "canPlayType",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-canplaytype",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "type",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::CanPlayTypeResult"
-    },
-    "Web::HTML::HTMLMediaElement::controls": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "controls",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-controls",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "controls"
-      }
-    },
-    "Web::HTML::HTMLMediaElement::crossOrigin": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "crossOrigin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-crossorigin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLMediaElement::currentSrc": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "currentSrc",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-currentsrc",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::currentTime": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "currentTime",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-currenttime",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::HTMLMediaElement::defaultMuted": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "defaultMuted",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-defaultmuted",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "muted"
-      }
-    },
-    "Web::HTML::HTMLMediaElement::defaultPlaybackRate": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "defaultPlaybackRate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-defaultplaybackrate",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::HTMLMediaElement::duration": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "duration",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-duration",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "unrestricted double",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::ended": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "ended",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-ended",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::error": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "error",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-error",
-      "kind": "reference",
-      "type": "Web::HTML::MediaError",
-      "idlType": "MediaError?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::fastSeek": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "fastSeek",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-fastseek",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "time",
-          "type": "Real"
-        }
-      ]
-    },
-    "Web::HTML::HTMLMediaElement::getStartDate": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "getStartDate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-getstartdate",
-      "kind": "operation",
-      "params": [],
-      "result": "Base::Anything"
-    },
-    "Web::HTML::HTMLMediaElement::load": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "load",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-load",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLMediaElement::loading": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "loading",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-loading",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLMediaElement::loop": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "loop",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-loop",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "loop"
-      }
-    },
-    "Web::HTML::HTMLMediaElement::muted": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "muted",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-muted",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLMediaElement::networkState": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "networkState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-networkstate",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::pause": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "pause",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-pause",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLMediaElement::paused": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "paused",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-paused",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::play": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "play",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-play",
-      "kind": "operation",
-      "params": [],
-      "async": true
-    },
-    "Web::HTML::HTMLMediaElement::playbackRate": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "playbackRate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-playbackrate",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::HTMLMediaElement::played": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "played",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-played",
-      "kind": "reference",
-      "type": "Web::HTML::TimeRanges",
-      "idlType": "TimeRanges",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::preload": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "preload",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-preload",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLMediaElement::preservesPitch": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "preservesPitch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-preservespitch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLMediaElement::readyState": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "readyState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-readystate",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::seekable": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "seekable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-seekable",
-      "kind": "reference",
-      "type": "Web::HTML::TimeRanges",
-      "idlType": "TimeRanges",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::seeking": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "seeking",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-seeking",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::src": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLMediaElement::srcObject": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "srcObject",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-srcobject",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "MediaProvider?",
-      "multiplicity": "[0..1]",
-      "flags": [
-        "union-unmapped:(MediaStream or MediaSource or Blob)"
-      ]
-    },
-    "Web::HTML::HTMLMediaElement::textTracks": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "textTracks",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-texttracks",
-      "kind": "reference",
-      "type": "Web::HTML::TextTrackList",
-      "idlType": "TextTrackList",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::videoTracks": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "videoTracks",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-videotracks",
-      "kind": "reference",
-      "type": "Web::HTML::VideoTrackList",
-      "idlType": "VideoTrackList",
-      "constant": true
-    },
-    "Web::HTML::HTMLMediaElement::volume": {
-      "spec": "html",
-      "interface": "HTMLMediaElement",
-      "member": "volume",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmediaelement-volume",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::HTMLMenuElement": {
-      "spec": "html",
-      "interface": "HTMLMenuElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmenuelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMenuElement::compact": {
-      "spec": "html",
-      "interface": "HTMLMenuElement",
-      "member": "compact",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmenuelement-compact",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "compact"
-      }
-    },
-    "Web::HTML::HTMLMetaElement": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmetaelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMetaElement::content": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "member": "content",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmetaelement-content",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "content"
-      }
-    },
-    "Web::HTML::HTMLMetaElement::httpEquiv": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "member": "httpEquiv",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmetaelement-httpequiv",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "http-equiv"
-      }
-    },
-    "Web::HTML::HTMLMetaElement::media": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "member": "media",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmetaelement-media",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "media"
-      }
-    },
-    "Web::HTML::HTMLMetaElement::name": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmetaelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLMetaElement::scheme": {
-      "spec": "html",
-      "interface": "HTMLMetaElement",
-      "member": "scheme",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmetaelement-scheme",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "scheme"
-      }
-    },
-    "Web::HTML::HTMLMeterElement": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmeterelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLMeterElement::high": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "high",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-high",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "high"
-      }
-    },
-    "Web::HTML::HTMLMeterElement::labels": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLMeterElement::low": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "low",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-low",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "low"
-      }
-    },
-    "Web::HTML::HTMLMeterElement::max": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "max",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-max",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "max"
-      }
-    },
-    "Web::HTML::HTMLMeterElement::min": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "min",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-min",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "min"
-      }
-    },
-    "Web::HTML::HTMLMeterElement::optimum": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "optimum",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-optimum",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "optimum"
-      }
-    },
-    "Web::HTML::HTMLMeterElement::value": {
-      "spec": "html",
-      "interface": "HTMLMeterElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmeterelement-value",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLModElement": {
-      "spec": "html",
-      "interface": "HTMLModElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlmodelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLModElement::cite": {
-      "spec": "html",
-      "interface": "HTMLModElement",
-      "member": "cite",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmodelement-cite",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "cite"
-      }
-    },
-    "Web::HTML::HTMLModElement::dateTime": {
-      "spec": "html",
-      "interface": "HTMLModElement",
-      "member": "dateTime",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlmodelement-datetime",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "datetime"
-      }
-    },
-    "Web::HTML::HTMLOListElement": {
-      "spec": "html",
-      "interface": "HTMLOListElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlolistelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLOListElement::compact": {
-      "spec": "html",
-      "interface": "HTMLOListElement",
-      "member": "compact",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlolistelement-compact",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "compact"
-      }
-    },
-    "Web::HTML::HTMLOListElement::reversed": {
-      "spec": "html",
-      "interface": "HTMLOListElement",
-      "member": "reversed",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlolistelement-reversed",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "reversed"
-      }
-    },
-    "Web::HTML::HTMLOListElement::start": {
-      "spec": "html",
-      "interface": "HTMLOListElement",
-      "member": "start",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlolistelement-start",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "start",
-        "default": "1"
-      }
-    },
-    "Web::HTML::HTMLOListElement::type": {
-      "spec": "html",
-      "interface": "HTMLOListElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlolistelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLObjectElement": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlobjectelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLObjectElement::align": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::archive": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "archive",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-archive",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "archive"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::border": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "border",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-border",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "border"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLObjectElement::code": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "code",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-code",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "code"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::codeBase": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "codeBase",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-codebase",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "codebase"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::codeType": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "codeType",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-codetype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "codetype"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::contentDocument": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "contentDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-contentdocument",
-      "kind": "reference",
-      "type": "Web::DOM::Document",
-      "idlType": "Document?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLObjectElement::data": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "data",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-data",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "data"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::declare": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "declare",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-declare",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "declare"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::form": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLObjectElement::getSVGDocument": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "getSVGDocument",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-getsvgdocument",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::DOM::Document"
-    },
-    "Web::HTML::HTMLObjectElement::height": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-height",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::hspace": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "hspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-hspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "hspace"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::name": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLObjectElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLObjectElement::standby": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "standby",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-standby",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "standby"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::type": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::useMap": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "useMap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-usemap",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "usemap"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLObjectElement::validity": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLObjectElement::vspace": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "vspace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-vspace",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "vspace"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::width": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLObjectElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLObjectElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlobjectelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLOptGroupElement": {
-      "spec": "html",
-      "interface": "HTMLOptGroupElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmloptgroupelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLOptGroupElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLOptGroupElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptgroupelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLOptGroupElement::label": {
-      "spec": "html",
-      "interface": "HTMLOptGroupElement",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptgroupelement-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "label"
-      }
-    },
-    "Web::HTML::HTMLOptionElement": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmloptionelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLOptionElement::defaultSelected": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "defaultSelected",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-defaultselected",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "selected"
-      }
-    },
-    "Web::HTML::HTMLOptionElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLOptionElement::form": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLOptionElement::index": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "index",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-index",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "constant": true
-    },
-    "Web::HTML::HTMLOptionElement::label": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "label"
-      }
-    },
-    "Web::HTML::HTMLOptionElement::selected": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "selected",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-selected",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLOptionElement::text": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "text",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-text",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLOptionElement::value": {
-      "spec": "html",
-      "interface": "HTMLOptionElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloptionelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlorsvgormathmlelement",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::autofocus": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "member": "autofocus",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlorsvgormathmlelement-autofocus",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "autofocus"
-      }
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::blur": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "member": "blur",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlorsvgormathmlelement-blur",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::focus": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "member": "focus",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlorsvgormathmlelement-focus",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::FocusOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::nonce": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "member": "nonce",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlorsvgormathmlelement-nonce",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::tabIndex": {
-      "spec": "html",
-      "interface": "HTMLOrSVGOrMathMLElement",
-      "member": "tabIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlorsvgormathmlelement-tabindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "tabindex"
-      }
-    },
-    "Web::HTML::HTMLOutputElement": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmloutputelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLOutputElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLOutputElement::defaultValue": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "defaultValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-defaultvalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLOutputElement::form": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLOutputElement::htmlFor": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "htmlFor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-htmlfor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "for"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLOutputElement::labels": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLOutputElement::name": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLOutputElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLOutputElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLOutputElement::type": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLOutputElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLOutputElement::validity": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLOutputElement::value": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLOutputElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLOutputElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmloutputelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLParagraphElement": {
-      "spec": "html",
-      "interface": "HTMLParagraphElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlparagraphelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLParagraphElement::align": {
-      "spec": "html",
-      "interface": "HTMLParagraphElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlparagraphelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLParamElement": {
-      "spec": "html",
-      "interface": "HTMLParamElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlparamelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLParamElement::name": {
-      "spec": "html",
-      "interface": "HTMLParamElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlparamelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLParamElement::type": {
-      "spec": "html",
-      "interface": "HTMLParamElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlparamelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLParamElement::value": {
-      "spec": "html",
-      "interface": "HTMLParamElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlparamelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLParamElement::valueType": {
-      "spec": "html",
-      "interface": "HTMLParamElement",
-      "member": "valueType",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlparamelement-valuetype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "valuetype"
-      }
-    },
-    "Web::HTML::HTMLPictureElement": {
-      "spec": "html",
-      "interface": "HTMLPictureElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlpictureelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLPreElement": {
-      "spec": "html",
-      "interface": "HTMLPreElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlpreelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLPreElement::width": {
-      "spec": "html",
-      "interface": "HTMLPreElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlpreelement-width",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLProgressElement": {
-      "spec": "html",
-      "interface": "HTMLProgressElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlprogresselement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLProgressElement::labels": {
-      "spec": "html",
-      "interface": "HTMLProgressElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlprogresselement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLProgressElement::max": {
-      "spec": "html",
-      "interface": "HTMLProgressElement",
-      "member": "max",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlprogresselement-max",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::HTMLProgressElement::position": {
-      "spec": "html",
-      "interface": "HTMLProgressElement",
-      "member": "position",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlprogresselement-position",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "constant": true
-    },
-    "Web::HTML::HTMLProgressElement::value": {
-      "spec": "html",
-      "interface": "HTMLProgressElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlprogresselement-value",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "value"
-      }
-    },
-    "Web::HTML::HTMLQuoteElement": {
-      "spec": "html",
-      "interface": "HTMLQuoteElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlquoteelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLQuoteElement::cite": {
-      "spec": "html",
-      "interface": "HTMLQuoteElement",
-      "member": "cite",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlquoteelement-cite",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "cite"
-      }
-    },
-    "Web::HTML::HTMLScriptElement": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlscriptelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ],
-      "flags": [
-        "static:supports"
-      ]
-    },
-    "Web::HTML::HTMLScriptElement::async": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "async",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-async",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLScriptElement::blocking": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "blocking",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-blocking",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "blocking"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLScriptElement::charset": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "charset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-charset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charset"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::crossOrigin": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "crossOrigin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-crossorigin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString?",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::HTMLScriptElement::defer": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "defer",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-defer",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "defer"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::event": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "event",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-event",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "event"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::fetchPriority": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "fetchPriority",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-fetchpriority",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLScriptElement::htmlFor": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "htmlFor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-htmlfor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "for"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::integrity": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "integrity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-integrity",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "integrity"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::noModule": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "noModule",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-nomodule",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "nomodule"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::referrerPolicy": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "referrerPolicy",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-referrerpolicy",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLScriptElement::src": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLScriptElement::text": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "text",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-text",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLScriptElement::type": {
-      "spec": "html",
-      "interface": "HTMLScriptElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlscriptelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLSelectElement": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlselectelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::add": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "add",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-add",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "element",
-          "type": "Web::HTML::HTMLElement"
-        },
-        {
-          "name": "before",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::autocomplete": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "autocomplete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-autocomplete",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "autocomplete"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLSelectElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::form": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLSelectElement::item": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "item",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-item",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Natural"
-        }
-      ],
-      "result": "Web::HTML::HTMLOptionElement",
-      "flags": [
-        "special:getter"
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::labels": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::length": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLSelectElement::multiple": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "multiple",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-multiple",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "multiple"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::name": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::namedItem": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "namedItem",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-nameditem",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "name",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::HTMLOptionElement"
-    },
-    "Web::HTML::HTMLSelectElement::options": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "options",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-options",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLOptionsCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLOptionsCollection"
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLSelectElement::required": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "required",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-required",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "required"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::selectedIndex": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "selectedIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-selectedindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long"
-    },
-    "Web::HTML::HTMLSelectElement::selectedOptions": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "selectedOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-selectedoptions",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLSelectElement::showPicker": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "showPicker",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-showpicker",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLSelectElement::size": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "size",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-size",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "size",
-        "default": "0"
-      }
-    },
-    "Web::HTML::HTMLSelectElement::type": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLSelectElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLSelectElement::validity": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLSelectElement::value": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLSelectElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLSelectElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlselectelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLSelectedContentElement": {
-      "spec": "html",
-      "interface": "HTMLSelectedContentElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlselectedcontentelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLSlotElement": {
-      "spec": "html",
-      "interface": "HTMLSlotElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlslotelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLSlotElement::assign": {
-      "spec": "html",
-      "interface": "HTMLSlotElement",
-      "member": "assign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlslotelement-assign",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "nodes",
-          "type": "Web::DOM::Node",
-          "multiplicity": "[0..*]",
-          "variadic": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLSlotElement::assignedElements": {
-      "spec": "html",
-      "interface": "HTMLSlotElement",
-      "member": "assignedElements",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlslotelement-assignedelements",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::AssignedNodesOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Element"
-    },
-    "Web::HTML::HTMLSlotElement::assignedNodes": {
-      "spec": "html",
-      "interface": "HTMLSlotElement",
-      "member": "assignedNodes",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlslotelement-assignednodes",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "options",
-          "type": "Web::HTML::AssignedNodesOptions",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::DOM::Node"
-    },
-    "Web::HTML::HTMLSlotElement::name": {
-      "spec": "html",
-      "interface": "HTMLSlotElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlslotelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLSourceElement": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlsourceelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLSourceElement::height": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::media": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "media",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-media",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "media"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::sizes": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "sizes",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-sizes",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "sizes"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::src": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::srcset": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "srcset",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-srcset",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "srcset"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::type": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLSourceElement::width": {
-      "spec": "html",
-      "interface": "HTMLSourceElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlsourceelement-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLSpanElement": {
-      "spec": "html",
-      "interface": "HTMLSpanElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlspanelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLStyleElement": {
-      "spec": "html",
-      "interface": "HTMLStyleElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlstyleelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ],
-      "flags": [
-        "external-mixin:LinkStyle"
-      ]
-    },
-    "Web::HTML::HTMLStyleElement::blocking": {
-      "spec": "html",
-      "interface": "HTMLStyleElement",
-      "member": "blocking",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlstyleelement-blocking",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMTokenList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "blocking"
-      },
-      "flags": [
-        "wrapper:DOMTokenList"
-      ]
-    },
-    "Web::HTML::HTMLStyleElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLStyleElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlstyleelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::HTMLStyleElement::media": {
-      "spec": "html",
-      "interface": "HTMLStyleElement",
-      "member": "media",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlstyleelement-media",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "media"
-      }
-    },
-    "Web::HTML::HTMLStyleElement::type": {
-      "spec": "html",
-      "interface": "HTMLStyleElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlstyleelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLTableCaptionElement": {
-      "spec": "html",
-      "interface": "HTMLTableCaptionElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltablecaptionelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableCaptionElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableCaptionElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecaptionelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltablecellelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableCellElement::abbr": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "abbr",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-abbr",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "abbr"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::axis": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "axis",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-axis",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "axis"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::bgColor": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "bgcolor"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::cellIndex": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "cellIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-cellindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "constant": true
-    },
-    "Web::HTML::HTMLTableCellElement::ch": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "ch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-ch",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "char"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::chOff": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "chOff",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-choff",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charoff"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::colSpan": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "colSpan",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-colspan",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "colspan",
-        "range": [
-          "1",
-          "1000"
-        ],
-        "default": "1"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::headers": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "headers",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-headers",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "headers"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::height": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-height",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::noWrap": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "noWrap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-nowrap",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "nowrap"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::rowSpan": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "rowSpan",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-rowspan",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rowspan",
-        "range": [
-          "0",
-          "65534"
-        ],
-        "default": "1"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::scope": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "scope",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-scope",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTableCellElement::vAlign": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "vAlign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-valign",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "valign"
-      }
-    },
-    "Web::HTML::HTMLTableCellElement::width": {
-      "spec": "html",
-      "interface": "HTMLTableCellElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecellelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLTableColElement": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltablecolelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableColElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableColElement::ch": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "ch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-ch",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "char"
-      }
-    },
-    "Web::HTML::HTMLTableColElement::chOff": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "chOff",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-choff",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charoff"
-      }
-    },
-    "Web::HTML::HTMLTableColElement::span": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "span",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-span",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "span",
-        "range": [
-          "1",
-          "1000"
-        ],
-        "default": "1"
-      }
-    },
-    "Web::HTML::HTMLTableColElement::vAlign": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "vAlign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-valign",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "valign"
-      }
-    },
-    "Web::HTML::HTMLTableColElement::width": {
-      "spec": "html",
-      "interface": "HTMLTableColElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablecolelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLTableElement": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltableelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableElement::bgColor": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "bgcolor"
-      }
-    },
-    "Web::HTML::HTMLTableElement::border": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "border",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-border",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "border"
-      }
-    },
-    "Web::HTML::HTMLTableElement::caption": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "caption",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-caption",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLTableCaptionElement",
-      "idlType": "HTMLTableCaptionElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLTableElement::cellPadding": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "cellPadding",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-cellpadding",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "cellpadding"
-      }
-    },
-    "Web::HTML::HTMLTableElement::cellSpacing": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "cellSpacing",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-cellspacing",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "cellspacing"
-      }
-    },
-    "Web::HTML::HTMLTableElement::createCaption": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "createCaption",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-createcaption",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::HTMLTableCaptionElement"
-    },
-    "Web::HTML::HTMLTableElement::createTBody": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "createTBody",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-createtbody",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::HTMLTableSectionElement"
-    },
-    "Web::HTML::HTMLTableElement::createTFoot": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "createTFoot",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-createtfoot",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::HTMLTableSectionElement"
-    },
-    "Web::HTML::HTMLTableElement::createTHead": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "createTHead",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-createthead",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::HTMLTableSectionElement"
-    },
-    "Web::HTML::HTMLTableElement::deleteCaption": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "deleteCaption",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-deletecaption",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLTableElement::deleteRow": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "deleteRow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-deleterow",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer"
-        }
-      ]
-    },
-    "Web::HTML::HTMLTableElement::deleteTFoot": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "deleteTFoot",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-deletetfoot",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLTableElement::deleteTHead": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "deleteTHead",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-deletethead",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLTableElement::frame": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "frame",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-frame",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "frame"
-      }
-    },
-    "Web::HTML::HTMLTableElement::insertRow": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "insertRow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-insertrow",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::HTML::HTMLTableRowElement"
-    },
-    "Web::HTML::HTMLTableElement::rows": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "rows",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-rows",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLTableElement::rules": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "rules",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-rules",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "rules"
-      }
-    },
-    "Web::HTML::HTMLTableElement::summary": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "summary",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-summary",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "summary"
-      }
-    },
-    "Web::HTML::HTMLTableElement::tBodies": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "tBodies",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-tbodies",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLTableElement::tFoot": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "tFoot",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-tfoot",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLTableSectionElement",
-      "idlType": "HTMLTableSectionElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLTableElement::tHead": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "tHead",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-thead",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLTableSectionElement",
-      "idlType": "HTMLTableSectionElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLTableElement::width": {
-      "spec": "html",
-      "interface": "HTMLTableElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltableelement-width",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HTMLTableRowElement": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltablerowelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableRowElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableRowElement::bgColor": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "bgColor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-bgcolor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "bgcolor"
-      }
-    },
-    "Web::HTML::HTMLTableRowElement::cells": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "cells",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-cells",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLTableRowElement::ch": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "ch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-ch",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "char"
-      }
-    },
-    "Web::HTML::HTMLTableRowElement::chOff": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "chOff",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-choff",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charoff"
-      }
-    },
-    "Web::HTML::HTMLTableRowElement::deleteCell": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "deleteCell",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-deletecell",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer"
-        }
-      ]
-    },
-    "Web::HTML::HTMLTableRowElement::insertCell": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "insertCell",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-insertcell",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::HTML::HTMLTableCellElement"
-    },
-    "Web::HTML::HTMLTableRowElement::rowIndex": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "rowIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-rowindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "constant": true
-    },
-    "Web::HTML::HTMLTableRowElement::sectionRowIndex": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "sectionRowIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-sectionrowindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "constant": true
-    },
-    "Web::HTML::HTMLTableRowElement::vAlign": {
-      "spec": "html",
-      "interface": "HTMLTableRowElement",
-      "member": "vAlign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablerowelement-valign",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "valign"
-      }
-    },
-    "Web::HTML::HTMLTableSectionElement": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltablesectionelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTableSectionElement::align": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "align",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-align",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "align"
-      }
-    },
-    "Web::HTML::HTMLTableSectionElement::ch": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "ch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-ch",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "char"
-      }
-    },
-    "Web::HTML::HTMLTableSectionElement::chOff": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "chOff",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-choff",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "charoff"
-      }
-    },
-    "Web::HTML::HTMLTableSectionElement::deleteRow": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "deleteRow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-deleterow",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer"
-        }
-      ]
-    },
-    "Web::HTML::HTMLTableSectionElement::insertRow": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "insertRow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-insertrow",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Integer",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Web::HTML::HTMLTableRowElement"
-    },
-    "Web::HTML::HTMLTableSectionElement::rows": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "rows",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-rows",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "HTMLCollection",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:HTMLCollection"
-      ]
-    },
-    "Web::HTML::HTMLTableSectionElement::vAlign": {
-      "spec": "html",
-      "interface": "HTMLTableSectionElement",
-      "member": "vAlign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltablesectionelement-valign",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "valign"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltemplateelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTemplateElement::content": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "content",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-content",
-      "kind": "reference",
-      "type": "Web::DOM::DocumentFragment",
-      "idlType": "DocumentFragment",
-      "derived": true
-    },
-    "Web::HTML::HTMLTemplateElement::htmlFor": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "htmlFor",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-htmlfor",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "for"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootClonable": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootClonable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootclonable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shadowrootclonable"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootCustomElementRegistry": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootCustomElementRegistry",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootcustomelementregistry",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shadowrootcustomelementregistry"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootDelegatesFocus": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootDelegatesFocus",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootdelegatesfocus",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shadowrootdelegatesfocus"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootMode": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootMode",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootmode",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootSerializable": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootSerializable",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootserializable",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "shadowrootserializable"
-      }
-    },
-    "Web::HTML::HTMLTemplateElement::shadowRootSlotAssignment": {
-      "spec": "html",
-      "interface": "HTMLTemplateElement",
-      "member": "shadowRootSlotAssignment",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltemplateelement-shadowrootslotassignment",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTextAreaElement": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltextareaelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTextAreaElement::autocomplete": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "autocomplete",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-autocomplete",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "ReflectSetter",
-        "contentName": "autocomplete"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::checkValidity": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "checkValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-checkvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLTextAreaElement::cols": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "cols",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-cols",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLTextAreaElement::defaultValue": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "defaultValue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-defaultvalue",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTextAreaElement::dirName": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "dirName",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-dirname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "dirname"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::disabled": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-disabled",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "disabled"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::form": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "form",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-form",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLFormElement",
-      "idlType": "HTMLFormElement?",
-      "multiplicity": "[0..1]",
-      "derived": true
-    },
-    "Web::HTML::HTMLTextAreaElement::labels": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "labels",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-labels",
-      "kind": "reference",
-      "type": "Web::DOM::Node",
-      "idlType": "NodeList",
-      "multiplicity": "[0..*]",
-      "ordered": true,
-      "derived": true,
-      "flags": [
-        "wrapper:NodeList"
-      ]
-    },
-    "Web::HTML::HTMLTextAreaElement::maxLength": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "maxLength",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-maxlength",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "ReflectNonNegative",
-        "contentName": "maxlength"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::minLength": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "minLength",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-minlength",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "reflection": {
-        "kind": "ReflectNonNegative",
-        "contentName": "minlength"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::name": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "name",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-name",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "name"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::placeholder": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "placeholder",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-placeholder",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "placeholder"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::readOnly": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "readOnly",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-readonly",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "readonly"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::reportValidity": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "reportValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-reportvalidity",
-      "kind": "operation",
-      "params": [],
-      "result": "Boolean"
-    },
-    "Web::HTML::HTMLTextAreaElement::required": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "required",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-required",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "required"
-      }
-    },
-    "Web::HTML::HTMLTextAreaElement::rows": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "rows",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-rows",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLTextAreaElement::select": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "select",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-select",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::HTMLTextAreaElement::selectionDirection": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "selectionDirection",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-selectiondirection",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTextAreaElement::selectionEnd": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "selectionEnd",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-selectionend",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLTextAreaElement::selectionStart": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "selectionStart",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-selectionstart",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long"
-    },
-    "Web::HTML::HTMLTextAreaElement::setCustomValidity": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "setCustomValidity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-setcustomvalidity",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "error",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::HTMLTextAreaElement::setRangeText": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "setRangeText",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-setrangetext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "replacement",
-          "type": "String"
-        },
-        {
-          "name": "start",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "end",
-          "type": "Natural",
-          "multiplicity": "[0..1]",
-          "optional": true
-        },
-        {
-          "name": "selectionMode",
-          "type": "Web::HTML::SelectionMode",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "overloads": 2
-    },
-    "Web::HTML::HTMLTextAreaElement::setSelectionRange": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "setSelectionRange",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-setselectionrange",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "start",
-          "type": "Natural"
-        },
-        {
-          "name": "end",
-          "type": "Natural"
-        },
-        {
-          "name": "direction",
-          "type": "String",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ]
-    },
-    "Web::HTML::HTMLTextAreaElement::textLength": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "textLength",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-textlength",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLTextAreaElement::type": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLTextAreaElement::validationMessage": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "validationMessage",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-validationmessage",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::HTMLTextAreaElement::validity": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "validity",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-validity",
-      "kind": "reference",
-      "type": "Web::HTML::ValidityState",
-      "idlType": "ValidityState",
-      "constant": true
-    },
-    "Web::HTML::HTMLTextAreaElement::value": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "value",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-value",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTextAreaElement::willValidate": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "willValidate",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-willvalidate",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::HTMLTextAreaElement::wrap": {
-      "spec": "html",
-      "interface": "HTMLTextAreaElement",
-      "member": "wrap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltextareaelement-wrap",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "wrap"
-      }
-    },
-    "Web::HTML::HTMLTimeElement": {
-      "spec": "html",
-      "interface": "HTMLTimeElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltimeelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTimeElement::dateTime": {
-      "spec": "html",
-      "interface": "HTMLTimeElement",
-      "member": "dateTime",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltimeelement-datetime",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "datetime"
-      }
-    },
-    "Web::HTML::HTMLTitleElement": {
-      "spec": "html",
-      "interface": "HTMLTitleElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltitleelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTitleElement::text": {
-      "spec": "html",
-      "interface": "HTMLTitleElement",
-      "member": "text",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltitleelement-text",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTrackElement": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmltrackelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLTrackElement::ERROR": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "ERROR",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-error",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::HTML::HTMLTrackElement::LOADED": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "LOADED",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-loaded",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::HTML::HTMLTrackElement::LOADING": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "LOADING",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-loading",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::HTML::HTMLTrackElement::NONE": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "NONE",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-none",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "0"
-    },
-    "Web::HTML::HTMLTrackElement::default": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "default",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-default",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "default"
-      }
-    },
-    "Web::HTML::HTMLTrackElement::kind": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "kind",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-kind",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::HTMLTrackElement::label": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "label"
-      }
-    },
-    "Web::HTML::HTMLTrackElement::readyState": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "readyState",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-readystate",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::HTML::HTMLTrackElement::src": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "src",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-src",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "src"
-      }
-    },
-    "Web::HTML::HTMLTrackElement::srclang": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "srclang",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-srclang",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "srclang"
-      }
-    },
-    "Web::HTML::HTMLTrackElement::track": {
-      "spec": "html",
-      "interface": "HTMLTrackElement",
-      "member": "track",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmltrackelement-track",
-      "kind": "reference",
-      "type": "Web::HTML::TextTrack",
-      "idlType": "TextTrack",
-      "constant": true
-    },
-    "Web::HTML::HTMLUListElement": {
-      "spec": "html",
-      "interface": "HTMLUListElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlulistelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLUListElement::compact": {
-      "spec": "html",
-      "interface": "HTMLUListElement",
-      "member": "compact",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlulistelement-compact",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "compact"
-      }
-    },
-    "Web::HTML::HTMLUListElement::type": {
-      "spec": "html",
-      "interface": "HTMLUListElement",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlulistelement-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HTMLUnknownElement": {
-      "spec": "html",
-      "interface": "HTMLUnknownElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlunknownelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLElement"
-      ]
-    },
-    "Web::HTML::HTMLVideoElement": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "url": "https://html.spec.whatwg.org/multipage/#htmlvideoelement",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "element-interface",
-      "generalizations": [
-        "Web::HTML::HTMLMediaElement"
-      ]
-    },
-    "Web::HTML::HTMLVideoElement::height": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "height"
-      }
-    },
-    "Web::HTML::HTMLVideoElement::playsInline": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "playsInline",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-playsinline",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "playsinline"
-      }
-    },
-    "Web::HTML::HTMLVideoElement::poster": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "poster",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-poster",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "reflection": {
-        "kind": "ReflectURL",
-        "contentName": "poster"
-      }
-    },
-    "Web::HTML::HTMLVideoElement::videoHeight": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "videoHeight",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-videoheight",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLVideoElement::videoWidth": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "videoWidth",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-videowidth",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::HTMLVideoElement::width": {
-      "spec": "html",
-      "interface": "HTMLVideoElement",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-htmlvideoelement-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "width"
-      }
-    },
-    "Web::HTML::HyperlinkElementUtils": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "url": "https://html.spec.whatwg.org/multipage/#hyperlinkelementutils",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::HyperlinkElementUtils::hash": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "hash",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-hash",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::host": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "host",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-host",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::hostname": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "hostname",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-hostname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::hreflang": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "hreflang",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-hreflang",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "hreflang"
-      }
-    },
-    "Web::HTML::HyperlinkElementUtils::origin": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "origin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-origin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::HTML::HyperlinkElementUtils::password": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "password",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-password",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::pathname": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "pathname",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-pathname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::port": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "port",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-port",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::protocol": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "protocol",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-protocol",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::search": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "search",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-search",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::HyperlinkElementUtils::type": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "type"
-      }
-    },
-    "Web::HTML::HyperlinkElementUtils::username": {
-      "spec": "html",
-      "interface": "HyperlinkElementUtils",
-      "member": "username",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-hyperlinkelementutils-username",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::ImageBitmap": {
-      "spec": "html",
-      "interface": "ImageBitmap",
-      "url": "https://html.spec.whatwg.org/multipage/#imagebitmap",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::ImageBitmap::close": {
-      "spec": "html",
-      "interface": "ImageBitmap",
-      "member": "close",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-imagebitmap-close",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::ImageBitmap::height": {
-      "spec": "html",
-      "interface": "ImageBitmap",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::ImageBitmap::width": {
-      "spec": "html",
-      "interface": "ImageBitmap",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::ImageEncodeOptions": {
-      "spec": "html",
-      "interface": "ImageEncodeOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#imageencodeoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::ImageEncodeOptions::quality": {
-      "spec": "html",
-      "interface": "ImageEncodeOptions",
-      "member": "quality",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-imageencodeoptions-quality",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "unrestricted double",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::ImageEncodeOptions::type": {
-      "spec": "html",
-      "interface": "ImageEncodeOptions",
-      "member": "type",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-imageencodeoptions-type",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "multiplicity": "[0..1]",
-      "default": "image/png"
-    },
-    "Web::HTML::Location": {
-      "spec": "html",
-      "interface": "Location",
-      "url": "https://html.spec.whatwg.org/multipage/#location",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::Location::ancestorOrigins": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "ancestorOrigins",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-ancestororigins",
-      "kind": "reference",
-      "type": "Web::HTML::DOMStringList",
-      "idlType": "DOMStringList",
-      "constant": true
-    },
-    "Web::HTML::Location::assign": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "assign",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-assign",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "url",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::Location::hash": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "hash",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-hash",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::host": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "host",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-host",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::hostname": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "hostname",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-hostname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::href": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "href",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-href",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::origin": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "origin",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-origin",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString",
-      "constant": true
-    },
-    "Web::HTML::Location::pathname": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "pathname",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-pathname",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::port": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "port",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-port",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::protocol": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "protocol",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-protocol",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::Location::reload": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "reload",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-reload",
-      "kind": "operation",
-      "params": []
-    },
-    "Web::HTML::Location::replace": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "replace",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-replace",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "url",
-          "type": "String"
-        }
-      ]
-    },
-    "Web::HTML::Location::search": {
-      "spec": "html",
-      "interface": "Location",
-      "member": "search",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-location-search",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "USVString"
-    },
-    "Web::HTML::MediaError": {
-      "spec": "html",
-      "interface": "MediaError",
-      "url": "https://html.spec.whatwg.org/multipage/#mediaerror",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::MediaError::MEDIA_ERR_ABORTED": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "MEDIA_ERR_ABORTED",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-media_err_aborted",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "1"
-    },
-    "Web::HTML::MediaError::MEDIA_ERR_DECODE": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "MEDIA_ERR_DECODE",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-media_err_decode",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "3"
-    },
-    "Web::HTML::MediaError::MEDIA_ERR_NETWORK": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "MEDIA_ERR_NETWORK",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-media_err_network",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "2"
-    },
-    "Web::HTML::MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "MEDIA_ERR_SRC_NOT_SUPPORTED",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-media_err_src_not_supported",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true,
-      "value": "4"
-    },
-    "Web::HTML::MediaError::code": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "code",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-code",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned short",
-      "constant": true
-    },
-    "Web::HTML::MediaError::message": {
-      "spec": "html",
-      "interface": "MediaError",
-      "member": "message",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-mediaerror-message",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::OffscreenCanvas": {
-      "spec": "html",
-      "interface": "OffscreenCanvas",
-      "url": "https://html.spec.whatwg.org/multipage/#offscreencanvas",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "constructor",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::OffscreenCanvas::getContext": {
-      "spec": "html",
-      "interface": "OffscreenCanvas",
-      "member": "getContext",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-getcontext",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "contextId",
-          "type": "Web::HTML::OffscreenRenderingContextId"
-        },
-        {
-          "name": "options",
-          "type": "Base::Anything",
-          "multiplicity": "[0..1]",
-          "optional": true
-        }
-      ],
-      "result": "Base::Anything"
-    },
-    "Web::HTML::OffscreenCanvas::height": {
-      "spec": "html",
-      "interface": "OffscreenCanvas",
-      "member": "height",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-height",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long long"
-    },
-    "Web::HTML::OffscreenCanvas::transferToImageBitmap": {
-      "spec": "html",
-      "interface": "OffscreenCanvas",
-      "member": "transferToImageBitmap",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-transfertoimagebitmap",
-      "kind": "operation",
-      "params": [],
-      "result": "Web::HTML::ImageBitmap"
-    },
-    "Web::HTML::OffscreenCanvas::width": {
-      "spec": "html",
-      "interface": "OffscreenCanvas",
-      "member": "width",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-width",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long long"
-    },
-    "Web::HTML::OffscreenRenderingContextId": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "url": "https://html.spec.whatwg.org/multipage/#offscreenrenderingcontextid",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::OffscreenRenderingContextId::2d": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "member": "2d",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreenrenderingcontextid-2d"
-    },
-    "Web::HTML::OffscreenRenderingContextId::bitmaprenderer": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "member": "bitmaprenderer",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreenrenderingcontextid-bitmaprenderer"
-    },
-    "Web::HTML::OffscreenRenderingContextId::webgl": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "member": "webgl",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreenrenderingcontextid-webgl"
-    },
-    "Web::HTML::OffscreenRenderingContextId::webgl2": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "member": "webgl2",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreenrenderingcontextid-webgl2"
-    },
-    "Web::HTML::OffscreenRenderingContextId::webgpu": {
-      "spec": "html",
-      "interface": "OffscreenRenderingContextId",
-      "member": "webgpu",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-offscreenrenderingcontextid-webgpu"
-    },
-    "Web::HTML::PopoverTargetAttributes": {
-      "spec": "html",
-      "interface": "PopoverTargetAttributes",
-      "url": "https://html.spec.whatwg.org/multipage/#popovertargetattributes",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    },
-    "Web::HTML::PopoverTargetAttributes::popoverTargetAction": {
-      "spec": "html",
-      "interface": "PopoverTargetAttributes",
-      "member": "popoverTargetAction",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-popovertargetattributes-popovertargetaction",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::PopoverTargetAttributes::popoverTargetElement": {
-      "spec": "html",
-      "interface": "PopoverTargetAttributes",
-      "member": "popoverTargetElement",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-popovertargetattributes-popovertargetelement",
-      "kind": "reference",
-      "type": "Web::DOM::Element",
-      "idlType": "Element?",
-      "multiplicity": "[0..1]",
-      "derived": true,
-      "reflection": {
-        "kind": "Reflect",
-        "contentName": "popovertarget"
-      }
-    },
-    "Web::HTML::SelectionMode": {
-      "spec": "html",
-      "interface": "SelectionMode",
-      "url": "https://html.spec.whatwg.org/multipage/#selectionmode",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::SelectionMode::end": {
-      "spec": "html",
-      "interface": "SelectionMode",
-      "member": "end",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-selectionmode-end"
-    },
-    "Web::HTML::SelectionMode::preserve": {
-      "spec": "html",
-      "interface": "SelectionMode",
-      "member": "preserve",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-selectionmode-preserve"
-    },
-    "Web::HTML::SelectionMode::select": {
-      "spec": "html",
-      "interface": "SelectionMode",
-      "member": "select",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-selectionmode-select"
-    },
-    "Web::HTML::SelectionMode::start": {
-      "spec": "html",
-      "interface": "SelectionMode",
-      "member": "start",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-selectionmode-start"
-    },
-    "Web::HTML::SetHTMLOptions": {
-      "spec": "html",
-      "interface": "SetHTMLOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#sethtmloptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::SetHTMLOptions::sanitizer": {
-      "spec": "html",
-      "interface": "SetHTMLOptions",
-      "member": "sanitizer",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-sethtmloptions-sanitizer",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(Sanitizer or SanitizerConfig or SanitizerPresets)",
-      "multiplicity": "[0..1]",
-      "default": "default",
-      "flags": [
-        "union-unmapped:(Sanitizer or SanitizerConfig or SanitizerPresets)"
-      ]
-    },
-    "Web::HTML::SetHTMLUnsafeOptions": {
-      "spec": "html",
-      "interface": "SetHTMLUnsafeOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#sethtmlunsafeoptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::SetHTMLUnsafeOptions::runScripts": {
-      "spec": "html",
-      "interface": "SetHTMLUnsafeOptions",
-      "member": "runScripts",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-sethtmlunsafeoptions-runscripts",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::SetHTMLUnsafeOptions::sanitizer": {
-      "spec": "html",
-      "interface": "SetHTMLUnsafeOptions",
-      "member": "sanitizer",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-sethtmlunsafeoptions-sanitizer",
-      "kind": "attribute",
-      "type": "Base::Anything",
-      "idlType": "(Sanitizer or SanitizerConfig or SanitizerPresets)",
-      "multiplicity": "[0..1]",
-      "default": "{}",
-      "flags": [
-        "union-unmapped:(Sanitizer or SanitizerConfig or SanitizerPresets)"
-      ]
-    },
-    "Web::HTML::ShowPopoverOptions": {
-      "spec": "html",
-      "interface": "ShowPopoverOptions",
-      "url": "https://html.spec.whatwg.org/multipage/#showpopoveroptions",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::ShowPopoverOptions::source": {
-      "spec": "html",
-      "interface": "ShowPopoverOptions",
-      "member": "source",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-showpopoveroptions-source",
-      "kind": "reference",
-      "type": "Web::HTML::HTMLElement",
-      "idlType": "HTMLElement",
-      "multiplicity": "[0..1]"
-    },
-    "Web::HTML::TextTrack": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "url": "https://html.spec.whatwg.org/multipage/#texttrack",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::TextTrack::activeCues": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "activeCues",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-activecues",
-      "kind": "reference",
-      "type": "Web::HTML::TextTrackCueList",
-      "idlType": "TextTrackCueList?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::addCue": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "addCue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-addcue",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "cue",
-          "type": "Web::HTML::TextTrackCue"
-        }
-      ]
-    },
-    "Web::HTML::TextTrack::cues": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "cues",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-cues",
-      "kind": "reference",
-      "type": "Web::HTML::TextTrackCueList",
-      "idlType": "TextTrackCueList?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::id": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "id",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-id",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::inBandMetadataTrackDispatchType": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "inBandMetadataTrackDispatchType",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-inbandmetadatatrackdispatchtype",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::kind": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "kind",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-kind",
-      "kind": "attribute",
-      "type": "Web::HTML::TextTrackKind",
-      "idlType": "TextTrackKind",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::label": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::language": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "language",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-language",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::TextTrack::mode": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "mode",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-mode",
-      "kind": "attribute",
-      "type": "Web::HTML::TextTrackMode",
-      "idlType": "TextTrackMode"
-    },
-    "Web::HTML::TextTrack::removeCue": {
-      "spec": "html",
-      "interface": "TextTrack",
-      "member": "removeCue",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrack-removecue",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "cue",
-          "type": "Web::HTML::TextTrackCue"
-        }
-      ]
-    },
-    "Web::HTML::TextTrackCue": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "url": "https://html.spec.whatwg.org/multipage/#texttrackcue",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::TextTrackCue::endTime": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "member": "endTime",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcue-endtime",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "unrestricted double"
-    },
-    "Web::HTML::TextTrackCue::id": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "member": "id",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcue-id",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString"
-    },
-    "Web::HTML::TextTrackCue::pauseOnExit": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "member": "pauseOnExit",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcue-pauseonexit",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::TextTrackCue::startTime": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "member": "startTime",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcue-starttime",
-      "kind": "attribute",
-      "type": "Real",
-      "idlType": "double"
-    },
-    "Web::HTML::TextTrackCue::track": {
-      "spec": "html",
-      "interface": "TextTrackCue",
-      "member": "track",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcue-track",
-      "kind": "reference",
-      "type": "Web::HTML::TextTrack",
-      "idlType": "TextTrack?",
-      "multiplicity": "[0..1]",
-      "constant": true
-    },
-    "Web::HTML::TextTrackCueList": {
-      "spec": "html",
-      "interface": "TextTrackCueList",
-      "url": "https://html.spec.whatwg.org/multipage/#texttrackcuelist",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::TextTrackCueList::getCueById": {
-      "spec": "html",
-      "interface": "TextTrackCueList",
-      "member": "getCueById",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcuelist-getcuebyid",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "id",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::TextTrackCue"
-    },
-    "Web::HTML::TextTrackCueList::length": {
-      "spec": "html",
-      "interface": "TextTrackCueList",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackcuelist-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::TextTrackKind": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "url": "https://html.spec.whatwg.org/multipage/#texttrackkind",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::TextTrackKind::captions": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "member": "captions",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackkind-captions"
-    },
-    "Web::HTML::TextTrackKind::chapters": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "member": "chapters",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackkind-chapters"
-    },
-    "Web::HTML::TextTrackKind::descriptions": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "member": "descriptions",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackkind-descriptions"
-    },
-    "Web::HTML::TextTrackKind::metadata": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "member": "metadata",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackkind-metadata"
-    },
-    "Web::HTML::TextTrackKind::subtitles": {
-      "spec": "html",
-      "interface": "TextTrackKind",
-      "member": "subtitles",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackkind-subtitles"
-    },
-    "Web::HTML::TextTrackList": {
-      "spec": "html",
-      "interface": "TextTrackList",
-      "url": "https://html.spec.whatwg.org/multipage/#texttracklist",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::TextTrackList::getTrackById": {
-      "spec": "html",
-      "interface": "TextTrackList",
-      "member": "getTrackById",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttracklist-gettrackbyid",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "id",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::TextTrack"
-    },
-    "Web::HTML::TextTrackList::length": {
-      "spec": "html",
-      "interface": "TextTrackList",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttracklist-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::TextTrackMode": {
-      "spec": "html",
-      "interface": "TextTrackMode",
-      "url": "https://html.spec.whatwg.org/multipage/#texttrackmode",
-      "idlKind": "enum",
-      "kind": "enum"
-    },
-    "Web::HTML::TextTrackMode::disabled": {
-      "spec": "html",
-      "interface": "TextTrackMode",
-      "member": "disabled",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackmode-disabled"
-    },
-    "Web::HTML::TextTrackMode::hidden": {
-      "spec": "html",
-      "interface": "TextTrackMode",
-      "member": "hidden",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackmode-hidden"
-    },
-    "Web::HTML::TextTrackMode::showing": {
-      "spec": "html",
-      "interface": "TextTrackMode",
-      "member": "showing",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-texttrackmode-showing"
-    },
-    "Web::HTML::TimeRanges": {
-      "spec": "html",
-      "interface": "TimeRanges",
-      "url": "https://html.spec.whatwg.org/multipage/#timeranges",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::TimeRanges::end": {
-      "spec": "html",
-      "interface": "TimeRanges",
-      "member": "end",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-timeranges-end",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Natural"
-        }
-      ],
-      "result": "Real"
-    },
-    "Web::HTML::TimeRanges::length": {
-      "spec": "html",
-      "interface": "TimeRanges",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-timeranges-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::TimeRanges::start": {
-      "spec": "html",
-      "interface": "TimeRanges",
-      "member": "start",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-timeranges-start",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "index",
-          "type": "Natural"
-        }
-      ],
-      "result": "Real"
-    },
-    "Web::HTML::ValidityState": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "url": "https://html.spec.whatwg.org/multipage/#validitystate",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::ValidityState::badInput": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "badInput",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-badinput",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::customError": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "customError",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-customerror",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::patternMismatch": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "patternMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-patternmismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::rangeOverflow": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "rangeOverflow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-rangeoverflow",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::rangeUnderflow": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "rangeUnderflow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-rangeunderflow",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::stepMismatch": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "stepMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-stepmismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::tooLong": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "tooLong",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-toolong",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::tooShort": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "tooShort",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-tooshort",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::typeMismatch": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "typeMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-typemismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::valid": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "valid",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-valid",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityState::valueMissing": {
-      "spec": "html",
-      "interface": "ValidityState",
-      "member": "valueMissing",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystate-valuemissing",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "constant": true
-    },
-    "Web::HTML::ValidityStateFlags": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "url": "https://html.spec.whatwg.org/multipage/#validitystateflags",
-      "idlKind": "dictionary",
-      "kind": "attribute"
-    },
-    "Web::HTML::ValidityStateFlags::badInput": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "badInput",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-badinput",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::customError": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "customError",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-customerror",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::patternMismatch": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "patternMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-patternmismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::rangeOverflow": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "rangeOverflow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-rangeoverflow",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::rangeUnderflow": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "rangeUnderflow",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-rangeunderflow",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::stepMismatch": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "stepMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-stepmismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::tooLong": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "tooLong",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-toolong",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::tooShort": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "tooShort",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-tooshort",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::typeMismatch": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "typeMismatch",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-typemismatch",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::ValidityStateFlags::valueMissing": {
-      "spec": "html",
-      "interface": "ValidityStateFlags",
-      "member": "valueMissing",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-validitystateflags-valuemissing",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean",
-      "multiplicity": "[0..1]",
-      "default": "false"
-    },
-    "Web::HTML::VideoTrack": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "url": "https://html.spec.whatwg.org/multipage/#videotrack",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created"
-    },
-    "Web::HTML::VideoTrack::id": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "member": "id",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotrack-id",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::VideoTrack::kind": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "member": "kind",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotrack-kind",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::VideoTrack::label": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "member": "label",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotrack-label",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::VideoTrack::language": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "member": "language",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotrack-language",
-      "kind": "attribute",
-      "type": "String",
-      "idlType": "DOMString",
-      "constant": true
-    },
-    "Web::HTML::VideoTrack::selected": {
-      "spec": "html",
-      "interface": "VideoTrack",
-      "member": "selected",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotrack-selected",
-      "kind": "attribute",
-      "type": "Boolean",
-      "idlType": "boolean"
-    },
-    "Web::HTML::VideoTrackList": {
-      "spec": "html",
-      "interface": "VideoTrackList",
-      "url": "https://html.spec.whatwg.org/multipage/#videotracklist",
-      "idlKind": "interface",
-      "kind": "part",
-      "abstract": "platform-created",
-      "generalizations": [
-        "Web::DOM::EventTarget"
-      ]
-    },
-    "Web::HTML::VideoTrackList::getTrackById": {
-      "spec": "html",
-      "interface": "VideoTrackList",
-      "member": "getTrackById",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotracklist-gettrackbyid",
-      "kind": "operation",
-      "params": [
-        {
-          "name": "id",
-          "type": "String"
-        }
-      ],
-      "result": "Web::HTML::VideoTrack"
-    },
-    "Web::HTML::VideoTrackList::length": {
-      "spec": "html",
-      "interface": "VideoTrackList",
-      "member": "length",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotracklist-length",
-      "kind": "attribute",
-      "type": "Natural",
-      "idlType": "unsigned long",
-      "constant": true
-    },
-    "Web::HTML::VideoTrackList::selectedIndex": {
-      "spec": "html",
-      "interface": "VideoTrackList",
-      "member": "selectedIndex",
-      "url": "https://html.spec.whatwg.org/multipage/#dom-videotracklist-selectedindex",
-      "kind": "attribute",
-      "type": "Integer",
-      "idlType": "long",
-      "constant": true
-    },
-    "Web::HTML::WindowEventHandlers": {
-      "spec": "html",
-      "interface": "WindowEventHandlers",
-      "url": "https://html.spec.whatwg.org/multipage/#windoweventhandlers",
-      "idlKind": "interface mixin",
-      "kind": "part",
-      "abstract": "mixin"
-    }
-  },
-  "omitted": {
-    "Web::DOM::Document::defaultView": {
-      "reason": "unknown-type:WindowProxy",
-      "idlType": "WindowProxy?"
-    },
-    "Web::DOM::Document::onreadystatechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::DOM::Document::onvisibilitychange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::DOM::Document::open": {
-      "reason": "unknown-type:WindowProxy"
-    },
-    "Web::DOM::NodeIterator::filter": {
-      "reason": "callback",
-      "idlType": "NodeFilter?"
-    },
-    "Web::DOM::ShadowRoot::onslotchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::DOM::TreeWalker::filter": {
-      "reason": "callback",
-      "idlType": "NodeFilter?"
-    },
-    "Web::HTML::AudioTrackList::onaddtrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::AudioTrackList::onchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::AudioTrackList::onremovetrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::BlobCallback::": {
-      "reason": "external-type:Blob"
-    },
-    "Web::HTML::CanPlayTypeResult::": {
-      "reason": "empty-enum-value"
-    },
-    "Web::HTML::CustomElementRegistry::get": {
-      "reason": "undefined"
-    },
-    "Web::HTML::GlobalEventHandlers::onabort": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onauxclick": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onbeforeinput": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onbeforematch": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onbeforetoggle": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onblur": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncancel": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncanplay": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncanplaythrough": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onclick": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onclose": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncommand": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncontextlost": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncontextmenu": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncontextrestored": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncopy": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncuechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oncut": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondblclick": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondrag": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondragend": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondragenter": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondragleave": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondragover": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondragstart": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondrop": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ondurationchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onemptied": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onended": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onerror": {
-      "reason": "callback",
-      "idlType": "OnErrorEventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onfocus": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onformdata": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oninput": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::oninvalid": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onkeydown": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onkeypress": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onkeyup": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onload": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onloadeddata": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onloadedmetadata": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onloadstart": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmousedown": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmouseenter": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmouseleave": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmousemove": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmouseout": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmouseover": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onmouseup": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onpaste": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onpause": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onplay": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onplaying": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onprogress": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onratechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onreset": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onresize": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onscroll": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onscrollend": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onsecuritypolicyviolation": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onseeked": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onseeking": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onselect": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onslotchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onstalled": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onsubmit": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onsuspend": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ontimeupdate": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::ontoggle": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onvolumechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwaiting": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwebkitanimationend": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwebkitanimationiteration": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwebkitanimationstart": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwebkittransitionend": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::GlobalEventHandlers::onwheel": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::HTMLFrameElement::contentWindow": {
-      "reason": "unknown-type:WindowProxy",
-      "idlType": "WindowProxy?"
-    },
-    "Web::HTML::HTMLIFrameElement::contentWindow": {
-      "reason": "unknown-type:WindowProxy",
-      "idlType": "WindowProxy?"
-    },
-    "Web::HTML::HTMLInputElement::files": {
-      "reason": "external-type:FileList",
-      "idlType": "FileList?"
-    },
-    "Web::HTML::HTMLObjectElement::contentWindow": {
-      "reason": "unknown-type:WindowProxy",
-      "idlType": "WindowProxy?"
-    },
-    "Web::HTML::HTMLOrSVGOrMathMLElement::dataset": {
-      "reason": "record",
-      "idlType": "DOMStringMap"
-    },
-    "Web::HTML::HTMLSelectElement::remove": {
-      "reason": "inherited-member:ChildNode"
-    },
-    "Web::HTML::OffscreenCanvas::convertToBlob": {
-      "reason": "external-type:Blob"
-    },
-    "Web::HTML::OffscreenCanvas::oncontextlost": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::OffscreenCanvas::oncontextrestored": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrack::oncuechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrackCue::onenter": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrackCue::onexit": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrackList::onaddtrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrackList::onchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::TextTrackList::onremovetrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::VideoTrackList::onaddtrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::VideoTrackList::onchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::VideoTrackList::onremovetrack": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onafterprint": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onbeforeprint": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onbeforeunload": {
-      "reason": "callback",
-      "idlType": "OnBeforeUnloadEventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onhashchange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onlanguagechange": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onmessage": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onmessageerror": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onoffline": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::ononline": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onpagehide": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onpagereveal": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onpageshow": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onpageswap": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onpopstate": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onrejectionhandled": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onstorage": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onunhandledrejection": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    },
-    "Web::HTML::WindowEventHandlers::onunload": {
-      "reason": "callback",
-      "idlType": "EventHandler"
-    }
-  }
-}
diff --git a/local-packages/Web.sysml b/local-packages/Web.sysml
deleted file mode 100644
index 206ab2d..0000000
--- a/local-packages/Web.sysml
+++ /dev/null
@@ -1,2753 +0,0 @@
-library package Web {
-    doc /* Web platform library. GENERATED - do not edit; regenerate with the websysml generator.
-       Source: the standards' machine-readable WebIDL corpus, @webref/idl 3.83.0, @webref/elements 2.8.0.
-       Packages: DOM (dom, css-shadow); HTML (html); HTML::Elements (html element metadata).
-       Conventions: unsigned integers -> Natural, signed -> Integer, floating point -> Real, strings -> String;
-       T? -> [0..1]; sequence/FrozenArray/ObservableArray/NodeList/HTMLCollection/NamedNodeMap -> T[0..*] ordered (wrapper dropped);
-       readonly -> constant; tree-node references (Node/Attr and their collections) are derived navigation the
-       toolkit constructs from ownership; mixins are abstract definitions with multiple specialization;
-       operations are nested action definitions (in parameters, out result; Promise<T> -> T, recorded async;
-       overloads merged; an operation repeating the name of an inherited one is left to the inherited
-       declaration and recorded in the sidecar); callbacks are action definitions; record<K, V> is an
-       entry attribute definition.
-       Element kinds fix localName once and specialize the element's interface. Provenance: the sidecar.
-       */
-
-    package DOM {
-        private import ScalarValues::*;
-
-        abstract part def AbstractRange {
-            derived ref part startContainer : Node;
-            constant attribute startOffset : Natural;
-            derived ref part endContainer : Node;
-            constant attribute endOffset : Natural;
-            constant attribute collapsed : Boolean;
-        }
-
-        abstract part def ChildNode {
-            action def before {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def 'after' {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def replaceWith {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def remove;
-        }
-
-        part def DOMImplementation {
-            action def createDocumentType {
-                in name : String;
-                in publicId : String;
-                in systemId : String;
-                out result : DocumentType;
-            }
-            action def createDocument {
-                in namespace : String[0..1];
-                in qualifiedName : String;
-                in doctype : DocumentType[0..1];
-                out result : XMLDocument;
-            }
-            action def createHTMLDocument {
-                in title : String[0..1];
-                out result : Document;
-            }
-            action def hasFeature {
-                out result : Boolean;
-            }
-        }
-
-        abstract part def DocumentOrShadowRoot {
-            constant ref part customElementRegistry : HTML::CustomElementRegistry[0..1];
-            derived ref part activeElement : Element[0..1];
-        }
-
-        part def Event {
-            constant attribute type : String;
-            constant ref part target : EventTarget[0..1];
-            constant ref part srcElement : EventTarget[0..1];
-            constant ref part currentTarget : EventTarget[0..1];
-            constant attribute NONE : Natural = 0;
-            constant attribute CAPTURING_PHASE : Natural = 1;
-            constant attribute AT_TARGET : Natural = 2;
-            constant attribute BUBBLING_PHASE : Natural = 3;
-            constant attribute eventPhase : Natural;
-            attribute cancelBubble : Boolean;
-            constant attribute bubbles : Boolean;
-            constant attribute cancelable : Boolean;
-            attribute returnValue : Boolean;
-            constant attribute defaultPrevented : Boolean;
-            constant attribute composed : Boolean;
-            constant attribute isTrusted : Boolean;
-            constant attribute timeStamp : Real;
-            action def composedPath {
-                out result : EventTarget[0..*] ordered;
-            }
-            action def stopPropagation;
-            action def stopImmediatePropagation;
-            action def preventDefault;
-            action def initEvent {
-                in type : String;
-                in bubbles : Boolean[0..1];
-                in cancelable : Boolean[0..1];
-            }
-        }
-
-        action def EventListener {
-            in 'event' : Event;
-        }
-
-        part def EventTarget {
-            action def addEventListener {
-                in type : String;
-                in callback : EventListener[0..1];
-                in options : Base::Anything[0..1];
-            }
-            action def removeEventListener {
-                in type : String;
-                in callback : EventListener[0..1];
-                in options : Base::Anything[0..1];
-            }
-            action def dispatchEvent {
-                in 'event' : Event;
-                out result : Boolean;
-            }
-        }
-
-        attribute def GetRootNodeOptions {
-            attribute composed : Boolean[0..1] default = false;
-        }
-
-        abstract part def Node :> EventTarget {
-            constant attribute ELEMENT_NODE : Natural = 1;
-            constant attribute ATTRIBUTE_NODE : Natural = 2;
-            constant attribute TEXT_NODE : Natural = 3;
-            constant attribute CDATA_SECTION_NODE : Natural = 4;
-            constant attribute ENTITY_REFERENCE_NODE : Natural = 5;
-            constant attribute ENTITY_NODE : Natural = 6;
-            constant attribute PROCESSING_INSTRUCTION_NODE : Natural = 7;
-            constant attribute COMMENT_NODE : Natural = 8;
-            constant attribute DOCUMENT_NODE : Natural = 9;
-            constant attribute DOCUMENT_TYPE_NODE : Natural = 10;
-            constant attribute DOCUMENT_FRAGMENT_NODE : Natural = 11;
-            constant attribute NOTATION_NODE : Natural = 12;
-            constant attribute nodeType : Natural;
-            constant attribute nodeName : String;
-            constant attribute baseURI : String;
-            constant attribute isConnected : Boolean;
-            derived ref part ownerDocument : Document[0..1];
-            derived ref part parentNode : Node[0..1];
-            derived ref part parentElement : Element[0..1];
-            derived ref part childNodes : Node[0..*] ordered;
-            derived ref part firstChild : Node[0..1];
-            derived ref part lastChild : Node[0..1];
-            derived ref part previousSibling : Node[0..1];
-            derived ref part nextSibling : Node[0..1];
-            attribute nodeValue : String[0..1];
-            attribute textContent : String[0..1];
-            constant attribute DOCUMENT_POSITION_DISCONNECTED : Natural = 1;
-            constant attribute DOCUMENT_POSITION_PRECEDING : Natural = 2;
-            constant attribute DOCUMENT_POSITION_FOLLOWING : Natural = 4;
-            constant attribute DOCUMENT_POSITION_CONTAINS : Natural = 8;
-            constant attribute DOCUMENT_POSITION_CONTAINED_BY : Natural = 16;
-            constant attribute DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : Natural = 32;
-            action def getRootNode {
-                in options : GetRootNodeOptions[0..1];
-                out result : Node;
-            }
-            action def hasChildNodes {
-                out result : Boolean;
-            }
-            action def normalize;
-            action def cloneNode {
-                in subtree : Boolean[0..1];
-                out result : Node;
-            }
-            action def isEqualNode {
-                in otherNode : Node[0..1];
-                out result : Boolean;
-            }
-            action def isSameNode {
-                in otherNode : Node[0..1];
-                out result : Boolean;
-            }
-            action def compareDocumentPosition {
-                in other : Node;
-                out result : Natural;
-            }
-            action def contains {
-                in other : Node[0..1];
-                out result : Boolean;
-            }
-            action def lookupPrefix {
-                in namespace : String[0..1];
-                out result : String[0..1];
-            }
-            action def lookupNamespaceURI {
-                in prefix : String[0..1];
-                out result : String[0..1];
-            }
-            action def isDefaultNamespace {
-                in namespace : String[0..1];
-                out result : Boolean;
-            }
-            action def insertBefore {
-                in node : Node;
-                in child : Node[0..1];
-                out result : Node;
-            }
-            action def appendChild {
-                in node : Node;
-                out result : Node;
-            }
-            action def replaceChild {
-                in node : Node;
-                in child : Node;
-                out result : Node;
-            }
-            action def removeChild {
-                in child : Node;
-                out result : Node;
-            }
-        }
-
-        part def Attr :> Node {
-            constant attribute namespaceURI : String[0..1];
-            constant attribute prefix : String[0..1];
-            constant attribute localName : String;
-            constant attribute name : String;
-            attribute value : String;
-            derived ref part ownerElement : Element[0..1];
-            constant attribute specified : Boolean;
-        }
-
-        part def DocumentType :> Node, ChildNode {
-            constant attribute name : String;
-            constant attribute publicId : String;
-            constant attribute systemId : String;
-        }
-
-        action def NodeFilter {
-            in node : Node;
-            out result : Natural;
-        }
-
-        part def NodeIterator {
-            derived ref part root : Node;
-            derived ref part referenceNode : Node;
-            constant attribute pointerBeforeReferenceNode : Boolean;
-            constant attribute whatToShow : Natural;
-            action def nextNode {
-                out result : Node[0..1];
-            }
-            action def previousNode {
-                out result : Node[0..1];
-            }
-            action def detach;
-        }
-
-        abstract part def NonDocumentTypeChildNode {
-            derived ref part previousElementSibling : Element[0..1];
-            derived ref part nextElementSibling : Element[0..1];
-        }
-
-        abstract part def CharacterData :> Node, NonDocumentTypeChildNode, ChildNode {
-            attribute data : String;
-            constant attribute length : Natural;
-            action def substringData {
-                in offset : Natural;
-                in count : Natural;
-                out result : String;
-            }
-            action def appendData {
-                in data : String;
-            }
-            action def insertData {
-                in offset : Natural;
-                in data : String;
-            }
-            action def deleteData {
-                in offset : Natural;
-                in count : Natural;
-            }
-            action def replaceData {
-                in offset : Natural;
-                in count : Natural;
-                in data : String;
-            }
-        }
-
-        part def Comment :> CharacterData;
-
-        abstract part def NonElementParentNode {
-            action def getElementById {
-                in elementId : String;
-                out result : Element[0..1];
-            }
-        }
-
-        abstract part def ParentNode {
-            derived ref part children : Element[0..*] ordered;
-            derived ref part firstElementChild : Element[0..1];
-            derived ref part lastElementChild : Element[0..1];
-            constant attribute childElementCount : Natural;
-            action def prepend {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def append {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def replaceChildren {
-                in nodes : Base::Anything[0..*] ordered;
-            }
-            action def moveBefore {
-                in node : Node;
-                in child : Node[0..1];
-            }
-            action def querySelector {
-                in selectors : String;
-                out result : Element[0..1];
-            }
-            action def querySelectorAll {
-                in selectors : String;
-                out result : Node[0..*] ordered;
-            }
-        }
-
-        part def DocumentFragment :> Node, NonElementParentNode, ParentNode;
-
-        part def ProcessingInstruction :> CharacterData {
-            constant attribute target : String;
-            action def hasAttributes {
-                out result : Boolean;
-            }
-            action def getAttributeNames {
-                out result : String[0..*] ordered;
-            }
-            action def getAttribute {
-                in name : String;
-                out result : String[0..1];
-            }
-            action def setAttribute {
-                in name : String;
-                in value : String;
-            }
-            action def removeAttribute {
-                in name : String;
-            }
-            action def toggleAttribute {
-                in name : String;
-                in force : Boolean[0..1];
-                out result : Boolean;
-            }
-            action def hasAttribute {
-                in name : String;
-                out result : Boolean;
-            }
-        }
-
-        part def Range :> AbstractRange {
-            derived ref part commonAncestorContainer : Node;
-            constant attribute START_TO_START : Natural = 0;
-            constant attribute START_TO_END : Natural = 1;
-            constant attribute END_TO_END : Natural = 2;
-            constant attribute END_TO_START : Natural = 3;
-            action def setStart {
-                in node : Node;
-                in offset : Natural;
-            }
-            action def setEnd {
-                in node : Node;
-                in offset : Natural;
-            }
-            action def setStartBefore {
-                in node : Node;
-            }
-            action def setStartAfter {
-                in node : Node;
-            }
-            action def setEndBefore {
-                in node : Node;
-            }
-            action def setEndAfter {
-                in node : Node;
-            }
-            action def collapse {
-                in toStart : Boolean[0..1];
-            }
-            action def selectNode {
-                in node : Node;
-            }
-            action def selectNodeContents {
-                in node : Node;
-            }
-            action def compareBoundaryPoints {
-                in how : Natural;
-                in sourceRange : Range;
-                out result : Integer;
-            }
-            action def deleteContents;
-            action def extractContents {
-                out result : DocumentFragment;
-            }
-            action def cloneContents {
-                out result : DocumentFragment;
-            }
-            action def insertNode {
-                in node : Node;
-            }
-            action def surroundContents {
-                in newParent : Node;
-            }
-            action def cloneRange {
-                out result : Range;
-            }
-            action def detach;
-            action def isPointInRange {
-                in node : Node;
-                in offset : Natural;
-                out result : Boolean;
-            }
-            action def comparePoint {
-                in node : Node;
-                in offset : Natural;
-                out result : Integer;
-            }
-            action def intersectsNode {
-                in node : Node;
-                out result : Boolean;
-            }
-            action def createContextualFragment {
-                in string : Base::Anything;
-                out result : DocumentFragment;
-            }
-        }
-
-        part def ShadowRoot :> DocumentFragment, DocumentOrShadowRoot {
-            constant attribute mode : ShadowRootMode;
-            constant attribute delegatesFocus : Boolean;
-            constant attribute serializable : Boolean;
-            constant attribute slotAssignment : SlotAssignmentMode;
-            constant attribute clonable : Boolean;
-            derived ref part host : Element;
-            attribute innerHTML : Base::DataValue;
-            action def setHTML {
-                in html : String;
-                in options : HTML::SetHTMLOptions[0..1];
-            }
-            action def setHTMLUnsafe {
-                in html : Base::Anything;
-                in options : HTML::SetHTMLUnsafeOptions[0..1];
-            }
-            action def getHTML {
-                in options : HTML::GetHTMLOptions[0..1];
-                out result : String;
-            }
-        }
-
-        attribute def ShadowRootInit {
-            attribute mode : ShadowRootMode;
-            attribute delegatesFocus : Boolean[0..1] default = false;
-            attribute serializable : Boolean[0..1] default = false;
-            attribute slotAssignment : SlotAssignmentMode[0..1] default = "named";
-            attribute clonable : Boolean[0..1] default = false;
-            ref part customElementRegistry : HTML::CustomElementRegistry[0..1];
-        }
-
-        enum def ShadowRootMode {
-            open;
-            closed;
-        }
-
-        enum def SlotAssignmentMode {
-            manual;
-            named;
-        }
-
-        abstract part def Slottable {
-            derived ref part assignedSlot : HTML::HTMLSlotElement[0..1];
-        }
-
-        part def Element :> Node, ParentNode, NonDocumentTypeChildNode, ChildNode, Slottable {
-            constant attribute namespaceURI : String[0..1];
-            constant attribute prefix : String[0..1];
-            constant attribute localName : String;
-            constant attribute tagName : String;
-            attribute id : String;
-            attribute className : String;
-            attribute classList : String[0..*] ordered;
-            attribute slot : String;
-            derived ref part attributes : Attr[0..*] ordered;
-            derived ref part shadowRoot : ShadowRoot[0..1];
-            constant ref part customElementRegistry : HTML::CustomElementRegistry[0..1];
-            attribute 'part' : String[0..*] ordered;
-            attribute innerHTML : Base::DataValue;
-            attribute outerHTML : Base::DataValue;
-            action def hasAttributes {
-                out result : Boolean;
-            }
-            action def getAttributeNames {
-                out result : String[0..*] ordered;
-            }
-            action def getAttribute {
-                in qualifiedName : String;
-                out result : String[0..1];
-            }
-            action def getAttributeNS {
-                in namespace : String[0..1];
-                in localName : String;
-                out result : String[0..1];
-            }
-            action def setAttribute {
-                in qualifiedName : String;
-                in value : Base::Anything;
-            }
-            action def setAttributeNS {
-                in namespace : String[0..1];
-                in qualifiedName : String;
-                in value : Base::Anything;
-            }
-            action def removeAttribute {
-                in qualifiedName : String;
-            }
-            action def removeAttributeNS {
-                in namespace : String[0..1];
-                in localName : String;
-            }
-            action def toggleAttribute {
-                in qualifiedName : String;
-                in force : Boolean[0..1];
-                out result : Boolean;
-            }
-            action def hasAttribute {
-                in qualifiedName : String;
-                out result : Boolean;
-            }
-            action def hasAttributeNS {
-                in namespace : String[0..1];
-                in localName : String;
-                out result : Boolean;
-            }
-            action def getAttributeNode {
-                in qualifiedName : String;
-                out result : Attr[0..1];
-            }
-            action def getAttributeNodeNS {
-                in namespace : String[0..1];
-                in localName : String;
-                out result : Attr[0..1];
-            }
-            action def setAttributeNode {
-                in attr : Attr;
-                out result : Attr[0..1];
-            }
-            action def setAttributeNodeNS {
-                in attr : Attr;
-                out result : Attr[0..1];
-            }
-            action def removeAttributeNode {
-                in attr : Attr;
-                out result : Attr;
-            }
-            action def attachShadow {
-                in init : ShadowRootInit;
-                out result : ShadowRoot;
-            }
-            action def closest {
-                in selectors : String;
-                out result : Element[0..1];
-            }
-            action def matches {
-                in selectors : String;
-                out result : Boolean;
-            }
-            action def webkitMatchesSelector {
-                in selectors : String;
-                out result : Boolean;
-            }
-            action def getElementsByTagName {
-                in qualifiedName : String;
-                out result : Element[0..*] ordered;
-            }
-            action def getElementsByTagNameNS {
-                in namespace : String[0..1];
-                in localName : String;
-                out result : Element[0..*] ordered;
-            }
-            action def getElementsByClassName {
-                in classNames : String;
-                out result : Element[0..*] ordered;
-            }
-            action def insertAdjacentElement {
-                in where : String;
-                in element : Element;
-                out result : Element[0..1];
-            }
-            action def insertAdjacentText {
-                in where : String;
-                in data : String;
-            }
-            action def setHTML {
-                in html : String;
-                in options : HTML::SetHTMLOptions[0..1];
-            }
-            action def setHTMLUnsafe {
-                in html : Base::Anything;
-                in options : HTML::SetHTMLUnsafeOptions[0..1];
-            }
-            action def getHTML {
-                in options : HTML::GetHTMLOptions[0..1];
-                out result : String;
-            }
-            action def insertAdjacentHTML {
-                in position : String;
-                in string : Base::Anything;
-            }
-        }
-
-        part def Text :> CharacterData, Slottable {
-            constant attribute wholeText : String;
-            action def splitText {
-                in offset : Natural;
-                out result : Text;
-            }
-        }
-
-        part def CDATASection :> Text;
-
-        part def TreeWalker {
-            derived ref part root : Node;
-            constant attribute whatToShow : Natural;
-            derived ref part currentNode : Node;
-            action def parentNode {
-                out result : Node[0..1];
-            }
-            action def firstChild {
-                out result : Node[0..1];
-            }
-            action def lastChild {
-                out result : Node[0..1];
-            }
-            action def previousSibling {
-                out result : Node[0..1];
-            }
-            action def nextSibling {
-                out result : Node[0..1];
-            }
-            action def previousNode {
-                out result : Node[0..1];
-            }
-            action def nextNode {
-                out result : Node[0..1];
-            }
-        }
-
-        abstract part def XPathEvaluatorBase {
-            action def createExpression {
-                in expression : String;
-                in resolver : XPathNSResolver[0..1];
-                out result : XPathExpression;
-            }
-            action def createNSResolver {
-                in nodeResolver : Node;
-                out result : Node;
-            }
-            action def evaluate {
-                in expression : String;
-                in contextNode : Node;
-                in resolver : XPathNSResolver[0..1];
-                in type : Natural[0..1];
-                in result : XPathResult[0..1];
-                out 'return' : XPathResult;
-            }
-        }
-
-        part def Document :> Node, NonElementParentNode, DocumentOrShadowRoot, ParentNode, XPathEvaluatorBase, HTML::GlobalEventHandlers {
-            constant ref part implementation : DOMImplementation;
-            constant attribute URL : String;
-            constant attribute documentURI : String;
-            constant attribute compatMode : String;
-            constant attribute characterSet : String;
-            constant attribute charset : String;
-            constant attribute inputEncoding : String;
-            constant attribute contentType : String;
-            derived ref part doctype : DocumentType[0..1];
-            derived ref part documentElement : Element[0..1];
-            ref part location : HTML::Location[0..1];
-            attribute domain : String;
-            constant attribute referrer : String;
-            attribute cookie : String;
-            constant attribute lastModified : String;
-            constant attribute readyState : HTML::DocumentReadyState;
-            attribute title : String;
-            attribute dir : String;
-            derived ref part body : HTML::HTMLElement[0..1];
-            derived ref part head : HTML::HTMLHeadElement[0..1];
-            derived ref part images : Element[0..*] ordered;
-            derived ref part embeds : Element[0..*] ordered;
-            derived ref part plugins : Element[0..*] ordered;
-            derived ref part links : Element[0..*] ordered;
-            derived ref part forms : Element[0..*] ordered;
-            derived ref part scripts : Element[0..*] ordered;
-            derived ref part currentScript : Element[0..1];
-            attribute designMode : String;
-            constant attribute hidden : Boolean;
-            constant attribute visibilityState : HTML::DocumentVisibilityState;
-            attribute fgColor : String;
-            attribute linkColor : String;
-            attribute vlinkColor : String;
-            attribute alinkColor : String;
-            attribute bgColor : String;
-            derived ref part anchors : Element[0..*] ordered;
-            derived ref part applets : Element[0..*] ordered;
-            derived ref part 'all' : Element[0..*] ordered;
-            action def getElementsByTagName {
-                in qualifiedName : String;
-                out result : Element[0..*] ordered;
-            }
-            action def getElementsByTagNameNS {
-                in namespace : String[0..1];
-                in localName : String;
-                out result : Element[0..*] ordered;
-            }
-            action def getElementsByClassName {
-                in classNames : String;
-                out result : Element[0..*] ordered;
-            }
-            action def createElement {
-                in localName : String;
-                in options : Base::Anything[0..1];
-                out result : Element;
-            }
-            action def createElementNS {
-                in namespace : String[0..1];
-                in qualifiedName : String;
-                in options : Base::Anything[0..1];
-                out result : Element;
-            }
-            action def createDocumentFragment {
-                out result : DocumentFragment;
-            }
-            action def createTextNode {
-                in data : String;
-                out result : Text;
-            }
-            action def createCDATASection {
-                in data : String;
-                out result : CDATASection;
-            }
-            action def createComment {
-                in data : String;
-                out result : Comment;
-            }
-            action def createProcessingInstruction {
-                in target : String;
-                in data : String;
-                out result : ProcessingInstruction;
-            }
-            action def importNode {
-                in node : Node;
-                in options : Base::Anything[0..1];
-                out result : Node;
-            }
-            action def adoptNode {
-                in node : Node;
-                out result : Node;
-            }
-            action def createAttribute {
-                in localName : String;
-                out result : Attr;
-            }
-            action def createAttributeNS {
-                in namespace : String[0..1];
-                in qualifiedName : String;
-                out result : Attr;
-            }
-            action def createEvent {
-                in 'interface' : String;
-                out result : Event;
-            }
-            action def createRange {
-                out result : Range;
-            }
-            action def createNodeIterator {
-                in root : Node;
-                in whatToShow : Natural[0..1];
-                in 'filter' : NodeFilter[0..1];
-                out result : NodeIterator;
-            }
-            action def createTreeWalker {
-                in root : Node;
-                in whatToShow : Natural[0..1];
-                in 'filter' : NodeFilter[0..1];
-                out result : TreeWalker;
-            }
-            action def getElementsByName {
-                in elementName : String;
-                out result : Node[0..*] ordered;
-            }
-            action def close;
-            action def write {
-                in text : Base::Anything[0..*] ordered;
-            }
-            action def writeln {
-                in text : Base::Anything[0..*] ordered;
-            }
-            action def hasFocus {
-                out result : Boolean;
-            }
-            action def execCommand {
-                in commandId : String;
-                in showUI : Boolean[0..1];
-                in value : String[0..1];
-                out result : Boolean;
-            }
-            action def queryCommandEnabled {
-                in commandId : String;
-                out result : Boolean;
-            }
-            action def queryCommandIndeterm {
-                in commandId : String;
-                out result : Boolean;
-            }
-            action def queryCommandState {
-                in commandId : String;
-                out result : Boolean;
-            }
-            action def queryCommandSupported {
-                in commandId : String;
-                out result : Boolean;
-            }
-            action def queryCommandValue {
-                in commandId : String;
-                out result : String;
-            }
-            action def clear;
-            action def captureEvents;
-            action def releaseEvents;
-        }
-
-        part def XMLDocument :> Document;
-
-        part def XPathExpression {
-            action def evaluate {
-                in contextNode : Node;
-                in type : Natural[0..1];
-                in result : XPathResult[0..1];
-                out 'return' : XPathResult;
-            }
-        }
-
-        action def XPathNSResolver {
-            in prefix : String[0..1];
-            out result : String[0..1];
-        }
-
-        part def XPathResult {
-            constant attribute ANY_TYPE : Natural = 0;
-            constant attribute NUMBER_TYPE : Natural = 1;
-            constant attribute STRING_TYPE : Natural = 2;
-            constant attribute BOOLEAN_TYPE : Natural = 3;
-            constant attribute UNORDERED_NODE_ITERATOR_TYPE : Natural = 4;
-            constant attribute ORDERED_NODE_ITERATOR_TYPE : Natural = 5;
-            constant attribute UNORDERED_NODE_SNAPSHOT_TYPE : Natural = 6;
-            constant attribute ORDERED_NODE_SNAPSHOT_TYPE : Natural = 7;
-            constant attribute ANY_UNORDERED_NODE_TYPE : Natural = 8;
-            constant attribute FIRST_ORDERED_NODE_TYPE : Natural = 9;
-            constant attribute resultType : Natural;
-            constant attribute numberValue : Real;
-            constant attribute stringValue : String;
-            constant attribute booleanValue : Boolean;
-            derived ref part singleNodeValue : Node[0..1];
-            constant attribute invalidIteratorState : Boolean;
-            constant attribute snapshotLength : Natural;
-            action def iterateNext {
-                out result : Node[0..1];
-            }
-            action def snapshotItem {
-                in index : Natural;
-                out result : Node[0..1];
-            }
-        }
-    }
-
-    package HTML {
-        private import ScalarValues::*;
-        private import DOM::*;
-
-        attribute def AssignedNodesOptions {
-            attribute flatten : Boolean[0..1] default = false;
-        }
-
-        part def AudioTrack {
-            constant attribute id : String;
-            constant attribute kind : String;
-            constant attribute label : String;
-            constant attribute 'language' : String;
-            attribute enabled : Boolean;
-        }
-
-        part def AudioTrackList :> EventTarget {
-            constant attribute length : Natural;
-            action def getTrackById {
-                in id : String;
-                out result : AudioTrack[0..1];
-            }
-        }
-
-        action def BlobCallback;
-
-        enum def CanPlayTypeResult {
-            maybe;
-            probably;
-        }
-
-        action def CustomElementConstructor {
-            out result : HTMLElement;
-        }
-
-        part def CustomElementRegistry {
-            action def define {
-                in name : String;
-                in constructor : CustomElementConstructor;
-                in options : ElementDefinitionOptions[0..1];
-            }
-            action def getName {
-                in constructor : CustomElementConstructor;
-                out result : String[0..1];
-            }
-            action def whenDefined {
-                in name : String;
-                out result : CustomElementConstructor;
-            }
-            action def upgrade {
-                in root : Node;
-            }
-            action def initialize {
-                in root : Node;
-            }
-        }
-
-        part def CustomStateSet;
-
-        part def DOMStringList {
-            constant attribute length : Natural;
-            action def 'item' {
-                in index : Natural;
-                out result : String[0..1];
-            }
-            action def contains {
-                in string : String;
-                out result : Boolean;
-            }
-        }
-
-        enum def DocumentReadyState {
-            loading;
-            interactive;
-            complete;
-        }
-
-        enum def DocumentVisibilityState {
-            visible;
-            hidden;
-        }
-
-        abstract part def ElementContentEditable {
-            attribute contentEditable : String;
-            attribute enterKeyHint : String;
-            constant attribute isContentEditable : Boolean;
-            attribute inputMode : String;
-        }
-
-        attribute def ElementDefinitionOptions {
-            attribute extends : String[0..1];
-        }
-
-        part def ElementInternals {
-            derived ref part shadowRoot : ShadowRoot[0..1];
-            derived ref part form : HTMLFormElement[0..1];
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            constant ref part states : CustomStateSet;
-            action def setFormValue {
-                in value : Base::Anything[0..1];
-                in 'state' : Base::Anything[0..1];
-            }
-            action def setValidity {
-                in flags : ValidityStateFlags[0..1];
-                in 'message' : String[0..1];
-                in anchor : HTMLElement[0..1];
-            }
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-        }
-
-        attribute def FocusOptions {
-            attribute preventScroll : Boolean[0..1] default = false;
-            attribute focusVisible : Boolean[0..1];
-        }
-
-        attribute def GetHTMLOptions {
-            attribute serializableShadowRoots : Boolean[0..1] default = false;
-            ref part shadowRoots : ShadowRoot[0..*] ordered;
-        }
-
-        abstract part def GlobalEventHandlers;
-
-        abstract part def HTMLHyperlinkElementUtils {
-            attribute href : String;
-            attribute target : String;
-        }
-
-        abstract part def HTMLOrSVGOrMathMLElement {
-            attribute nonce : String;
-            attribute autofocus : Boolean;
-            attribute tabIndex : Integer;
-            action def focus {
-                in options : FocusOptions[0..1];
-            }
-            action def blur;
-        }
-
-        part def HTMLElement :> Element, GlobalEventHandlers, ElementContentEditable, HTMLOrSVGOrMathMLElement {
-            attribute title : String;
-            attribute lang : String;
-            attribute translate : Boolean;
-            attribute dir : String;
-            attribute hidden : Base::DataValue[0..1];
-            attribute inert : Boolean;
-            attribute accessKey : String;
-            constant attribute accessKeyLabel : String;
-            attribute draggable : Boolean;
-            attribute spellcheck : Boolean;
-            attribute writingSuggestions : String;
-            attribute autocapitalize : String;
-            attribute autocorrect : Boolean;
-            attribute innerText : String;
-            attribute outerText : String;
-            attribute popover : String[0..1];
-            attribute headingOffset : Natural;
-            attribute headingReset : Boolean;
-            action def click;
-            action def attachInternals {
-                out result : ElementInternals;
-            }
-            action def showPopover {
-                in options : ShowPopoverOptions[0..1];
-            }
-            action def hidePopover;
-            action def togglePopover {
-                in options : Base::Anything[0..1];
-                out result : Boolean;
-            }
-        }
-
-        part def HTMLBRElement :> HTMLElement {
-            attribute clear : String;
-        }
-
-        part def HTMLBaseElement :> HTMLElement {
-            attribute href : String;
-            attribute target : String;
-        }
-
-        part def HTMLCanvasElement :> HTMLElement {
-            attribute width : Natural;
-            attribute height : Natural;
-            action def getContext {
-                in contextId : String;
-                in options : Base::Anything[0..1];
-                out result : Base::Anything[0..1];
-            }
-            action def toDataURL {
-                in type : String[0..1];
-                in quality : Base::Anything[0..1];
-                out result : String;
-            }
-            action def toBlob {
-                in callback : BlobCallback;
-                in type : String[0..1];
-                in quality : Base::Anything[0..1];
-            }
-            action def transferControlToOffscreen {
-                out result : OffscreenCanvas;
-            }
-        }
-
-        part def HTMLDListElement :> HTMLElement {
-            attribute compact : Boolean;
-        }
-
-        part def HTMLDataElement :> HTMLElement {
-            attribute value : String;
-        }
-
-        part def HTMLDataListElement :> HTMLElement {
-            derived ref part options : Element[0..*] ordered;
-        }
-
-        part def HTMLDetailsElement :> HTMLElement {
-            attribute name : String;
-            attribute open : Boolean;
-        }
-
-        part def HTMLDialogElement :> HTMLElement {
-            attribute open : Boolean;
-            attribute returnValue : String;
-            attribute closedBy : String;
-            action def show;
-            action def showModal;
-            action def close {
-                in returnValue : String[0..1];
-            }
-            action def requestClose {
-                in returnValue : String[0..1];
-            }
-        }
-
-        part def HTMLDirectoryElement :> HTMLElement {
-            attribute compact : Boolean;
-        }
-
-        part def HTMLDivElement :> HTMLElement {
-            attribute align : String;
-        }
-
-        part def HTMLEmbedElement :> HTMLElement {
-            attribute src : String;
-            attribute type : String;
-            attribute width : String;
-            attribute height : String;
-            attribute align : String;
-            attribute name : String;
-            action def getSVGDocument {
-                out result : Document[0..1];
-            }
-        }
-
-        part def HTMLFieldSetElement :> HTMLElement {
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute name : String;
-            constant attribute type : String;
-            derived ref part elements : Element[0..*] ordered;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-        }
-
-        part def HTMLFontElement :> HTMLElement {
-            attribute color : String;
-            attribute face : String;
-            attribute size : String;
-        }
-
-        part def HTMLFormElement :> HTMLElement {
-            attribute acceptCharset : String;
-            attribute 'action' : String;
-            attribute autocomplete : String;
-            attribute enctype : String;
-            attribute encoding : String;
-            attribute method : String;
-            attribute name : String;
-            attribute noValidate : Boolean;
-            attribute target : String;
-            attribute rel : String;
-            attribute relList : String[0..*] ordered;
-            derived ref part elements : Element[0..*] ordered;
-            constant attribute length : Natural;
-            action def submit;
-            action def requestSubmit {
-                in submitter : HTMLElement[0..1];
-            }
-            action def reset;
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-        }
-
-        part def HTMLFrameElement :> HTMLElement {
-            attribute name : String;
-            attribute scrolling : String;
-            attribute src : String;
-            attribute frameBorder : String;
-            attribute longDesc : String;
-            attribute noResize : Boolean;
-            derived ref part contentDocument : Document[0..1];
-            attribute marginHeight : String;
-            attribute marginWidth : String;
-        }
-
-        part def HTMLHRElement :> HTMLElement {
-            attribute align : String;
-            attribute color : String;
-            attribute noShade : Boolean;
-            attribute size : String;
-            attribute width : String;
-        }
-
-        part def HTMLHeadElement :> HTMLElement;
-
-        part def HTMLHeadingElement :> HTMLElement {
-            attribute align : String;
-        }
-
-        part def HTMLHtmlElement :> HTMLElement {
-            attribute version : String;
-        }
-
-        part def HTMLIFrameElement :> HTMLElement {
-            attribute src : String;
-            attribute srcdoc : Base::DataValue;
-            attribute name : String;
-            attribute sandbox : String[0..*] ordered;
-            attribute allow : String;
-            attribute allowFullscreen : Boolean;
-            attribute width : String;
-            attribute height : String;
-            attribute referrerPolicy : String;
-            attribute loading : String;
-            derived ref part contentDocument : Document[0..1];
-            attribute align : String;
-            attribute scrolling : String;
-            attribute frameBorder : String;
-            attribute longDesc : String;
-            attribute marginHeight : String;
-            attribute marginWidth : String;
-            action def getSVGDocument {
-                out result : Document[0..1];
-            }
-        }
-
-        part def HTMLImageElement :> HTMLElement {
-            attribute alt : String;
-            attribute src : String;
-            attribute srcset : String;
-            attribute sizes : String;
-            attribute crossOrigin : String[0..1];
-            attribute useMap : String;
-            attribute isMap : Boolean;
-            attribute controls : Boolean;
-            attribute width : Natural;
-            attribute height : Natural;
-            constant attribute naturalWidth : Natural;
-            constant attribute naturalHeight : Natural;
-            constant attribute complete : Boolean;
-            constant attribute currentSrc : String;
-            attribute referrerPolicy : String;
-            attribute decoding : String;
-            attribute loading : String;
-            attribute fetchPriority : String;
-            attribute name : String;
-            attribute lowsrc : String;
-            attribute align : String;
-            attribute hspace : Natural;
-            attribute vspace : Natural;
-            attribute longDesc : String;
-            attribute border : String;
-            action def decode;
-        }
-
-        part def HTMLLIElement :> HTMLElement {
-            attribute value : Integer;
-            attribute type : String;
-        }
-
-        part def HTMLLabelElement :> HTMLElement {
-            derived ref part form : HTMLFormElement[0..1];
-            attribute htmlFor : String;
-            derived ref part control : HTMLElement[0..1];
-        }
-
-        part def HTMLLegendElement :> HTMLElement {
-            derived ref part form : HTMLFormElement[0..1];
-            attribute align : String;
-        }
-
-        part def HTMLLinkElement :> HTMLElement {
-            attribute href : String;
-            attribute crossOrigin : String[0..1];
-            attribute rel : String;
-            attribute 'as' : String;
-            attribute relList : String[0..*] ordered;
-            attribute media : String;
-            attribute integrity : String;
-            attribute hreflang : String;
-            attribute type : String;
-            attribute sizes : String[0..*] ordered;
-            attribute imageSrcset : String;
-            attribute imageSizes : String;
-            attribute referrerPolicy : String;
-            attribute blocking : String[0..*] ordered;
-            attribute disabled : Boolean;
-            attribute fetchPriority : String;
-            attribute charset : String;
-            attribute rev : String;
-            attribute target : String;
-        }
-
-        part def HTMLMapElement :> HTMLElement {
-            attribute name : String;
-            derived ref part areas : Element[0..*] ordered;
-        }
-
-        part def HTMLMarqueeElement :> HTMLElement {
-            attribute behavior : String;
-            attribute bgColor : String;
-            attribute direction : String;
-            attribute height : String;
-            attribute hspace : Natural;
-            attribute 'loop' : Integer;
-            attribute scrollAmount : Natural;
-            attribute scrollDelay : Natural;
-            attribute trueSpeed : Boolean;
-            attribute vspace : Natural;
-            attribute width : String;
-            action def start;
-            action def stop;
-        }
-
-        abstract part def HTMLMediaElement :> HTMLElement {
-            constant ref part error : MediaError[0..1];
-            attribute src : String;
-            attribute srcObject : Base::DataValue[0..1];
-            constant attribute currentSrc : String;
-            attribute crossOrigin : String[0..1];
-            constant attribute NETWORK_EMPTY : Natural = 0;
-            constant attribute NETWORK_IDLE : Natural = 1;
-            constant attribute NETWORK_LOADING : Natural = 2;
-            constant attribute NETWORK_NO_SOURCE : Natural = 3;
-            constant attribute networkState : Natural;
-            attribute preload : String;
-            constant ref part buffered : TimeRanges;
-            constant attribute HAVE_NOTHING : Natural = 0;
-            constant attribute HAVE_METADATA : Natural = 1;
-            constant attribute HAVE_CURRENT_DATA : Natural = 2;
-            constant attribute HAVE_FUTURE_DATA : Natural = 3;
-            constant attribute HAVE_ENOUGH_DATA : Natural = 4;
-            constant attribute readyState : Natural;
-            constant attribute seeking : Boolean;
-            attribute currentTime : Real;
-            constant attribute duration : Real;
-            constant attribute paused : Boolean;
-            attribute defaultPlaybackRate : Real;
-            attribute playbackRate : Real;
-            attribute preservesPitch : Boolean;
-            constant ref part played : TimeRanges;
-            constant ref part seekable : TimeRanges;
-            constant attribute ended : Boolean;
-            attribute autoplay : Boolean;
-            attribute 'loop' : Boolean;
-            attribute controls : Boolean;
-            attribute volume : Real;
-            attribute muted : Boolean;
-            attribute defaultMuted : Boolean;
-            attribute loading : String;
-            constant ref part audioTracks : AudioTrackList;
-            constant ref part videoTracks : VideoTrackList;
-            constant ref part textTracks : TextTrackList;
-            action def load;
-            action def canPlayType {
-                in type : String;
-                out result : CanPlayTypeResult;
-            }
-            action def fastSeek {
-                in time : Real;
-            }
-            action def getStartDate {
-                out result : Base::Anything;
-            }
-            action def play;
-            action def pause;
-            action def addTextTrack {
-                in kind : TextTrackKind;
-                in label : String[0..1];
-                in 'language' : String[0..1];
-                out result : TextTrack;
-            }
-        }
-
-        part def HTMLAudioElement :> HTMLMediaElement;
-
-        part def HTMLMenuElement :> HTMLElement {
-            attribute compact : Boolean;
-        }
-
-        part def HTMLMetaElement :> HTMLElement {
-            attribute name : String;
-            attribute httpEquiv : String;
-            attribute content : String;
-            attribute media : String;
-            attribute scheme : String;
-        }
-
-        part def HTMLMeterElement :> HTMLElement {
-            attribute value : Real;
-            attribute min : Real;
-            attribute max : Real;
-            attribute low : Real;
-            attribute high : Real;
-            attribute optimum : Real;
-            derived ref part labels : Node[0..*] ordered;
-        }
-
-        part def HTMLModElement :> HTMLElement {
-            attribute cite : String;
-            attribute dateTime : String;
-        }
-
-        part def HTMLOListElement :> HTMLElement {
-            attribute reversed : Boolean;
-            attribute start : Integer;
-            attribute type : String;
-            attribute compact : Boolean;
-        }
-
-        part def HTMLObjectElement :> HTMLElement {
-            attribute data : String;
-            attribute type : String;
-            attribute name : String;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute width : String;
-            attribute height : String;
-            derived ref part contentDocument : Document[0..1];
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            attribute align : String;
-            attribute archive : String;
-            attribute code : String;
-            attribute declare : Boolean;
-            attribute hspace : Natural;
-            attribute standby : String;
-            attribute vspace : Natural;
-            attribute codeBase : String;
-            attribute codeType : String;
-            attribute useMap : String;
-            attribute border : String;
-            action def getSVGDocument {
-                out result : Document[0..1];
-            }
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-        }
-
-        part def HTMLOptGroupElement :> HTMLElement {
-            attribute disabled : Boolean;
-            attribute label : String;
-        }
-
-        part def HTMLOptionElement :> HTMLElement {
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute label : String;
-            attribute defaultSelected : Boolean;
-            attribute selected : Boolean;
-            attribute value : String;
-            attribute text : String;
-            constant attribute index : Integer;
-        }
-
-        part def HTMLOutputElement :> HTMLElement {
-            attribute htmlFor : String[0..*] ordered;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute name : String;
-            constant attribute type : String;
-            attribute defaultValue : String;
-            attribute value : String;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-        }
-
-        part def HTMLParagraphElement :> HTMLElement {
-            attribute align : String;
-        }
-
-        part def HTMLParamElement :> HTMLElement {
-            attribute name : String;
-            attribute value : String;
-            attribute type : String;
-            attribute valueType : String;
-        }
-
-        part def HTMLPictureElement :> HTMLElement;
-
-        part def HTMLPreElement :> HTMLElement {
-            attribute width : Integer;
-        }
-
-        part def HTMLProgressElement :> HTMLElement {
-            attribute value : Real;
-            attribute max : Real;
-            constant attribute position : Real;
-            derived ref part labels : Node[0..*] ordered;
-        }
-
-        part def HTMLQuoteElement :> HTMLElement {
-            attribute cite : String;
-        }
-
-        part def HTMLScriptElement :> HTMLElement {
-            attribute type : String;
-            attribute src : String;
-            attribute noModule : Boolean;
-            attribute async : Boolean;
-            attribute defer : Boolean;
-            attribute blocking : String[0..*] ordered;
-            attribute crossOrigin : String[0..1];
-            attribute referrerPolicy : String;
-            attribute integrity : String;
-            attribute fetchPriority : String;
-            attribute text : String;
-            attribute charset : String;
-            attribute 'event' : String;
-            attribute htmlFor : String;
-        }
-
-        part def HTMLSelectElement :> HTMLElement {
-            attribute autocomplete : String;
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute multiple : Boolean;
-            attribute name : String;
-            attribute required : Boolean;
-            attribute size : Natural;
-            constant attribute type : String;
-            derived ref part options : Element[0..*] ordered;
-            attribute length : Natural;
-            derived ref part selectedOptions : Element[0..*] ordered;
-            attribute selectedIndex : Integer;
-            attribute value : String;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            action def 'item' {
-                in index : Natural;
-                out result : HTMLOptionElement[0..1];
-            }
-            action def namedItem {
-                in name : String;
-                out result : HTMLOptionElement[0..1];
-            }
-            action def add {
-                in element : HTMLElement;
-                in before : Base::Anything[0..1];
-            }
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-            action def showPicker;
-        }
-
-        part def HTMLSelectedContentElement :> HTMLElement;
-
-        part def HTMLSlotElement :> HTMLElement {
-            attribute name : String;
-            action def assignedNodes {
-                in options : AssignedNodesOptions[0..1];
-                out result : Node[0..*] ordered;
-            }
-            action def assignedElements {
-                in options : AssignedNodesOptions[0..1];
-                out result : Element[0..*] ordered;
-            }
-            action def 'assign' {
-                in nodes : Node[0..*] ordered;
-            }
-        }
-
-        part def HTMLSourceElement :> HTMLElement {
-            attribute src : String;
-            attribute type : String;
-            attribute srcset : String;
-            attribute sizes : String;
-            attribute media : String;
-            attribute width : Natural;
-            attribute height : Natural;
-        }
-
-        part def HTMLSpanElement :> HTMLElement;
-
-        part def HTMLStyleElement :> HTMLElement {
-            attribute disabled : Boolean;
-            attribute media : String;
-            attribute blocking : String[0..*] ordered;
-            attribute type : String;
-        }
-
-        part def HTMLTableCaptionElement :> HTMLElement {
-            attribute align : String;
-        }
-
-        part def HTMLTableCellElement :> HTMLElement {
-            attribute colSpan : Natural;
-            attribute rowSpan : Natural;
-            attribute headers : String;
-            constant attribute cellIndex : Integer;
-            attribute scope : String;
-            attribute abbr : String;
-            attribute align : String;
-            attribute axis : String;
-            attribute height : String;
-            attribute width : String;
-            attribute ch : String;
-            attribute chOff : String;
-            attribute noWrap : Boolean;
-            attribute vAlign : String;
-            attribute bgColor : String;
-        }
-
-        part def HTMLTableColElement :> HTMLElement {
-            attribute span : Natural;
-            attribute align : String;
-            attribute ch : String;
-            attribute chOff : String;
-            attribute vAlign : String;
-            attribute width : String;
-        }
-
-        part def HTMLTableElement :> HTMLElement {
-            derived ref part caption : HTMLTableCaptionElement[0..1];
-            derived ref part tHead : HTMLTableSectionElement[0..1];
-            derived ref part tFoot : HTMLTableSectionElement[0..1];
-            derived ref part tBodies : Element[0..*] ordered;
-            derived ref part rows : Element[0..*] ordered;
-            attribute align : String;
-            attribute border : String;
-            attribute 'frame' : String;
-            attribute rules : String;
-            attribute summary : String;
-            attribute width : String;
-            attribute bgColor : String;
-            attribute cellPadding : String;
-            attribute cellSpacing : String;
-            action def createCaption {
-                out result : HTMLTableCaptionElement;
-            }
-            action def deleteCaption;
-            action def createTHead {
-                out result : HTMLTableSectionElement;
-            }
-            action def deleteTHead;
-            action def createTFoot {
-                out result : HTMLTableSectionElement;
-            }
-            action def deleteTFoot;
-            action def createTBody {
-                out result : HTMLTableSectionElement;
-            }
-            action def insertRow {
-                in index : Integer[0..1];
-                out result : HTMLTableRowElement;
-            }
-            action def deleteRow {
-                in index : Integer;
-            }
-        }
-
-        part def HTMLTableRowElement :> HTMLElement {
-            constant attribute rowIndex : Integer;
-            constant attribute sectionRowIndex : Integer;
-            derived ref part cells : Element[0..*] ordered;
-            attribute align : String;
-            attribute ch : String;
-            attribute chOff : String;
-            attribute vAlign : String;
-            attribute bgColor : String;
-            action def insertCell {
-                in index : Integer[0..1];
-                out result : HTMLTableCellElement;
-            }
-            action def deleteCell {
-                in index : Integer;
-            }
-        }
-
-        part def HTMLTableSectionElement :> HTMLElement {
-            derived ref part rows : Element[0..*] ordered;
-            attribute align : String;
-            attribute ch : String;
-            attribute chOff : String;
-            attribute vAlign : String;
-            action def insertRow {
-                in index : Integer[0..1];
-                out result : HTMLTableRowElement;
-            }
-            action def deleteRow {
-                in index : Integer;
-            }
-        }
-
-        part def HTMLTemplateElement :> HTMLElement {
-            derived ref part content : DocumentFragment;
-            attribute htmlFor : String;
-            attribute shadowRootMode : String;
-            attribute shadowRootDelegatesFocus : Boolean;
-            attribute shadowRootSerializable : Boolean;
-            attribute shadowRootSlotAssignment : String;
-            attribute shadowRootClonable : Boolean;
-            attribute shadowRootCustomElementRegistry : String;
-        }
-
-        part def HTMLTextAreaElement :> HTMLElement {
-            attribute autocomplete : String;
-            attribute cols : Natural;
-            attribute dirName : String;
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute maxLength : Integer;
-            attribute minLength : Integer;
-            attribute name : String;
-            attribute placeholder : String;
-            attribute readOnly : Boolean;
-            attribute required : Boolean;
-            attribute rows : Natural;
-            attribute wrap : String;
-            constant attribute type : String;
-            attribute defaultValue : String;
-            attribute value : String;
-            constant attribute textLength : Natural;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            attribute selectionStart : Natural;
-            attribute selectionEnd : Natural;
-            attribute selectionDirection : String;
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-            action def select;
-            action def setRangeText {
-                in replacement : String;
-                in start : Natural[0..1];
-                in 'end' : Natural[0..1];
-                in selectionMode : SelectionMode[0..1];
-            }
-            action def setSelectionRange {
-                in start : Natural;
-                in 'end' : Natural;
-                in direction : String[0..1];
-            }
-        }
-
-        part def HTMLTimeElement :> HTMLElement {
-            attribute dateTime : String;
-        }
-
-        part def HTMLTitleElement :> HTMLElement {
-            attribute text : String;
-        }
-
-        part def HTMLTrackElement :> HTMLElement {
-            attribute kind : String;
-            attribute src : String;
-            attribute srclang : String;
-            attribute label : String;
-            attribute 'default' : Boolean;
-            constant attribute NONE : Natural = 0;
-            constant attribute LOADING : Natural = 1;
-            constant attribute LOADED : Natural = 2;
-            constant attribute ERROR : Natural = 3;
-            constant attribute readyState : Natural;
-            constant ref part track : TextTrack;
-        }
-
-        part def HTMLUListElement :> HTMLElement {
-            attribute compact : Boolean;
-            attribute type : String;
-        }
-
-        part def HTMLUnknownElement :> HTMLElement;
-
-        part def HTMLVideoElement :> HTMLMediaElement {
-            attribute width : Natural;
-            attribute height : Natural;
-            constant attribute videoWidth : Natural;
-            constant attribute videoHeight : Natural;
-            attribute poster : String;
-            attribute playsInline : Boolean;
-        }
-
-        abstract part def HyperlinkElementUtils {
-            constant attribute origin : String;
-            attribute protocol : String;
-            attribute username : String;
-            attribute password : String;
-            attribute host : String;
-            attribute hostname : String;
-            attribute 'port' : String;
-            attribute pathname : String;
-            attribute search : String;
-            attribute hash : String;
-            attribute hreflang : String;
-            attribute type : String;
-        }
-
-        part def HTMLAnchorElement :> HTMLElement, HyperlinkElementUtils, HTMLHyperlinkElementUtils {
-            attribute download : String;
-            attribute ping : String;
-            attribute rel : String;
-            attribute relList : String[0..*] ordered;
-            attribute text : String;
-            attribute referrerPolicy : String;
-            attribute coords : String;
-            attribute charset : String;
-            attribute name : String;
-            attribute rev : String;
-            attribute shape : String;
-        }
-
-        part def HTMLAreaElement :> HTMLElement, HyperlinkElementUtils, HTMLHyperlinkElementUtils {
-            attribute alt : String;
-            attribute coords : String;
-            attribute shape : String;
-            attribute download : String;
-            attribute ping : String;
-            attribute rel : String;
-            attribute relList : String[0..*] ordered;
-            attribute referrerPolicy : String;
-            attribute noHref : Boolean;
-        }
-
-        part def ImageBitmap {
-            constant attribute width : Natural;
-            constant attribute height : Natural;
-            action def close;
-        }
-
-        attribute def ImageEncodeOptions {
-            attribute type : String[0..1] default = "image/png";
-            attribute quality : Real[0..1];
-        }
-
-        part def Location {
-            attribute href : String;
-            constant attribute origin : String;
-            attribute protocol : String;
-            attribute host : String;
-            attribute hostname : String;
-            attribute 'port' : String;
-            attribute pathname : String;
-            attribute search : String;
-            attribute hash : String;
-            constant ref part ancestorOrigins : DOMStringList;
-            action def 'assign' {
-                in url : String;
-            }
-            action def replace {
-                in url : String;
-            }
-            action def reload;
-        }
-
-        part def MediaError {
-            constant attribute MEDIA_ERR_ABORTED : Natural = 1;
-            constant attribute MEDIA_ERR_NETWORK : Natural = 2;
-            constant attribute MEDIA_ERR_DECODE : Natural = 3;
-            constant attribute MEDIA_ERR_SRC_NOT_SUPPORTED : Natural = 4;
-            constant attribute code : Natural;
-            constant attribute 'message' : String;
-        }
-
-        part def OffscreenCanvas :> EventTarget {
-            attribute width : Natural;
-            attribute height : Natural;
-            action def getContext {
-                in contextId : OffscreenRenderingContextId;
-                in options : Base::Anything[0..1];
-                out result : Base::Anything[0..1];
-            }
-            action def transferToImageBitmap {
-                out result : ImageBitmap;
-            }
-        }
-
-        enum def OffscreenRenderingContextId {
-            '2d';
-            bitmaprenderer;
-            webgl;
-            webgl2;
-            webgpu;
-        }
-
-        abstract part def PopoverTargetAttributes {
-            derived ref part popoverTargetElement : Element[0..1];
-            attribute popoverTargetAction : String;
-        }
-
-        part def HTMLButtonElement :> HTMLElement, PopoverTargetAttributes {
-            attribute command : String;
-            derived ref part commandForElement : Element[0..1];
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute formAction : String;
-            attribute formEnctype : String;
-            attribute formMethod : String;
-            attribute formNoValidate : Boolean;
-            attribute formTarget : String;
-            attribute name : String;
-            attribute type : String;
-            attribute value : String;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-        }
-
-        part def HTMLInputElement :> HTMLElement, PopoverTargetAttributes {
-            attribute 'accept' : String;
-            attribute alpha : Boolean;
-            attribute alt : String;
-            attribute autocomplete : String;
-            attribute defaultChecked : Boolean;
-            attribute checked : Boolean;
-            attribute colorSpace : String;
-            attribute dirName : String;
-            attribute disabled : Boolean;
-            derived ref part form : HTMLFormElement[0..1];
-            attribute formAction : String;
-            attribute formEnctype : String;
-            attribute formMethod : String;
-            attribute formNoValidate : Boolean;
-            attribute formTarget : String;
-            attribute height : Natural;
-            attribute indeterminate : Boolean;
-            derived ref part list : HTMLDataListElement[0..1];
-            attribute max : String;
-            attribute maxLength : Integer;
-            attribute min : String;
-            attribute minLength : Integer;
-            attribute multiple : Boolean;
-            attribute name : String;
-            attribute pattern : String;
-            attribute placeholder : String;
-            attribute readOnly : Boolean;
-            attribute required : Boolean;
-            attribute size : Natural;
-            attribute src : String;
-            attribute step : String;
-            attribute type : String;
-            attribute defaultValue : String;
-            attribute value : String;
-            attribute valueAsDate : Base::DataValue[0..1];
-            attribute valueAsNumber : Real;
-            attribute width : Natural;
-            constant attribute willValidate : Boolean;
-            constant ref part validity : ValidityState;
-            constant attribute validationMessage : String;
-            derived ref part labels : Node[0..*] ordered;
-            attribute selectionStart : Natural[0..1];
-            attribute selectionEnd : Natural[0..1];
-            attribute selectionDirection : String[0..1];
-            attribute align : String;
-            attribute useMap : String;
-            action def stepUp {
-                in n : Integer[0..1];
-            }
-            action def stepDown {
-                in n : Integer[0..1];
-            }
-            action def checkValidity {
-                out result : Boolean;
-            }
-            action def reportValidity {
-                out result : Boolean;
-            }
-            action def setCustomValidity {
-                in error : String;
-            }
-            action def select;
-            action def setRangeText {
-                in replacement : String;
-                in start : Natural[0..1];
-                in 'end' : Natural[0..1];
-                in selectionMode : SelectionMode[0..1];
-            }
-            action def setSelectionRange {
-                in start : Natural;
-                in 'end' : Natural;
-                in direction : String[0..1];
-            }
-            action def showPicker;
-        }
-
-        enum def SelectionMode {
-            select;
-            start;
-            'end';
-            preserve;
-        }
-
-        attribute def SetHTMLOptions {
-            attribute sanitizer : Base::DataValue[0..1] default = "default";
-        }
-
-        attribute def SetHTMLUnsafeOptions {
-            attribute sanitizer : Base::DataValue[0..1];
-            attribute runScripts : Boolean[0..1] default = false;
-        }
-
-        attribute def ShowPopoverOptions {
-            ref part source : HTMLElement[0..1];
-        }
-
-        part def TextTrack :> EventTarget {
-            constant attribute kind : TextTrackKind;
-            constant attribute label : String;
-            constant attribute 'language' : String;
-            constant attribute id : String;
-            constant attribute inBandMetadataTrackDispatchType : String;
-            attribute mode : TextTrackMode;
-            constant ref part cues : TextTrackCueList[0..1];
-            constant ref part activeCues : TextTrackCueList[0..1];
-            action def addCue {
-                in cue : TextTrackCue;
-            }
-            action def removeCue {
-                in cue : TextTrackCue;
-            }
-        }
-
-        part def TextTrackCue :> EventTarget {
-            constant ref part track : TextTrack[0..1];
-            attribute id : String;
-            attribute startTime : Real;
-            attribute endTime : Real;
-            attribute pauseOnExit : Boolean;
-        }
-
-        part def TextTrackCueList {
-            constant attribute length : Natural;
-            action def getCueById {
-                in id : String;
-                out result : TextTrackCue[0..1];
-            }
-        }
-
-        enum def TextTrackKind {
-            subtitles;
-            captions;
-            descriptions;
-            chapters;
-            'metadata';
-        }
-
-        part def TextTrackList :> EventTarget {
-            constant attribute length : Natural;
-            action def getTrackById {
-                in id : String;
-                out result : TextTrack[0..1];
-            }
-        }
-
-        enum def TextTrackMode {
-            disabled;
-            hidden;
-            showing;
-        }
-
-        part def TimeRanges {
-            constant attribute length : Natural;
-            action def start {
-                in index : Natural;
-                out result : Real;
-            }
-            action def 'end' {
-                in index : Natural;
-                out result : Real;
-            }
-        }
-
-        part def ValidityState {
-            constant attribute valueMissing : Boolean;
-            constant attribute typeMismatch : Boolean;
-            constant attribute patternMismatch : Boolean;
-            constant attribute tooLong : Boolean;
-            constant attribute tooShort : Boolean;
-            constant attribute rangeUnderflow : Boolean;
-            constant attribute rangeOverflow : Boolean;
-            constant attribute stepMismatch : Boolean;
-            constant attribute badInput : Boolean;
-            constant attribute customError : Boolean;
-            constant attribute valid : Boolean;
-        }
-
-        attribute def ValidityStateFlags {
-            attribute valueMissing : Boolean[0..1] default = false;
-            attribute typeMismatch : Boolean[0..1] default = false;
-            attribute patternMismatch : Boolean[0..1] default = false;
-            attribute tooLong : Boolean[0..1] default = false;
-            attribute tooShort : Boolean[0..1] default = false;
-            attribute rangeUnderflow : Boolean[0..1] default = false;
-            attribute rangeOverflow : Boolean[0..1] default = false;
-            attribute stepMismatch : Boolean[0..1] default = false;
-            attribute badInput : Boolean[0..1] default = false;
-            attribute customError : Boolean[0..1] default = false;
-        }
-
-        part def VideoTrack {
-            constant attribute id : String;
-            constant attribute kind : String;
-            constant attribute label : String;
-            constant attribute 'language' : String;
-            attribute selected : Boolean;
-        }
-
-        part def VideoTrackList :> EventTarget {
-            constant attribute length : Natural;
-            constant attribute selectedIndex : Integer;
-            action def getTrackById {
-                in id : String;
-                out result : VideoTrack[0..1];
-            }
-        }
-
-        abstract part def WindowEventHandlers;
-
-        part def HTMLBodyElement :> HTMLElement, WindowEventHandlers {
-            attribute text : String;
-            attribute link : String;
-            attribute vLink : String;
-            attribute aLink : String;
-            attribute bgColor : String;
-            attribute background : String;
-        }
-
-        part def HTMLFrameSetElement :> HTMLElement, WindowEventHandlers {
-            attribute cols : String;
-            attribute rows : String;
-        }
-
-        package Elements {
-            part def A :> HTMLAnchorElement {
-                :>> localName = "a";
-            }
-
-            part def Abbr :> HTMLElement {
-                :>> localName = "abbr";
-            }
-
-            part def Acronym :> HTMLElement {
-                :>> localName = "acronym";
-            }
-
-            part def Address :> HTMLElement {
-                :>> localName = "address";
-            }
-
-            part def Applet :> HTMLUnknownElement {
-                :>> localName = "applet";
-            }
-
-            part def Area :> HTMLAreaElement {
-                :>> localName = "area";
-            }
-
-            part def Article :> HTMLElement {
-                :>> localName = "article";
-            }
-
-            part def Aside :> HTMLElement {
-                :>> localName = "aside";
-            }
-
-            part def Audio :> HTMLAudioElement {
-                :>> localName = "audio";
-            }
-
-            part def B :> HTMLElement {
-                :>> localName = "b";
-            }
-
-            part def Base :> HTMLBaseElement {
-                :>> localName = "base";
-            }
-
-            part def Basefont :> HTMLElement {
-                :>> localName = "basefont";
-            }
-
-            part def Bdi :> HTMLElement {
-                :>> localName = "bdi";
-            }
-
-            part def Bdo :> HTMLElement {
-                :>> localName = "bdo";
-            }
-
-            part def Bgsound :> HTMLUnknownElement {
-                :>> localName = "bgsound";
-            }
-
-            part def Big :> HTMLElement {
-                :>> localName = "big";
-            }
-
-            part def Blink :> HTMLUnknownElement {
-                :>> localName = "blink";
-            }
-
-            part def Blockquote :> HTMLQuoteElement {
-                :>> localName = "blockquote";
-            }
-
-            part def Body :> HTMLBodyElement {
-                :>> localName = "body";
-            }
-
-            part def Br :> HTMLBRElement {
-                :>> localName = "br";
-            }
-
-            part def Button :> HTMLButtonElement {
-                :>> localName = "button";
-            }
-
-            part def Canvas :> HTMLCanvasElement {
-                :>> localName = "canvas";
-            }
-
-            part def Caption :> HTMLTableCaptionElement {
-                :>> localName = "caption";
-            }
-
-            part def Center :> HTMLElement {
-                :>> localName = "center";
-            }
-
-            part def Cite :> HTMLElement {
-                :>> localName = "cite";
-            }
-
-            part def Code :> HTMLElement {
-                :>> localName = "code";
-            }
-
-            part def Col :> HTMLTableColElement {
-                :>> localName = "col";
-            }
-
-            part def Colgroup :> HTMLTableColElement {
-                :>> localName = "colgroup";
-            }
-
-            part def Data :> HTMLDataElement {
-                :>> localName = "data";
-            }
-
-            part def Datalist :> HTMLDataListElement {
-                :>> localName = "datalist";
-            }
-
-            part def Dd :> HTMLElement {
-                :>> localName = "dd";
-            }
-
-            part def Del :> HTMLModElement {
-                :>> localName = "del";
-            }
-
-            part def Details :> HTMLDetailsElement {
-                :>> localName = "details";
-            }
-
-            part def Dfn :> HTMLElement {
-                :>> localName = "dfn";
-            }
-
-            part def Dialog :> HTMLDialogElement {
-                :>> localName = "dialog";
-            }
-
-            part def Dir :> HTMLDirectoryElement {
-                :>> localName = "dir";
-            }
-
-            part def Div :> HTMLDivElement {
-                :>> localName = "div";
-            }
-
-            part def Dl :> HTMLDListElement {
-                :>> localName = "dl";
-            }
-
-            part def Dt :> HTMLElement {
-                :>> localName = "dt";
-            }
-
-            part def Em :> HTMLElement {
-                :>> localName = "em";
-            }
-
-            part def Embed :> HTMLEmbedElement {
-                :>> localName = "embed";
-            }
-
-            part def Fieldset :> HTMLFieldSetElement {
-                :>> localName = "fieldset";
-            }
-
-            part def Figcaption :> HTMLElement {
-                :>> localName = "figcaption";
-            }
-
-            part def Figure :> HTMLElement {
-                :>> localName = "figure";
-            }
-
-            part def Font :> HTMLFontElement {
-                :>> localName = "font";
-            }
-
-            part def Footer :> HTMLElement {
-                :>> localName = "footer";
-            }
-
-            part def Form :> HTMLFormElement {
-                :>> localName = "form";
-            }
-
-            part def Frame :> HTMLFrameElement {
-                :>> localName = "frame";
-            }
-
-            part def Frameset :> HTMLFrameSetElement {
-                :>> localName = "frameset";
-            }
-
-            part def H1 :> HTMLHeadingElement {
-                :>> localName = "h1";
-            }
-
-            part def H2 :> HTMLHeadingElement {
-                :>> localName = "h2";
-            }
-
-            part def H3 :> HTMLHeadingElement {
-                :>> localName = "h3";
-            }
-
-            part def H4 :> HTMLHeadingElement {
-                :>> localName = "h4";
-            }
-
-            part def H5 :> HTMLHeadingElement {
-                :>> localName = "h5";
-            }
-
-            part def H6 :> HTMLHeadingElement {
-                :>> localName = "h6";
-            }
-
-            part def Head :> HTMLHeadElement {
-                :>> localName = "head";
-            }
-
-            part def Header :> HTMLElement {
-                :>> localName = "header";
-            }
-
-            part def Hgroup :> HTMLElement {
-                :>> localName = "hgroup";
-            }
-
-            part def Hr :> HTMLHRElement {
-                :>> localName = "hr";
-            }
-
-            part def Html :> HTMLHtmlElement {
-                :>> localName = "html";
-            }
-
-            part def I :> HTMLElement {
-                :>> localName = "i";
-            }
-
-            part def Iframe :> HTMLIFrameElement {
-                :>> localName = "iframe";
-            }
-
-            part def Img :> HTMLImageElement {
-                :>> localName = "img";
-            }
-
-            part def Input :> HTMLInputElement {
-                :>> localName = "input";
-            }
-
-            part def Ins :> HTMLModElement {
-                :>> localName = "ins";
-            }
-
-            part def Isindex :> HTMLUnknownElement {
-                :>> localName = "isindex";
-            }
-
-            part def Kbd :> HTMLElement {
-                :>> localName = "kbd";
-            }
-
-            part def Keygen :> HTMLUnknownElement {
-                :>> localName = "keygen";
-            }
-
-            part def Label :> HTMLLabelElement {
-                :>> localName = "label";
-            }
-
-            part def Legend :> HTMLLegendElement {
-                :>> localName = "legend";
-            }
-
-            part def Li :> HTMLLIElement {
-                :>> localName = "li";
-            }
-
-            part def Link :> HTMLLinkElement {
-                :>> localName = "link";
-            }
-
-            part def Listing :> HTMLPreElement {
-                :>> localName = "listing";
-            }
-
-            part def Main :> HTMLElement {
-                :>> localName = "main";
-            }
-
-            part def Map :> HTMLMapElement {
-                :>> localName = "map";
-            }
-
-            part def Mark :> HTMLElement {
-                :>> localName = "mark";
-            }
-
-            part def Marquee :> HTMLMarqueeElement {
-                :>> localName = "marquee";
-            }
-
-            part def Menu :> HTMLMenuElement {
-                :>> localName = "menu";
-            }
-
-            part def Menuitem :> HTMLElement {
-                :>> localName = "menuitem";
-            }
-
-            part def Meta :> HTMLMetaElement {
-                :>> localName = "meta";
-            }
-
-            part def Meter :> HTMLMeterElement {
-                :>> localName = "meter";
-            }
-
-            part def Multicol :> HTMLUnknownElement {
-                :>> localName = "multicol";
-            }
-
-            part def Nav :> HTMLElement {
-                :>> localName = "nav";
-            }
-
-            part def Nextid :> HTMLUnknownElement {
-                :>> localName = "nextid";
-            }
-
-            part def Nobr :> HTMLElement {
-                :>> localName = "nobr";
-            }
-
-            part def Noembed :> HTMLElement {
-                :>> localName = "noembed";
-            }
-
-            part def Noframes :> HTMLElement {
-                :>> localName = "noframes";
-            }
-
-            part def Noscript :> HTMLElement {
-                :>> localName = "noscript";
-            }
-
-            part def Object :> HTMLObjectElement {
-                :>> localName = "object";
-            }
-
-            part def Ol :> HTMLOListElement {
-                :>> localName = "ol";
-            }
-
-            part def Optgroup :> HTMLOptGroupElement {
-                :>> localName = "optgroup";
-            }
-
-            part def Option :> HTMLOptionElement {
-                :>> localName = "option";
-            }
-
-            part def Output :> HTMLOutputElement {
-                :>> localName = "output";
-            }
-
-            part def P :> HTMLParagraphElement {
-                :>> localName = "p";
-            }
-
-            part def Param :> HTMLParamElement {
-                :>> localName = "param";
-            }
-
-            part def Picture :> HTMLPictureElement {
-                :>> localName = "picture";
-            }
-
-            part def Plaintext :> HTMLElement {
-                :>> localName = "plaintext";
-            }
-
-            part def Pre :> HTMLPreElement {
-                :>> localName = "pre";
-            }
-
-            part def Progress :> HTMLProgressElement {
-                :>> localName = "progress";
-            }
-
-            part def Q :> HTMLQuoteElement {
-                :>> localName = "q";
-            }
-
-            part def Rb :> HTMLElement {
-                :>> localName = "rb";
-            }
-
-            part def Rp :> HTMLElement {
-                :>> localName = "rp";
-            }
-
-            part def Rt :> HTMLElement {
-                :>> localName = "rt";
-            }
-
-            part def Rtc :> HTMLElement {
-                :>> localName = "rtc";
-            }
-
-            part def Ruby :> HTMLElement {
-                :>> localName = "ruby";
-            }
-
-            part def S :> HTMLElement {
-                :>> localName = "s";
-            }
-
-            part def Samp :> HTMLElement {
-                :>> localName = "samp";
-            }
-
-            part def Script :> HTMLScriptElement {
-                :>> localName = "script";
-            }
-
-            part def Search :> HTMLElement {
-                :>> localName = "search";
-            }
-
-            part def Section :> HTMLElement {
-                :>> localName = "section";
-            }
-
-            part def Select :> HTMLSelectElement {
-                :>> localName = "select";
-            }
-
-            part def Selectedcontent :> HTMLSelectedContentElement {
-                :>> localName = "selectedcontent";
-            }
-
-            part def Slot :> HTMLSlotElement {
-                :>> localName = "slot";
-            }
-
-            part def Small :> HTMLElement {
-                :>> localName = "small";
-            }
-
-            part def Source :> HTMLSourceElement {
-                :>> localName = "source";
-            }
-
-            part def Spacer :> HTMLUnknownElement {
-                :>> localName = "spacer";
-            }
-
-            part def Span :> HTMLSpanElement {
-                :>> localName = "span";
-            }
-
-            part def Strike :> HTMLElement {
-                :>> localName = "strike";
-            }
-
-            part def Strong :> HTMLElement {
-                :>> localName = "strong";
-            }
-
-            part def Style :> HTMLStyleElement {
-                :>> localName = "style";
-            }
-
-            part def Sub :> HTMLElement {
-                :>> localName = "sub";
-            }
-
-            part def Summary :> HTMLElement {
-                :>> localName = "summary";
-            }
-
-            part def Sup :> HTMLElement {
-                :>> localName = "sup";
-            }
-
-            part def Table :> HTMLTableElement {
-                :>> localName = "table";
-            }
-
-            part def Tbody :> HTMLTableSectionElement {
-                :>> localName = "tbody";
-            }
-
-            part def Td :> HTMLTableCellElement {
-                :>> localName = "td";
-            }
-
-            part def Template :> HTMLTemplateElement {
-                :>> localName = "template";
-            }
-
-            part def Textarea :> HTMLTextAreaElement {
-                :>> localName = "textarea";
-            }
-
-            part def Tfoot :> HTMLTableSectionElement {
-                :>> localName = "tfoot";
-            }
-
-            part def Th :> HTMLTableCellElement {
-                :>> localName = "th";
-            }
-
-            part def Thead :> HTMLTableSectionElement {
-                :>> localName = "thead";
-            }
-
-            part def Time :> HTMLTimeElement {
-                :>> localName = "time";
-            }
-
-            part def Title :> HTMLTitleElement {
-                :>> localName = "title";
-            }
-
-            part def Tr :> HTMLTableRowElement {
-                :>> localName = "tr";
-            }
-
-            part def Track :> HTMLTrackElement {
-                :>> localName = "track";
-            }
-
-            part def Tt :> HTMLElement {
-                :>> localName = "tt";
-            }
-
-            part def U :> HTMLElement {
-                :>> localName = "u";
-            }
-
-            part def Ul :> HTMLUListElement {
-                :>> localName = "ul";
-            }
-
-            part def Var :> HTMLElement {
-                :>> localName = "var";
-            }
-
-            part def Video :> HTMLVideoElement {
-                :>> localName = "video";
-            }
-
-            part def Wbr :> HTMLElement {
-                :>> localName = "wbr";
-            }
-
-            part def Xmp :> HTMLPreElement {
-                :>> localName = "xmp";
-            }
-        }
-    }
-}
diff --git a/local-packages/WebApp.provenance.json b/local-packages/WebApp.provenance.json
deleted file mode 100644
index f628131..0000000
--- a/local-packages/WebApp.provenance.json
+++ /dev/null
@@ -1,131 +0,0 @@
-{
-  "generator": {
-    "name": "@sysml/web",
-    "version": "0.8.0"
-  },
-  "dataset": {},
-  "kernel": "0.8.0",
-  "library": "WebApp",
-  "elements": {
-    "WebApp::WebApp::Application": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "WebApp::WebApp::Application::assets": {
-      "kind": "part",
-      "type": "WebApp::WebApp::Asset",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "WebApp::WebApp::Application::dependencies": {
-      "kind": "part",
-      "type": "SourceDependency",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "WebApp::WebApp::Application::entryModule": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "WebApp::WebApp::Application::mountTarget": {
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Application::navigation": {
-      "kind": "part",
-      "type": "WebApp::WebApp::NavigationGraph",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Application::rootComponent": {
-      "kind": "reference",
-      "type": "ComponentDefinition",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Application::rootComponentExpression": {
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Application::router": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Application::startupMode": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "WebApp::WebApp::Asset": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "WebApp::WebApp::Asset::contentHash": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Asset::kind": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Asset::path": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "WebApp::WebApp::NavigationGraph": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "WebApp::WebApp::NavigationGraph::adapter": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::NavigationGraph::router": {
-      "kind": "attribute",
-      "type": "String"
-    },
-    "WebApp::WebApp::NavigationGraph::routes": {
-      "kind": "part",
-      "type": "WebApp::WebApp::Route",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "WebApp::WebApp::Route": {
-      "spec": "application-schema",
-      "idlKind": "datatype",
-      "kind": "part"
-    },
-    "WebApp::WebApp::Route::children": {
-      "kind": "part",
-      "type": "WebApp::WebApp::Route",
-      "multiplicity": "[0..*]",
-      "ordered": true
-    },
-    "WebApp::WebApp::Route::component": {
-      "kind": "reference",
-      "type": "ComponentDefinition",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Route::componentExpression": {
-      "kind": "attribute",
-      "type": "SourceExpression",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Route::name": {
-      "kind": "attribute",
-      "type": "String",
-      "multiplicity": "[0..1]"
-    },
-    "WebApp::WebApp::Route::path": {
-      "kind": "attribute",
-      "type": "String"
-    }
-  },
-  "omitted": {}
-}
diff --git a/local-packages/WebApp.sysml b/local-packages/WebApp.sysml
deleted file mode 100644
index 960faa0..0000000
--- a/local-packages/WebApp.sysml
+++ /dev/null
@@ -1,41 +0,0 @@
-library package WebApp {
-    doc /* Framework-neutral Web application layer: entry modules that mount or hydrate a root
-       component, static assets, and an optional navigation graph a router adapter supplies.
-       GENERATED from the generator's application schema - do not edit; regenerate with
-       the websysml generator.
-       */
-    private import ScalarValues::*;
-    private import Template::*;
-
-    part def Application {
-        attribute entryModule : String;
-        attribute startupMode : String;
-        attribute mountTarget : SourceExpression[0..1];
-        ref part rootComponent : ComponentDefinition[0..1];
-        attribute rootComponentExpression : SourceExpression[0..1];
-        attribute router : String[0..1];
-        part assets : Asset[0..*] ordered;
-        part navigation : NavigationGraph[0..1];
-        part dependencies : SourceDependency[0..*] ordered;
-    }
-
-    part def Asset {
-        attribute path : String;
-        attribute kind : String[0..1];
-        attribute contentHash : String[0..1];
-    }
-
-    part def NavigationGraph {
-        attribute router : String;
-        attribute adapter : String[0..1];
-        part routes : Route[0..*] ordered;
-    }
-
-    part def Route {
-        attribute path : String;
-        attribute name : String[0..1];
-        ref part component : ComponentDefinition[0..1];
-        attribute componentExpression : SourceExpression[0..1];
-        part children : Route[0..*] ordered;
-    }
-}
diff --git a/spec-refs/README.md b/spec-refs/README.md
index d554b33..2ffd682 100644
--- a/spec-refs/README.md
+++ b/spec-refs/README.md
@@ -1,6 +1,6 @@
 # Specification references and test corpus
 
-Reference material vendored for grammar fidelity and corpus testing. The reference files are development/test inputs, not runtime dependencies. Checked-in Rust tables are generated from the schemas and XMI; the optional WASM package bundles standard-library sources and a resolution snapshot during its build.
+Reference material vendored for grammar fidelity and corpus testing. The reference files are development/test inputs, not runtime dependencies. Checked-in Rust tables are generated from the schemas and XMI; the optional WASM package bundles standard-library sources and a resolution snapshot during its build, and ships the library's EPL-2.0 license and upstream notices with them. The two corpus directories are git submodules: this repository records their pinned revisions, not their files.
 
 Current corpus pins: `SysML-v2-Release` at `de1070ae8e79c21532b8004fc663d47b35d0e9fa`, and `apollo-11-sysml-v2` at `6e9c93fe7d80c5ca3534bb14b10ab374a643ef2d`. The official gate covers 94 library units and 251 user files (345 total). See also the [external static-rule fixtures](../crates/sysmlv2-parser/tests/fixtures/opensysml/README.md), whose provenance and contracts are checked in separately.
 
@@ -9,12 +9,12 @@ Current corpus pins: `SysML-v2-Release` at `de1070ae8e79c21532b8004fc663d47b35d0
 | `KerML.xtext` | Normative KerML structural grammar | [SysML-v2-Pilot-Implementation](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation) `org.omg.kerml.xtext` (master; metamodel 20250201) | EPL-2.0 |
 | `KerMLExpressions.xtext` | Normative terminals + expression grammar (shared by both dialects) | same, `org.omg.kerml.expressions.xtext` | EPL-2.0 |
 | `SysML.xtext` | Normative SysML v2 textual-notation grammar | same, `org.omg.sysml.xtext` | EPL-2.0 |
-| `SysML.schema.json` | Normative abstract-syntax JSON schema (drives the full-form property catalog + validation gates) | https://www.omg.org/spec/SysML/20250201/SysML.json | OMG spec file |
-| `KerML.schema.json` | Normative KerML abstract-syntax JSON schema | https://www.omg.org/spec/KerML/20250201/KerML.json | OMG spec file |
-| `KerML.xmi` | Normative KerML metamodel XMI — the authoritative owned-vs-derived property split (`isDerived`), defaults, and multiplicities per metaclass (drives the property-audit gate via `tools/xmi_props.py`) | https://www.omg.org/spec/KerML/20250201/KerML.xmi | OMG spec file |
-| `SysML.xmi` | Normative SysML v2 metamodel XMI (93 classes generalizing into `KerML.xmi` by href) | https://www.omg.org/spec/SysML/20250201/SysML.xmi | OMG spec file |
-| `derived-properties.json`, `derived-properties.md` | Generated census of the metamodel's 279 derived property names (declaring metaclasses, type, multiplicity, OCL rule, computation class, emitter status) — output of `tools/derived_census.py`, regenerate rather than edit | this repository | Apache-2.0 |
-| `SysML-v2-Release/` | Test corpus: `sysml.library/` (standard + domain + kernel libraries), `sysml/src/{examples,training,validation}` — git submodule; a sparse, blob-filtered checkout of those four directories is enough (`git submodule update --init --filter=blob:none spec-refs/SysML-v2-Release`, then `git -C spec-refs/SysML-v2-Release sparse-checkout set sysml.library sysml/src/examples sysml/src/training sysml/src/validation`) — the corpus gates read only them | [SysML-v2-Release](https://github.com/Systems-Modeling/SysML-v2-Release) | LGPL-3.0 |
+| `SysML.schema.json` | Normative abstract-syntax JSON schema (drives the full-form property catalog + validation gates) | https://www.omg.org/spec/SysML/20250201/SysML.json | OMG specification terms |
+| `KerML.schema.json` | Normative KerML abstract-syntax JSON schema | https://www.omg.org/spec/KerML/20250201/KerML.json | OMG specification terms |
+| `KerML.xmi` | Normative KerML metamodel XMI — the authoritative owned-vs-derived property split (`isDerived`), defaults, and multiplicities per metaclass (drives the property-audit gate via `tools/xmi_props.py`) | https://www.omg.org/spec/KerML/20250201/KerML.xmi | OMG specification terms |
+| `SysML.xmi` | Normative SysML v2 metamodel XMI (93 classes generalizing into `KerML.xmi` by href) | https://www.omg.org/spec/SysML/20250201/SysML.xmi | OMG specification terms |
+| `derived-properties.json`, `derived-properties.md`, `derived-correspondence.json` | Generated census of the metamodel's 279 derived property names (declaring metaclasses, type, multiplicity, OCL rule, computation class, emitter status) — output of `tools/derived_census.py`, regenerate rather than edit; the correspondence table (every schema property with its fidelity) is written by `cargo run --example derived_correspondence` | this repository | Apache-2.0 |
+| `SysML-v2-Release/` | Test corpus: `sysml.library/` (standard + domain + kernel libraries), `sysml/src/{examples,training,validation}` — git submodule; a sparse, blob-filtered checkout of those four directories is enough (`git submodule update --init --filter=blob:none spec-refs/SysML-v2-Release`, then `git -C spec-refs/SysML-v2-Release sparse-checkout set sysml.library sysml/src/examples sysml/src/training sysml/src/validation`) — the corpus gates read only them | [SysML-v2-Release](https://github.com/Systems-Modeling/SysML-v2-Release) | EPL-2.0 |
 | `apollo-11-sysml-v2/` | External validation corpus: Airbus Central R&T's Apollo 11 mission model (28 files, five-layer CoSMA framework) — git submodule, the first substantial model independent of the OMG pilot lineage; gates in `tests/apollo.rs` skip when uninitialized | [airbus/apollo-11-sysml-v2](https://github.com/airbus/apollo-11-sysml-v2) | MPL-2.0 |
 
 Related normative documents (not vendored):
diff --git a/spec-refs/derived-correspondence.json b/spec-refs/derived-correspondence.json
index ebb49c5..b8c38ed 100644
--- a/spec-refs/derived-correspondence.json
+++ b/spec-refs/derived-correspondence.json
@@ -4,8 +4,8 @@
   "rows": [
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22,8 +22,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70,8 +70,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95,7 +95,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107,7 +107,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -143,7 +143,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -167,7 +167,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -179,7 +179,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -203,7 +203,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -215,7 +215,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -226,8 +226,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -239,7 +239,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -251,7 +251,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -263,7 +263,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -413,7 +413,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -425,7 +425,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -784,8 +784,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -797,7 +797,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1169,7 +1169,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1193,7 +1193,7 @@
     {
       "declaredOn": "AcceptActionUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -1258,8 +1258,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1283,7 +1283,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AcceptActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1319,7 +1319,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1361,7 +1361,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1373,7 +1373,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1403,7 +1403,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1415,7 +1415,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1427,7 +1427,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1439,7 +1439,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1451,7 +1451,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1463,7 +1463,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1475,7 +1475,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1553,7 +1553,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1565,7 +1565,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -1601,7 +1601,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2165,7 +2165,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2201,7 +2201,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -2237,7 +2237,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2272,8 +2272,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2290,8 +2290,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2338,8 +2338,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2363,7 +2363,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2375,7 +2375,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2411,7 +2411,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2435,7 +2435,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2447,7 +2447,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2471,7 +2471,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2483,7 +2483,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2494,8 +2494,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -2507,7 +2507,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2519,7 +2519,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2531,7 +2531,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2681,7 +2681,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -2693,7 +2693,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3052,8 +3052,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3065,7 +3065,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3437,7 +3437,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3490,8 +3490,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3515,7 +3515,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3917,7 +3917,7 @@
     {
       "declaredOn": "AllocationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3929,7 +3929,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -3941,7 +3941,7 @@
     {
       "declaredOn": "ConnectionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3977,7 +3977,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -3989,7 +3989,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4019,7 +4019,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4031,7 +4031,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4043,7 +4043,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4055,7 +4055,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4067,7 +4067,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4079,7 +4079,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4091,7 +4091,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4175,7 +4175,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4187,7 +4187,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4223,7 +4223,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4823,7 +4823,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4853,7 +4853,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -4871,7 +4871,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -4907,7 +4907,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4948,8 +4948,8 @@
     },
     {
       "declaredOn": "AllocationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4960,8 +4960,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4984,8 +4984,8 @@
     },
     {
       "declaredOn": "ConnectionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -4997,7 +4997,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5044,8 +5044,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5069,7 +5069,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5081,7 +5081,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5117,7 +5117,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5141,7 +5141,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5153,7 +5153,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5177,7 +5177,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5189,7 +5189,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5200,8 +5200,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -5213,7 +5213,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5225,7 +5225,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5237,7 +5237,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5380,8 +5380,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5405,7 +5405,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5417,7 +5417,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5776,8 +5776,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -5789,7 +5789,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6172,8 +6172,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6202,8 +6202,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6215,7 +6215,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6245,7 +6245,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -6263,7 +6263,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6286,8 +6286,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6311,7 +6311,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AllocationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6347,7 +6347,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6359,7 +6359,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6377,7 +6377,7 @@
     {
       "declaredOn": "CalculationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6413,7 +6413,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6425,7 +6425,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6455,7 +6455,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6467,7 +6467,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -6479,7 +6479,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6491,7 +6491,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6503,7 +6503,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6515,7 +6515,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6527,7 +6527,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6539,7 +6539,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6629,7 +6629,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6641,7 +6641,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -6677,7 +6677,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..1",
       "ordered": true,
@@ -6689,7 +6689,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7253,7 +7253,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7277,7 +7277,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -7289,7 +7289,7 @@
     {
       "declaredOn": "AnalysisCaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -7313,7 +7313,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -7325,7 +7325,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -7361,7 +7361,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7396,8 +7396,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7409,7 +7409,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7426,8 +7426,8 @@
     },
     {
       "declaredOn": "AnalysisCaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -7438,8 +7438,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7450,8 +7450,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -7462,8 +7462,8 @@
     },
     {
       "declaredOn": "CaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -7510,8 +7510,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7535,7 +7535,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7547,7 +7547,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7583,7 +7583,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7607,7 +7607,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7619,7 +7619,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7643,7 +7643,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7654,8 +7654,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -7667,7 +7667,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7678,8 +7678,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -7691,7 +7691,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7703,7 +7703,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7715,7 +7715,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7877,7 +7877,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -7889,7 +7889,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -8249,7 +8249,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -8260,8 +8260,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -8273,7 +8273,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -8645,7 +8645,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -8675,7 +8675,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -8687,7 +8687,7 @@
     {
       "declaredOn": "AnalysisCaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -8711,7 +8711,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -8734,8 +8734,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -8759,7 +8759,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AnalysisCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9304,8 +9304,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9328,8 +9328,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -9364,8 +9364,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9389,7 +9389,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9401,7 +9401,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9437,7 +9437,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9461,7 +9461,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9473,7 +9473,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9497,7 +9497,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9508,8 +9508,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -9521,7 +9521,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9532,8 +9532,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -9545,7 +9545,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9557,7 +9557,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9569,7 +9569,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9737,7 +9737,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -9749,7 +9749,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10108,8 +10108,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10121,7 +10121,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10493,7 +10493,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10510,8 +10510,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -10535,7 +10535,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -10570,8 +10570,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10595,7 +10595,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssertConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10630,8 +10630,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10648,8 +10648,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10696,8 +10696,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10721,7 +10721,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10733,7 +10733,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10769,7 +10769,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10793,7 +10793,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10805,7 +10805,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10829,7 +10829,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10841,7 +10841,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10852,8 +10852,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -10865,7 +10865,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10877,7 +10877,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -10889,7 +10889,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11039,7 +11039,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11051,7 +11051,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11410,8 +11410,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11423,7 +11423,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11795,7 +11795,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11872,8 +11872,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11897,7 +11897,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssignmentActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -11951,7 +11951,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": false,
@@ -11987,7 +11987,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12017,7 +12017,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12029,7 +12029,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12041,7 +12041,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12053,7 +12053,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12065,7 +12065,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12077,7 +12077,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12089,7 +12089,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12161,7 +12161,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12173,7 +12173,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12209,7 +12209,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12485,7 +12485,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12515,7 +12515,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..1",
       "ordered": false,
@@ -12533,7 +12533,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Association",
       "multiplicity": "0..*",
       "ordered": false,
@@ -12575,7 +12575,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": false,
@@ -12611,7 +12611,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12641,7 +12641,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12653,7 +12653,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12665,7 +12665,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12677,7 +12677,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12689,7 +12689,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12701,7 +12701,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12713,7 +12713,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12785,7 +12785,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12797,7 +12797,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -12833,7 +12833,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13109,7 +13109,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13139,7 +13139,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..1",
       "ordered": false,
@@ -13157,7 +13157,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AssociationStructure",
       "multiplicity": "0..*",
       "ordered": false,
@@ -13223,7 +13223,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13235,7 +13235,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13265,7 +13265,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13277,7 +13277,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13289,7 +13289,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13301,7 +13301,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13313,7 +13313,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13325,7 +13325,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13337,7 +13337,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13409,7 +13409,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13421,7 +13421,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -13457,7 +13457,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14069,7 +14069,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14110,8 +14110,8 @@
     },
     {
       "declaredOn": "AttributeUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14158,8 +14158,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14183,7 +14183,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14195,7 +14195,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14231,7 +14231,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14255,7 +14255,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14267,7 +14267,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14291,7 +14291,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14303,7 +14303,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14315,7 +14315,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14327,7 +14327,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14339,7 +14339,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14483,7 +14483,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14495,7 +14495,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -14855,7 +14855,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15262,8 +15262,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15287,7 +15287,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "AttributeUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15353,7 +15353,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15383,7 +15383,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15395,7 +15395,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15407,7 +15407,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15419,7 +15419,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15431,7 +15431,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15443,7 +15443,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15455,7 +15455,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15521,7 +15521,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15533,7 +15533,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15569,7 +15569,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15809,7 +15809,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15845,7 +15845,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Behavior",
       "multiplicity": "0..*",
       "ordered": false,
@@ -15886,8 +15886,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15911,7 +15911,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -15971,7 +15971,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16007,7 +16007,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16031,7 +16031,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16043,7 +16043,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16067,7 +16067,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16079,7 +16079,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16091,7 +16091,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16103,7 +16103,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16115,7 +16115,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16235,7 +16235,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16247,7 +16247,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16283,7 +16283,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16654,8 +16654,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16667,7 +16667,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16697,7 +16697,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..1",
       "ordered": true,
@@ -16715,7 +16715,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16738,8 +16738,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16768,8 +16768,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16793,7 +16793,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16840,8 +16840,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16865,7 +16865,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16877,7 +16877,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16913,7 +16913,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16937,7 +16937,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16949,7 +16949,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16973,7 +16973,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16985,7 +16985,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -16997,7 +16997,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17009,7 +17009,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17021,7 +17021,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17171,7 +17171,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17183,7 +17183,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17543,7 +17543,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17938,8 +17938,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17951,7 +17951,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -17981,7 +17981,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -17999,7 +17999,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18022,8 +18022,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18047,7 +18047,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BindingConnectorAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18088,8 +18088,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18149,7 +18149,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18185,7 +18185,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18209,7 +18209,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18221,7 +18221,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18245,7 +18245,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18256,8 +18256,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -18269,7 +18269,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18281,7 +18281,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18293,7 +18293,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18305,7 +18305,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18431,7 +18431,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18443,7 +18443,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18479,7 +18479,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18827,7 +18827,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18838,8 +18838,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -18863,7 +18863,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -18898,8 +18898,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "BooleanExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18923,7 +18923,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18941,7 +18941,7 @@
     {
       "declaredOn": "CalculationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18977,7 +18977,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -18989,7 +18989,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19019,7 +19019,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19031,7 +19031,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -19043,7 +19043,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19055,7 +19055,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19067,7 +19067,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19079,7 +19079,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19091,7 +19091,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19103,7 +19103,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19193,7 +19193,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19205,7 +19205,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19241,7 +19241,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19805,7 +19805,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19829,7 +19829,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -19853,7 +19853,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -19889,7 +19889,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19924,8 +19924,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19942,8 +19942,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -19954,8 +19954,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -20002,8 +20002,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20027,7 +20027,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20039,7 +20039,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20075,7 +20075,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20099,7 +20099,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20111,7 +20111,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20135,7 +20135,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20146,8 +20146,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -20159,7 +20159,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20170,8 +20170,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -20183,7 +20183,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20195,7 +20195,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20207,7 +20207,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20369,7 +20369,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20381,7 +20381,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20740,8 +20740,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -20753,7 +20753,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21125,7 +21125,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21155,7 +21155,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -21190,8 +21190,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21215,7 +21215,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CalculationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21251,7 +21251,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21263,7 +21263,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21281,7 +21281,7 @@
     {
       "declaredOn": "CalculationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21317,7 +21317,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21329,7 +21329,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21359,7 +21359,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21371,7 +21371,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -21383,7 +21383,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21395,7 +21395,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21407,7 +21407,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21419,7 +21419,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21431,7 +21431,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21443,7 +21443,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21533,7 +21533,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21545,7 +21545,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -21581,7 +21581,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..1",
       "ordered": true,
@@ -21593,7 +21593,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22157,7 +22157,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22181,7 +22181,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -22205,7 +22205,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -22217,7 +22217,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -22253,7 +22253,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22288,8 +22288,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22301,7 +22301,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22318,8 +22318,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22330,8 +22330,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -22342,8 +22342,8 @@
     },
     {
       "declaredOn": "CaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -22390,8 +22390,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22415,7 +22415,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22427,7 +22427,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22463,7 +22463,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22487,7 +22487,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22499,7 +22499,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22523,7 +22523,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22534,8 +22534,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -22547,7 +22547,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22558,8 +22558,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -22571,7 +22571,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22583,7 +22583,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22595,7 +22595,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22757,7 +22757,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -22769,7 +22769,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23129,7 +23129,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -23140,8 +23140,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23153,7 +23153,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23525,7 +23525,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23555,7 +23555,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -23579,7 +23579,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -23602,8 +23602,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23627,7 +23627,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23693,7 +23693,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23723,7 +23723,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23735,7 +23735,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23747,7 +23747,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23759,7 +23759,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23771,7 +23771,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23783,7 +23783,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23795,7 +23795,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23861,7 +23861,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23873,7 +23873,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -23909,7 +23909,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Class",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24227,7 +24227,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24257,7 +24257,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24269,7 +24269,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24281,7 +24281,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24293,7 +24293,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24305,7 +24305,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24317,7 +24317,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24329,7 +24329,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24395,7 +24395,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24407,7 +24407,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24443,7 +24443,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Classifier",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24737,7 +24737,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24748,8 +24748,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24809,7 +24809,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24845,7 +24845,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24869,7 +24869,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24881,7 +24881,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24905,7 +24905,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24916,8 +24916,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -24929,7 +24929,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24941,7 +24941,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24953,7 +24953,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -24965,7 +24965,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25103,7 +25103,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25115,7 +25115,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25157,7 +25157,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25505,7 +25505,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25529,7 +25529,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -25564,8 +25564,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "CollectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25823,7 +25823,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25877,7 +25877,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25889,7 +25889,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25919,7 +25919,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25931,7 +25931,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -25943,7 +25943,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25955,7 +25955,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25967,7 +25967,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25979,7 +25979,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -25991,7 +25991,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26003,7 +26003,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26015,7 +26015,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26105,7 +26105,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26117,7 +26117,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26153,7 +26153,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26717,7 +26717,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26759,7 +26759,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -26783,7 +26783,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26795,7 +26795,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -26807,7 +26807,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -26855,7 +26855,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26891,7 +26891,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26920,8 +26920,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -26944,8 +26944,8 @@
     },
     {
       "declaredOn": "ConcernUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -26956,8 +26956,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -26992,8 +26992,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27017,7 +27017,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27029,7 +27029,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27065,7 +27065,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27089,7 +27089,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27101,7 +27101,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27125,7 +27125,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27137,7 +27137,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27148,8 +27148,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -27161,7 +27161,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27172,8 +27172,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -27185,7 +27185,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27197,7 +27197,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27209,7 +27209,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27371,7 +27371,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27383,7 +27383,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27742,8 +27742,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -27755,7 +27755,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28127,7 +28127,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28144,8 +28144,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -28186,8 +28186,8 @@
     },
     {
       "declaredOn": "RequirementUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -28199,7 +28199,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -28223,7 +28223,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28235,7 +28235,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -28270,8 +28270,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28295,7 +28295,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConcernUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28373,7 +28373,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28385,7 +28385,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28415,7 +28415,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28427,7 +28427,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28439,7 +28439,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28451,7 +28451,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28463,7 +28463,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28475,7 +28475,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28487,7 +28487,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28565,7 +28565,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28577,7 +28577,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -28625,7 +28625,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29249,7 +29249,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConjugatedPortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29476,8 +29476,8 @@
     },
     {
       "declaredOn": "ConjugatedPortTyping",
-      "fidelity": "not-computed",
-      "fidelityUnderClosure": "not-computed",
+      "fidelity": "exact",
+      "fidelityUnderClosure": "exact",
       "metaclass": "ConjugatedPortTyping",
       "multiplicity": "1..1",
       "ordered": false,
@@ -29813,7 +29813,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -29825,7 +29825,7 @@
     {
       "declaredOn": "ConnectionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29861,7 +29861,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29873,7 +29873,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29903,7 +29903,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29915,7 +29915,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29927,7 +29927,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29939,7 +29939,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29951,7 +29951,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29963,7 +29963,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -29975,7 +29975,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30059,7 +30059,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30071,7 +30071,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30107,7 +30107,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30707,7 +30707,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30737,7 +30737,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -30755,7 +30755,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -30791,7 +30791,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30832,8 +30832,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30856,8 +30856,8 @@
     },
     {
       "declaredOn": "ConnectionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30869,7 +30869,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30916,8 +30916,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30941,7 +30941,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30953,7 +30953,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -30989,7 +30989,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31013,7 +31013,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31025,7 +31025,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31049,7 +31049,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31061,7 +31061,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31072,8 +31072,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -31085,7 +31085,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31097,7 +31097,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31109,7 +31109,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31252,8 +31252,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31277,7 +31277,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31289,7 +31289,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31648,8 +31648,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -31661,7 +31661,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32044,8 +32044,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32074,8 +32074,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32087,7 +32087,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32117,7 +32117,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -32135,7 +32135,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32158,8 +32158,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32183,7 +32183,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConnectionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32224,8 +32224,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32249,7 +32249,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32309,7 +32309,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32345,7 +32345,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32369,7 +32369,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32381,7 +32381,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32405,7 +32405,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32417,7 +32417,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32429,7 +32429,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32441,7 +32441,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32453,7 +32453,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32573,7 +32573,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32585,7 +32585,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32621,7 +32621,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -32992,8 +32992,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33005,7 +33005,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33035,7 +33035,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..1",
       "ordered": true,
@@ -33053,7 +33053,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33076,8 +33076,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Connector",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33131,7 +33131,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33143,7 +33143,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33173,7 +33173,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33185,7 +33185,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -33197,7 +33197,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33209,7 +33209,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33221,7 +33221,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33233,7 +33233,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33245,7 +33245,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33257,7 +33257,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33347,7 +33347,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33359,7 +33359,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33395,7 +33395,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33959,7 +33959,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -33983,7 +33983,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -34007,7 +34007,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -34043,7 +34043,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34084,8 +34084,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34108,8 +34108,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -34144,8 +34144,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34169,7 +34169,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34181,7 +34181,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34217,7 +34217,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34241,7 +34241,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34253,7 +34253,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34277,7 +34277,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34288,8 +34288,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -34301,7 +34301,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34312,8 +34312,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -34325,7 +34325,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34337,7 +34337,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34349,7 +34349,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34511,7 +34511,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34523,7 +34523,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34882,8 +34882,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -34895,7 +34895,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35267,7 +35267,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35284,8 +35284,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -35309,7 +35309,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -35344,8 +35344,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35369,7 +35369,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstraintUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35411,7 +35411,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35422,8 +35422,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35483,7 +35483,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35519,7 +35519,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35543,7 +35543,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35555,7 +35555,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35579,7 +35579,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35590,8 +35590,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -35603,7 +35603,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35615,7 +35615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35627,7 +35627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35639,7 +35639,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35777,7 +35777,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35789,7 +35789,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -35825,7 +35825,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36173,7 +36173,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36197,7 +36197,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -36232,8 +36232,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ConstructorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36569,7 +36569,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36599,7 +36599,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36611,7 +36611,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36623,7 +36623,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36635,7 +36635,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36647,7 +36647,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36659,7 +36659,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36671,7 +36671,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36737,7 +36737,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36749,7 +36749,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -36785,7 +36785,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DataType",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37072,8 +37072,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37090,8 +37090,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37138,8 +37138,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37163,7 +37163,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37175,7 +37175,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37211,7 +37211,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37235,7 +37235,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37247,7 +37247,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37271,7 +37271,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37283,7 +37283,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37294,8 +37294,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..1",
       "ordered": false,
@@ -37307,7 +37307,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37319,7 +37319,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37331,7 +37331,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37481,7 +37481,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37493,7 +37493,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37852,8 +37852,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -37865,7 +37865,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38237,7 +38237,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38290,8 +38290,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38315,7 +38315,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "DecisionNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38381,7 +38381,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38393,7 +38393,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38423,7 +38423,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38435,7 +38435,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38447,7 +38447,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38459,7 +38459,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38471,7 +38471,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38483,7 +38483,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38495,7 +38495,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38567,7 +38567,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38579,7 +38579,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -38615,7 +38615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -39227,7 +39227,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Definition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40901,7 +40901,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40913,7 +40913,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40943,7 +40943,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40967,7 +40967,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40979,7 +40979,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -40991,7 +40991,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41003,7 +41003,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41015,7 +41015,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41027,7 +41027,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41099,7 +41099,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41111,7 +41111,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41147,7 +41147,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41759,7 +41759,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41800,8 +41800,8 @@
     },
     {
       "declaredOn": "AttributeUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41848,8 +41848,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41873,7 +41873,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41885,7 +41885,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41921,7 +41921,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41944,8 +41944,8 @@
     },
     {
       "declaredOn": "EnumerationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -41957,7 +41957,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41969,7 +41969,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -41993,7 +41993,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42005,7 +42005,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42017,7 +42017,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42029,7 +42029,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42041,7 +42041,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42185,7 +42185,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42197,7 +42197,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42557,7 +42557,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42964,8 +42964,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -42989,7 +42989,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EnumerationUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43066,8 +43066,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43091,7 +43091,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43103,7 +43103,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43139,7 +43139,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43175,7 +43175,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43187,7 +43187,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43211,7 +43211,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43223,7 +43223,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43234,8 +43234,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -43247,7 +43247,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43259,7 +43259,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43271,7 +43271,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43421,7 +43421,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43433,7 +43433,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43792,8 +43792,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -43805,7 +43805,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44218,8 +44218,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44243,7 +44243,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "EventOccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44278,8 +44278,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44296,8 +44296,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44344,8 +44344,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44369,7 +44369,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44381,7 +44381,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44429,7 +44429,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44501,7 +44501,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44513,7 +44513,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44537,7 +44537,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44549,7 +44549,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44560,8 +44560,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -44573,7 +44573,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44585,7 +44585,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44597,7 +44597,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44753,7 +44753,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -44765,7 +44765,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45124,8 +45124,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45137,7 +45137,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45509,7 +45509,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45562,8 +45562,8 @@
     },
     {
       "declaredOn": "StateUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45586,8 +45586,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45611,7 +45611,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ExhibitStateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45652,8 +45652,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45713,7 +45713,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45749,7 +45749,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45773,7 +45773,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45785,7 +45785,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45809,7 +45809,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45820,8 +45820,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -45833,7 +45833,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45845,7 +45845,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45857,7 +45857,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45869,7 +45869,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -45995,7 +45995,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46007,7 +46007,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46043,7 +46043,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46391,7 +46391,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46415,7 +46415,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -46450,8 +46450,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Expression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46529,7 +46529,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46565,7 +46565,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46589,7 +46589,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46601,7 +46601,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46625,7 +46625,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46637,7 +46637,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46649,7 +46649,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46661,7 +46661,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46673,7 +46673,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46787,7 +46787,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46799,7 +46799,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -46835,7 +46835,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47218,8 +47218,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Feature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47249,7 +47249,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47260,8 +47260,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47321,7 +47321,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47357,7 +47357,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47381,7 +47381,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47393,7 +47393,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47417,7 +47417,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47428,8 +47428,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -47441,7 +47441,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47453,7 +47453,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47465,7 +47465,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47477,7 +47477,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47615,7 +47615,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47627,7 +47627,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -47669,7 +47669,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -48017,7 +48017,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -48041,7 +48041,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -48088,8 +48088,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureChainExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -48928,8 +48928,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -48989,7 +48989,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49025,7 +49025,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49049,7 +49049,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49061,7 +49061,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49085,7 +49085,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49096,8 +49096,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -49109,7 +49109,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49121,7 +49121,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49133,7 +49133,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49145,7 +49145,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49271,7 +49271,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49283,7 +49283,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49319,7 +49319,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49667,7 +49667,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -49703,7 +49703,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -49738,8 +49738,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FeatureReferenceExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50380,8 +50380,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50392,8 +50392,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50417,7 +50417,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50477,7 +50477,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50513,7 +50513,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50537,7 +50537,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50549,7 +50549,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50573,7 +50573,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50585,7 +50585,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..2",
       "ordered": true,
@@ -50597,7 +50597,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50609,7 +50609,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50621,7 +50621,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50633,7 +50633,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50644,8 +50644,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50765,7 +50765,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50777,7 +50777,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -50813,7 +50813,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51173,7 +51173,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51196,8 +51196,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51220,8 +51220,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51233,7 +51233,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51263,7 +51263,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -51275,7 +51275,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -51293,7 +51293,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51305,7 +51305,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -51328,8 +51328,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Flow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51353,7 +51353,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51371,7 +51371,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -51407,7 +51407,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51419,7 +51419,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51449,7 +51449,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51461,7 +51461,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51473,7 +51473,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51497,7 +51497,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51509,7 +51509,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51521,7 +51521,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51533,7 +51533,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51617,7 +51617,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51629,7 +51629,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -51665,7 +51665,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52241,7 +52241,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52277,7 +52277,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52307,7 +52307,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -52319,7 +52319,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -52337,7 +52337,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -52373,7 +52373,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52463,7 +52463,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52499,7 +52499,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52523,7 +52523,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52535,7 +52535,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52559,7 +52559,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52571,7 +52571,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52583,7 +52583,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52595,7 +52595,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52607,7 +52607,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52721,7 +52721,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52733,7 +52733,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -52769,7 +52769,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53152,8 +53152,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowEnd",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53176,8 +53176,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53194,8 +53194,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53206,8 +53206,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53231,7 +53231,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53278,8 +53278,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53303,7 +53303,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53315,7 +53315,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53351,7 +53351,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53375,7 +53375,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53387,7 +53387,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53411,7 +53411,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53422,8 +53422,8 @@
     },
     {
       "declaredOn": "FlowUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53435,7 +53435,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..2",
       "ordered": true,
@@ -53447,7 +53447,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53458,8 +53458,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -53471,7 +53471,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53483,7 +53483,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53495,7 +53495,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53506,8 +53506,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53663,7 +53663,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -53675,7 +53675,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54034,8 +54034,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54047,7 +54047,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54431,7 +54431,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54454,8 +54454,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54484,8 +54484,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54497,7 +54497,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54527,7 +54527,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -54539,7 +54539,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -54557,7 +54557,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54569,7 +54569,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -54592,8 +54592,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54617,7 +54617,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "FlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54652,8 +54652,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54670,8 +54670,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54730,8 +54730,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54755,7 +54755,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54767,7 +54767,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54803,7 +54803,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54827,7 +54827,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54839,7 +54839,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54863,7 +54863,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54875,7 +54875,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54886,8 +54886,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -54899,7 +54899,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54911,7 +54911,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -54923,7 +54923,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55085,7 +55085,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55097,7 +55097,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55456,8 +55456,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55469,7 +55469,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55841,7 +55841,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55906,8 +55906,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55931,7 +55931,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55966,8 +55966,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -55984,8 +55984,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56032,8 +56032,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56057,7 +56057,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56069,7 +56069,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56105,7 +56105,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56129,7 +56129,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56141,7 +56141,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56165,7 +56165,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56177,7 +56177,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56188,8 +56188,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..1",
       "ordered": false,
@@ -56201,7 +56201,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56213,7 +56213,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56225,7 +56225,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56375,7 +56375,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56387,7 +56387,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56746,8 +56746,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -56759,7 +56759,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57131,7 +57131,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57184,8 +57184,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57209,7 +57209,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ForkNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57665,7 +57665,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57695,7 +57695,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57707,7 +57707,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": false,
@@ -57719,7 +57719,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57731,7 +57731,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57743,7 +57743,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57755,7 +57755,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57767,7 +57767,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57779,7 +57779,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57857,7 +57857,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57869,7 +57869,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -57905,7 +57905,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58145,7 +58145,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58169,7 +58169,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "1..1",
       "ordered": false,
@@ -58193,7 +58193,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Function",
       "multiplicity": "0..*",
       "ordered": false,
@@ -58228,8 +58228,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58246,8 +58246,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58294,8 +58294,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58319,7 +58319,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58331,7 +58331,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58379,7 +58379,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58403,7 +58403,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58415,7 +58415,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58439,7 +58439,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58463,7 +58463,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58474,8 +58474,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -58487,7 +58487,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58499,7 +58499,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58511,7 +58511,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58661,7 +58661,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -58673,7 +58673,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59032,8 +59032,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59045,7 +59045,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59417,7 +59417,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59482,8 +59482,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59507,7 +59507,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IfActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59542,8 +59542,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59555,7 +59555,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59572,8 +59572,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59584,8 +59584,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -59596,8 +59596,8 @@
     },
     {
       "declaredOn": "CaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -59644,8 +59644,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59669,7 +59669,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59681,7 +59681,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59717,7 +59717,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59753,7 +59753,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59765,7 +59765,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59789,7 +59789,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59800,8 +59800,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -59813,7 +59813,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59836,8 +59836,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -59849,7 +59849,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59861,7 +59861,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -59873,7 +59873,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60035,7 +60035,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60047,7 +60047,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60407,7 +60407,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -60418,8 +60418,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60431,7 +60431,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60803,7 +60803,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60845,7 +60845,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -60869,7 +60869,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -60892,8 +60892,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60917,7 +60917,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60928,8 +60928,8 @@
     },
     {
       "declaredOn": "UseCaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IncludeUseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -60983,7 +60983,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -60994,8 +60994,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61055,7 +61055,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61091,7 +61091,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61115,7 +61115,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61127,7 +61127,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61151,7 +61151,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61162,8 +61162,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -61175,7 +61175,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61187,7 +61187,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61199,7 +61199,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61211,7 +61211,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61349,7 +61349,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61361,7 +61361,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61403,7 +61403,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61751,7 +61751,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61775,7 +61775,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -61810,8 +61810,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "IndexExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61841,7 +61841,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": false,
@@ -61877,7 +61877,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61907,7 +61907,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61919,7 +61919,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61931,7 +61931,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61943,7 +61943,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61955,7 +61955,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61967,7 +61967,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -61979,7 +61979,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62051,7 +62051,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62063,7 +62063,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62099,7 +62099,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62351,7 +62351,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62387,7 +62387,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62417,7 +62417,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..1",
       "ordered": false,
@@ -62429,7 +62429,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": false,
@@ -62447,7 +62447,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Interaction",
       "multiplicity": "0..*",
       "ordered": false,
@@ -62489,7 +62489,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -62501,7 +62501,7 @@
     {
       "declaredOn": "ConnectionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62537,7 +62537,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62549,7 +62549,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62579,7 +62579,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62591,7 +62591,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62603,7 +62603,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62615,7 +62615,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62627,7 +62627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62639,7 +62639,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62651,7 +62651,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62663,7 +62663,7 @@
     {
       "declaredOn": "InterfaceDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62747,7 +62747,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62759,7 +62759,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -62795,7 +62795,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63395,7 +63395,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63425,7 +63425,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -63443,7 +63443,7 @@
     {
       "declaredOn": "Association",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -63479,7 +63479,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63520,8 +63520,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63544,8 +63544,8 @@
     },
     {
       "declaredOn": "ConnectionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63557,7 +63557,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63604,8 +63604,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63629,7 +63629,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63641,7 +63641,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63677,7 +63677,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63701,7 +63701,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63713,7 +63713,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63737,7 +63737,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63749,7 +63749,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63760,8 +63760,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -63773,7 +63773,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63785,7 +63785,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63797,7 +63797,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63808,8 +63808,8 @@
     },
     {
       "declaredOn": "InterfaceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": false,
@@ -63952,8 +63952,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63977,7 +63977,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -63989,7 +63989,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64348,8 +64348,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64361,7 +64361,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64744,8 +64744,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64774,8 +64774,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64787,7 +64787,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64817,7 +64817,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -64835,7 +64835,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64858,8 +64858,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -64883,7 +64883,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InterfaceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65158,8 +65158,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65219,7 +65219,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65255,7 +65255,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65279,7 +65279,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65291,7 +65291,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65315,7 +65315,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65326,8 +65326,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..1",
       "ordered": false,
@@ -65339,7 +65339,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65351,7 +65351,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65363,7 +65363,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65375,7 +65375,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65507,7 +65507,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65519,7 +65519,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65555,7 +65555,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65903,7 +65903,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -65914,8 +65914,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..1",
       "ordered": false,
@@ -65939,7 +65939,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "1..1",
       "ordered": false,
@@ -65974,8 +65974,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Invariant",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66005,7 +66005,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66016,8 +66016,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66077,7 +66077,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66113,7 +66113,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66137,7 +66137,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66149,7 +66149,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66173,7 +66173,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66184,8 +66184,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -66197,7 +66197,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66209,7 +66209,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66221,7 +66221,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66233,7 +66233,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66371,7 +66371,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66383,7 +66383,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66419,7 +66419,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66767,7 +66767,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66791,7 +66791,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -66826,8 +66826,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "InvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66881,7 +66881,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66893,7 +66893,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66923,7 +66923,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66935,7 +66935,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66947,7 +66947,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66959,7 +66959,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66971,7 +66971,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66983,7 +66983,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -66995,7 +66995,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67073,7 +67073,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67085,7 +67085,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67121,7 +67121,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67733,7 +67733,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67810,8 +67810,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67835,7 +67835,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67847,7 +67847,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67883,7 +67883,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67907,7 +67907,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67919,7 +67919,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67943,7 +67943,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67955,7 +67955,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67966,8 +67966,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -67979,7 +67979,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -67991,7 +67991,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68003,7 +68003,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68140,8 +68140,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68165,7 +68165,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68177,7 +68177,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68536,8 +68536,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68549,7 +68549,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68962,8 +68962,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -68987,7 +68987,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ItemUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69022,8 +69022,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69040,8 +69040,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69088,8 +69088,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69113,7 +69113,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69125,7 +69125,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69161,7 +69161,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69185,7 +69185,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69197,7 +69197,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69221,7 +69221,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69233,7 +69233,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69244,8 +69244,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..1",
       "ordered": false,
@@ -69257,7 +69257,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69269,7 +69269,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69281,7 +69281,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69431,7 +69431,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69443,7 +69443,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69802,8 +69802,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -69815,7 +69815,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70187,7 +70187,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70240,8 +70240,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70265,7 +70265,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "JoinNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70349,7 +70349,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LibraryPackage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70385,7 +70385,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LibraryPackage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70397,7 +70397,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LibraryPackage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70570,8 +70570,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70631,7 +70631,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70667,7 +70667,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70691,7 +70691,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70703,7 +70703,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70727,7 +70727,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70738,8 +70738,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..1",
       "ordered": false,
@@ -70751,7 +70751,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70763,7 +70763,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70775,7 +70775,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70787,7 +70787,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70913,7 +70913,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70925,7 +70925,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -70961,7 +70961,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71309,7 +71309,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71333,7 +71333,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "1..1",
       "ordered": false,
@@ -71368,8 +71368,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralBoolean",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71404,8 +71404,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71465,7 +71465,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71501,7 +71501,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71525,7 +71525,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71537,7 +71537,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71561,7 +71561,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71572,8 +71572,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -71585,7 +71585,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71597,7 +71597,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71609,7 +71609,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71621,7 +71621,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71747,7 +71747,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71759,7 +71759,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -71795,7 +71795,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72143,7 +72143,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72167,7 +72167,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -72202,8 +72202,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72232,8 +72232,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72293,7 +72293,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72329,7 +72329,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72353,7 +72353,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72365,7 +72365,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72389,7 +72389,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72400,8 +72400,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..1",
       "ordered": false,
@@ -72413,7 +72413,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72425,7 +72425,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72437,7 +72437,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72449,7 +72449,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72575,7 +72575,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72587,7 +72587,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72623,7 +72623,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72971,7 +72971,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -72995,7 +72995,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "1..1",
       "ordered": false,
@@ -73030,8 +73030,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInfinity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73060,8 +73060,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73121,7 +73121,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73157,7 +73157,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73181,7 +73181,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73193,7 +73193,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73217,7 +73217,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73228,8 +73228,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..1",
       "ordered": false,
@@ -73241,7 +73241,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73253,7 +73253,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73265,7 +73265,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73277,7 +73277,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73403,7 +73403,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73415,7 +73415,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73451,7 +73451,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73799,7 +73799,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73823,7 +73823,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "1..1",
       "ordered": false,
@@ -73858,8 +73858,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralInteger",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73894,8 +73894,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73955,7 +73955,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -73991,7 +73991,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74015,7 +74015,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74027,7 +74027,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74051,7 +74051,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74062,8 +74062,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..1",
       "ordered": false,
@@ -74075,7 +74075,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74087,7 +74087,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74099,7 +74099,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74111,7 +74111,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74237,7 +74237,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74249,7 +74249,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74285,7 +74285,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74633,7 +74633,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74657,7 +74657,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "1..1",
       "ordered": false,
@@ -74692,8 +74692,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralRational",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74728,8 +74728,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74789,7 +74789,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74825,7 +74825,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74849,7 +74849,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74861,7 +74861,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74885,7 +74885,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74896,8 +74896,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..1",
       "ordered": false,
@@ -74909,7 +74909,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74921,7 +74921,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74933,7 +74933,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -74945,7 +74945,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -75071,7 +75071,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -75083,7 +75083,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -75119,7 +75119,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -75467,7 +75467,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -75491,7 +75491,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "1..1",
       "ordered": false,
@@ -75526,8 +75526,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "LiteralString",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76348,8 +76348,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76366,8 +76366,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76414,8 +76414,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76439,7 +76439,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76451,7 +76451,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76487,7 +76487,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76511,7 +76511,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76523,7 +76523,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76547,7 +76547,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76559,7 +76559,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76570,8 +76570,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..1",
       "ordered": false,
@@ -76583,7 +76583,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76595,7 +76595,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76607,7 +76607,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76757,7 +76757,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -76769,7 +76769,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77128,8 +77128,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77141,7 +77141,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77513,7 +77513,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77566,8 +77566,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77591,7 +77591,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MergeNode",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77657,7 +77657,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77687,7 +77687,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77699,7 +77699,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77711,7 +77711,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77723,7 +77723,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77735,7 +77735,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77747,7 +77747,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77759,7 +77759,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77825,7 +77825,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77837,7 +77837,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -77873,7 +77873,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Metaclass",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78166,8 +78166,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78227,7 +78227,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78263,7 +78263,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78287,7 +78287,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78299,7 +78299,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78323,7 +78323,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78334,8 +78334,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -78347,7 +78347,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78359,7 +78359,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78371,7 +78371,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78383,7 +78383,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78509,7 +78509,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78521,7 +78521,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78557,7 +78557,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78905,7 +78905,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -78941,7 +78941,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -78976,8 +78976,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataAccessExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79031,7 +79031,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79043,7 +79043,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79073,7 +79073,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79085,7 +79085,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79097,7 +79097,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79109,7 +79109,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79121,7 +79121,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79133,7 +79133,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79145,7 +79145,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79223,7 +79223,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79235,7 +79235,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79271,7 +79271,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79883,7 +79883,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -79997,7 +79997,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80033,7 +80033,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80057,7 +80057,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80069,7 +80069,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80093,7 +80093,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80105,7 +80105,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80117,7 +80117,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80129,7 +80129,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80141,7 +80141,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80255,7 +80255,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80267,7 +80267,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80278,8 +80278,8 @@
     },
     {
       "declaredOn": "MetadataFeature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..1",
       "ordered": false,
@@ -80315,7 +80315,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80722,8 +80722,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80812,8 +80812,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80837,7 +80837,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80849,7 +80849,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80885,7 +80885,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80909,7 +80909,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80921,7 +80921,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80945,7 +80945,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80957,7 +80957,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80968,8 +80968,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -80981,7 +80981,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -80993,7 +80993,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81005,7 +81005,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81142,8 +81142,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81167,7 +81167,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81179,7 +81179,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81190,8 +81190,8 @@
     },
     {
       "declaredOn": "MetadataFeature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -81202,8 +81202,8 @@
     },
     {
       "declaredOn": "MetadataUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -81562,8 +81562,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -81575,7 +81575,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82012,8 +82012,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82037,7 +82037,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MetadataUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82127,7 +82127,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82163,7 +82163,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82187,7 +82187,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82199,7 +82199,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82223,7 +82223,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82235,7 +82235,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82247,7 +82247,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82259,7 +82259,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82271,7 +82271,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82385,7 +82385,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82397,7 +82397,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82433,7 +82433,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82816,8 +82816,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Multiplicity",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82907,7 +82907,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82943,7 +82943,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82967,7 +82967,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -82979,7 +82979,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83003,7 +83003,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83015,7 +83015,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83027,7 +83027,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83039,7 +83039,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83051,7 +83051,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83177,7 +83177,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83189,7 +83189,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83225,7 +83225,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83608,8 +83608,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "MultiplicityRange",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83681,7 +83681,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Namespace",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83711,7 +83711,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Namespace",
       "multiplicity": "0..*",
       "ordered": true,
@@ -83723,7 +83723,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Namespace",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84424,8 +84424,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84485,7 +84485,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84521,7 +84521,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84545,7 +84545,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84557,7 +84557,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84581,7 +84581,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84592,8 +84592,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -84605,7 +84605,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84617,7 +84617,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84629,7 +84629,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84641,7 +84641,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84767,7 +84767,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84779,7 +84779,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -84815,7 +84815,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85163,7 +85163,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85187,7 +85187,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -85222,8 +85222,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "NullExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85625,7 +85625,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85637,7 +85637,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85667,7 +85667,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85679,7 +85679,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85691,7 +85691,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85703,7 +85703,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85715,7 +85715,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85727,7 +85727,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85739,7 +85739,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85817,7 +85817,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85829,7 +85829,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -85865,7 +85865,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86477,7 +86477,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86554,8 +86554,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86579,7 +86579,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86591,7 +86591,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86627,7 +86627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86651,7 +86651,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86663,7 +86663,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86687,7 +86687,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86699,7 +86699,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86710,8 +86710,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -86723,7 +86723,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86735,7 +86735,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86747,7 +86747,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86897,7 +86897,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -86909,7 +86909,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87268,8 +87268,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87281,7 +87281,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87694,8 +87694,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87719,7 +87719,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OccurrenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87761,7 +87761,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87772,8 +87772,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87833,7 +87833,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87869,7 +87869,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87893,7 +87893,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87905,7 +87905,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87929,7 +87929,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87940,8 +87940,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -87953,7 +87953,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87965,7 +87965,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87977,7 +87977,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -87989,7 +87989,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88127,7 +88127,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88139,7 +88139,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88181,7 +88181,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88529,7 +88529,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88553,7 +88553,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -88588,8 +88588,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "OperatorExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -88973,7 +88973,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Package",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89003,7 +89003,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Package",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89015,7 +89015,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Package",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89561,7 +89561,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89573,7 +89573,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89603,7 +89603,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89615,7 +89615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89627,7 +89627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89639,7 +89639,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89651,7 +89651,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89663,7 +89663,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89675,7 +89675,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89753,7 +89753,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89765,7 +89765,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -89801,7 +89801,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90413,7 +90413,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90490,8 +90490,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90515,7 +90515,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90527,7 +90527,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90563,7 +90563,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90587,7 +90587,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90599,7 +90599,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90623,7 +90623,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90635,7 +90635,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90646,8 +90646,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -90659,7 +90659,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90671,7 +90671,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90683,7 +90683,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90820,8 +90820,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90845,7 +90845,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -90857,7 +90857,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91216,8 +91216,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91229,7 +91229,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91600,8 +91600,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91654,8 +91654,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91679,7 +91679,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PartUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91769,7 +91769,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91805,7 +91805,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91829,7 +91829,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91841,7 +91841,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91865,7 +91865,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91877,7 +91877,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91889,7 +91889,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91901,7 +91901,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -91913,7 +91913,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92027,7 +92027,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92039,7 +92039,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92075,7 +92075,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92458,8 +92458,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PayloadFeature",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92482,8 +92482,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92500,8 +92500,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92548,8 +92548,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92573,7 +92573,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92585,7 +92585,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92621,7 +92621,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92657,7 +92657,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92669,7 +92669,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92693,7 +92693,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92705,7 +92705,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92716,8 +92716,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -92729,7 +92729,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92741,7 +92741,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92753,7 +92753,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92903,7 +92903,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -92915,7 +92915,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -93274,8 +93274,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -93287,7 +93287,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -93659,7 +93659,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -93724,8 +93724,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -93749,7 +93749,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PerformActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94085,7 +94085,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94097,7 +94097,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94127,7 +94127,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94139,7 +94139,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94151,7 +94151,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94163,7 +94163,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94175,7 +94175,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94187,7 +94187,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94199,7 +94199,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94277,7 +94277,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94289,7 +94289,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94325,7 +94325,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -94937,7 +94937,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95014,8 +95014,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95039,7 +95039,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95051,7 +95051,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95087,7 +95087,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95111,7 +95111,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95123,7 +95123,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95147,7 +95147,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95159,7 +95159,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95170,8 +95170,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -95183,7 +95183,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95195,7 +95195,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95207,7 +95207,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95357,7 +95357,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95369,7 +95369,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95728,8 +95728,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -95741,7 +95741,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96112,8 +96112,8 @@
     },
     {
       "declaredOn": "PortUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96166,8 +96166,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96191,7 +96191,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "PortUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96257,7 +96257,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96287,7 +96287,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96299,7 +96299,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": false,
@@ -96311,7 +96311,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96323,7 +96323,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96335,7 +96335,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96347,7 +96347,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96359,7 +96359,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96371,7 +96371,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96449,7 +96449,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96461,7 +96461,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96497,7 +96497,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96737,7 +96737,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": true,
@@ -96761,7 +96761,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "1..1",
       "ordered": false,
@@ -96785,7 +96785,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Predicate",
       "multiplicity": "0..*",
       "ordered": false,
@@ -97420,8 +97420,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97445,7 +97445,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97457,7 +97457,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97493,7 +97493,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97517,7 +97517,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97529,7 +97529,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97553,7 +97553,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97565,7 +97565,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97577,7 +97577,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97589,7 +97589,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97601,7 +97601,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97745,7 +97745,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -97757,7 +97757,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98117,7 +98117,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98524,8 +98524,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98549,7 +98549,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ReferenceUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98615,7 +98615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98627,7 +98627,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98657,7 +98657,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98669,7 +98669,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98681,7 +98681,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98693,7 +98693,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98705,7 +98705,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98717,7 +98717,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98729,7 +98729,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98807,7 +98807,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98819,7 +98819,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -98855,7 +98855,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99431,7 +99431,7 @@
     {
       "declaredOn": "RenderingDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99479,7 +99479,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99556,8 +99556,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99581,7 +99581,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99593,7 +99593,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99629,7 +99629,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99653,7 +99653,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99665,7 +99665,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99689,7 +99689,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99701,7 +99701,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99712,8 +99712,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -99725,7 +99725,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99737,7 +99737,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99749,7 +99749,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99886,8 +99886,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99911,7 +99911,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -99923,7 +99923,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -100282,8 +100282,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -100295,7 +100295,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -100666,8 +100666,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -100696,8 +100696,8 @@
     },
     {
       "declaredOn": "RenderingUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -100732,8 +100732,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -100757,7 +100757,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RenderingUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101159,7 +101159,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101213,7 +101213,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101225,7 +101225,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101255,7 +101255,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101267,7 +101267,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -101279,7 +101279,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101291,7 +101291,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101303,7 +101303,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101315,7 +101315,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101327,7 +101327,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101339,7 +101339,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101351,7 +101351,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101441,7 +101441,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101453,7 +101453,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -101489,7 +101489,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102053,7 +102053,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102095,7 +102095,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -102119,7 +102119,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102131,7 +102131,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -102143,7 +102143,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -102191,7 +102191,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102227,7 +102227,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102256,8 +102256,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102280,8 +102280,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -102316,8 +102316,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102341,7 +102341,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102353,7 +102353,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102389,7 +102389,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102413,7 +102413,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102425,7 +102425,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102449,7 +102449,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102461,7 +102461,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102472,8 +102472,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -102485,7 +102485,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102496,8 +102496,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -102509,7 +102509,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102521,7 +102521,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102533,7 +102533,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102695,7 +102695,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -102707,7 +102707,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103066,8 +103066,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103079,7 +103079,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103451,7 +103451,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103468,8 +103468,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -103510,8 +103510,8 @@
     },
     {
       "declaredOn": "RequirementUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -103523,7 +103523,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -103547,7 +103547,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103559,7 +103559,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -103594,8 +103594,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -103619,7 +103619,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "RequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104741,7 +104741,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104782,8 +104782,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104806,8 +104806,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -104842,8 +104842,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104867,7 +104867,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104879,7 +104879,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104915,7 +104915,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104939,7 +104939,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104951,7 +104951,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104975,7 +104975,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104987,7 +104987,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -104998,8 +104998,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -105011,7 +105011,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105022,8 +105022,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -105035,7 +105035,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105047,7 +105047,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105059,7 +105059,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105227,7 +105227,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105239,7 +105239,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105598,8 +105598,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105611,7 +105611,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -105983,7 +105983,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106000,8 +106000,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -106042,8 +106042,8 @@
     },
     {
       "declaredOn": "RequirementUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -106055,7 +106055,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -106079,7 +106079,7 @@
     {
       "declaredOn": "SatisfyRequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -106103,7 +106103,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106115,7 +106115,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -106150,8 +106150,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106175,7 +106175,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SatisfyRequirementUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106217,7 +106217,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106228,8 +106228,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106289,7 +106289,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106325,7 +106325,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106349,7 +106349,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106361,7 +106361,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106385,7 +106385,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106396,8 +106396,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -106409,7 +106409,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106421,7 +106421,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106433,7 +106433,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106445,7 +106445,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106583,7 +106583,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106595,7 +106595,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106637,7 +106637,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -106985,7 +106985,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107009,7 +107009,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -107044,8 +107044,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SelectExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107068,8 +107068,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107086,8 +107086,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107134,8 +107134,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107159,7 +107159,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107171,7 +107171,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107207,7 +107207,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107231,7 +107231,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107243,7 +107243,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107267,7 +107267,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107279,7 +107279,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107290,8 +107290,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -107303,7 +107303,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107315,7 +107315,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107327,7 +107327,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107477,7 +107477,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107489,7 +107489,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107848,8 +107848,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -107861,7 +107861,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -108233,7 +108233,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -108322,8 +108322,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -108347,7 +108347,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SendActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -108983,7 +108983,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109025,7 +109025,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109037,7 +109037,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109079,7 +109079,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109115,7 +109115,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109127,7 +109127,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109139,7 +109139,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109151,7 +109151,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109163,7 +109163,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109175,7 +109175,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109259,7 +109259,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109271,7 +109271,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109307,7 +109307,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109871,7 +109871,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109907,7 +109907,7 @@
     {
       "declaredOn": "StateDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -109919,7 +109919,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -109955,7 +109955,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110344,8 +110344,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110362,8 +110362,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110410,8 +110410,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110435,7 +110435,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110447,7 +110447,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110495,7 +110495,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110543,7 +110543,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110555,7 +110555,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110579,7 +110579,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110591,7 +110591,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110602,8 +110602,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -110615,7 +110615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110627,7 +110627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110639,7 +110639,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110795,7 +110795,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -110807,7 +110807,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111166,8 +111166,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111179,7 +111179,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111551,7 +111551,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111592,8 +111592,8 @@
     },
     {
       "declaredOn": "StateUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111616,8 +111616,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111641,7 +111641,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "StateUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111682,8 +111682,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111743,7 +111743,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111779,7 +111779,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111803,7 +111803,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111815,7 +111815,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111839,7 +111839,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111851,7 +111851,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111863,7 +111863,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111875,7 +111875,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -111887,7 +111887,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112001,7 +112001,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112013,7 +112013,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112049,7 +112049,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112397,7 +112397,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112444,8 +112444,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Step",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112499,7 +112499,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112529,7 +112529,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112541,7 +112541,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112553,7 +112553,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112565,7 +112565,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112577,7 +112577,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112589,7 +112589,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112601,7 +112601,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112667,7 +112667,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112679,7 +112679,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -112715,7 +112715,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Structure",
       "multiplicity": "0..*",
       "ordered": true,
@@ -113896,8 +113896,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -113921,7 +113921,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -113981,7 +113981,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114017,7 +114017,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114041,7 +114041,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114053,7 +114053,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114077,7 +114077,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114089,7 +114089,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114101,7 +114101,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114113,7 +114113,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114125,7 +114125,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114245,7 +114245,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114257,7 +114257,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114293,7 +114293,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114664,8 +114664,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114677,7 +114677,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114707,7 +114707,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..1",
       "ordered": true,
@@ -114725,7 +114725,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114748,8 +114748,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Succession",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114778,8 +114778,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114803,7 +114803,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114850,8 +114850,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114875,7 +114875,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114887,7 +114887,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114923,7 +114923,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114947,7 +114947,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114959,7 +114959,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114983,7 +114983,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -114995,7 +114995,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115007,7 +115007,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115019,7 +115019,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115031,7 +115031,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115181,7 +115181,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115193,7 +115193,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115553,7 +115553,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115948,8 +115948,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115961,7 +115961,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -115991,7 +115991,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -116009,7 +116009,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116032,8 +116032,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116057,7 +116057,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionAsUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116098,8 +116098,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116110,8 +116110,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116135,7 +116135,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116195,7 +116195,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116231,7 +116231,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116255,7 +116255,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116267,7 +116267,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116291,7 +116291,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116303,7 +116303,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..2",
       "ordered": true,
@@ -116315,7 +116315,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116327,7 +116327,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116339,7 +116339,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116351,7 +116351,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116362,8 +116362,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116483,7 +116483,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116495,7 +116495,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116531,7 +116531,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116891,7 +116891,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116914,8 +116914,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116938,8 +116938,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116951,7 +116951,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -116981,7 +116981,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -116993,7 +116993,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -117011,7 +117011,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117023,7 +117023,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..1",
       "ordered": true,
@@ -117046,8 +117046,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlow",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117070,8 +117070,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117088,8 +117088,8 @@
     },
     {
       "declaredOn": "Connector",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117100,8 +117100,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117125,7 +117125,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117172,8 +117172,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117197,7 +117197,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117209,7 +117209,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117245,7 +117245,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117269,7 +117269,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117281,7 +117281,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117305,7 +117305,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117316,8 +117316,8 @@
     },
     {
       "declaredOn": "FlowUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117329,7 +117329,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..2",
       "ordered": true,
@@ -117341,7 +117341,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117352,8 +117352,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -117365,7 +117365,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117377,7 +117377,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117389,7 +117389,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117400,8 +117400,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117557,7 +117557,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117569,7 +117569,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117928,8 +117928,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -117941,7 +117941,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118325,7 +118325,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118348,8 +118348,8 @@
     },
     {
       "declaredOn": "Flow",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118378,8 +118378,8 @@
     },
     {
       "declaredOn": "Relationship",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118391,7 +118391,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118421,7 +118421,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -118433,7 +118433,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -118451,7 +118451,7 @@
     {
       "declaredOn": "Connector",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118463,7 +118463,7 @@
     {
       "declaredOn": "Flow",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -118486,8 +118486,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118511,7 +118511,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "SuccessionFlowUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118546,8 +118546,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118564,8 +118564,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118612,8 +118612,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118637,7 +118637,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118649,7 +118649,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118685,7 +118685,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118709,7 +118709,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118721,7 +118721,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118745,7 +118745,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118757,7 +118757,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118768,8 +118768,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -118781,7 +118781,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118793,7 +118793,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118805,7 +118805,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118955,7 +118955,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -118967,7 +118967,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -119326,8 +119326,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -119339,7 +119339,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -119711,7 +119711,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -119776,8 +119776,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -119801,7 +119801,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TerminateActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120436,8 +120436,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120454,8 +120454,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120502,8 +120502,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120527,7 +120527,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120539,7 +120539,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120587,7 +120587,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120611,7 +120611,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120623,7 +120623,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120647,7 +120647,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120671,7 +120671,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120682,8 +120682,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -120695,7 +120695,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120707,7 +120707,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120719,7 +120719,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120869,7 +120869,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -120881,7 +120881,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121240,8 +121240,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121253,7 +121253,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121625,7 +121625,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121726,8 +121726,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121751,7 +121751,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TransitionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121793,7 +121793,7 @@
     {
       "declaredOn": "InstantiationExpression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121804,8 +121804,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121865,7 +121865,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121901,7 +121901,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121925,7 +121925,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121937,7 +121937,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121961,7 +121961,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121972,8 +121972,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..1",
       "ordered": false,
@@ -121985,7 +121985,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -121997,7 +121997,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122009,7 +122009,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122021,7 +122021,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122165,7 +122165,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122177,7 +122177,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122213,7 +122213,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122561,7 +122561,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122585,7 +122585,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "1..1",
       "ordered": false,
@@ -122620,8 +122620,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "TriggerInvocationExpression",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122675,7 +122675,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122705,7 +122705,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122717,7 +122717,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122729,7 +122729,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122741,7 +122741,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122753,7 +122753,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122765,7 +122765,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122777,7 +122777,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122843,7 +122843,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122855,7 +122855,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -122891,7 +122891,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Type",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123682,8 +123682,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123707,7 +123707,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123719,7 +123719,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123755,7 +123755,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123779,7 +123779,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123791,7 +123791,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123815,7 +123815,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123827,7 +123827,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123839,7 +123839,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123851,7 +123851,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -123863,7 +123863,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124007,7 +124007,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124019,7 +124019,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124379,7 +124379,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124786,8 +124786,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124811,7 +124811,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "Usage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124847,7 +124847,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124859,7 +124859,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124877,7 +124877,7 @@
     {
       "declaredOn": "CalculationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124913,7 +124913,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124925,7 +124925,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124955,7 +124955,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124967,7 +124967,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -124979,7 +124979,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -124991,7 +124991,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125003,7 +125003,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125027,7 +125027,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125039,7 +125039,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125051,7 +125051,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125141,7 +125141,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125153,7 +125153,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125189,7 +125189,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..1",
       "ordered": true,
@@ -125201,7 +125201,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125765,7 +125765,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125789,7 +125789,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -125813,7 +125813,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -125825,7 +125825,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -125861,7 +125861,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125896,8 +125896,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125909,7 +125909,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125926,8 +125926,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -125938,8 +125938,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -125950,8 +125950,8 @@
     },
     {
       "declaredOn": "CaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -125998,8 +125998,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126023,7 +126023,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126035,7 +126035,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126071,7 +126071,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126095,7 +126095,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126107,7 +126107,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126131,7 +126131,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126142,8 +126142,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -126155,7 +126155,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126178,8 +126178,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -126191,7 +126191,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126203,7 +126203,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126215,7 +126215,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126377,7 +126377,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126389,7 +126389,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126749,7 +126749,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -126760,8 +126760,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -126773,7 +126773,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127145,7 +127145,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127175,7 +127175,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -127199,7 +127199,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -127222,8 +127222,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127247,7 +127247,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127258,8 +127258,8 @@
     },
     {
       "declaredOn": "UseCaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "UseCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -127619,7 +127619,7 @@
     {
       "declaredOn": "ActionDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127631,7 +127631,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127649,7 +127649,7 @@
     {
       "declaredOn": "CalculationDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127685,7 +127685,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127697,7 +127697,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127727,7 +127727,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127739,7 +127739,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -127751,7 +127751,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127763,7 +127763,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127775,7 +127775,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127787,7 +127787,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127799,7 +127799,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127811,7 +127811,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127901,7 +127901,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127913,7 +127913,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -127949,7 +127949,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..1",
       "ordered": true,
@@ -127961,7 +127961,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128525,7 +128525,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128549,7 +128549,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -128573,7 +128573,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -128585,7 +128585,7 @@
     {
       "declaredOn": "CaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -128621,7 +128621,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128657,7 +128657,7 @@
     {
       "declaredOn": "VerificationCaseDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128668,8 +128668,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128681,7 +128681,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128698,8 +128698,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128710,8 +128710,8 @@
     },
     {
       "declaredOn": "CalculationUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -128722,8 +128722,8 @@
     },
     {
       "declaredOn": "CaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -128770,8 +128770,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128795,7 +128795,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128807,7 +128807,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128843,7 +128843,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128867,7 +128867,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128879,7 +128879,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128903,7 +128903,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128914,8 +128914,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -128927,7 +128927,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128938,8 +128938,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -128951,7 +128951,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128963,7 +128963,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -128975,7 +128975,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129137,7 +129137,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129149,7 +129149,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129509,7 +129509,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": true,
@@ -129520,8 +129520,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129533,7 +129533,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129905,7 +129905,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -129935,7 +129935,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -129959,7 +129959,7 @@
     {
       "declaredOn": "CaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -129982,8 +129982,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130007,7 +130007,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130042,8 +130042,8 @@
     },
     {
       "declaredOn": "VerificationCaseUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -130055,7 +130055,7 @@
     {
       "declaredOn": "VerificationCaseUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "VerificationCaseUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130097,7 +130097,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130109,7 +130109,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130139,7 +130139,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130151,7 +130151,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130163,7 +130163,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130175,7 +130175,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130187,7 +130187,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130199,7 +130199,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130211,7 +130211,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130289,7 +130289,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130301,7 +130301,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130337,7 +130337,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130961,7 +130961,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -130997,7 +130997,7 @@
     {
       "declaredOn": "ViewDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131021,7 +131021,7 @@
     {
       "declaredOn": "ViewDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewDefinition",
       "multiplicity": "0..1",
       "ordered": false,
@@ -131434,8 +131434,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131459,7 +131459,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131471,7 +131471,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131507,7 +131507,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131543,7 +131543,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131555,7 +131555,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131579,7 +131579,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131591,7 +131591,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131602,8 +131602,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -131615,7 +131615,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131627,7 +131627,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131639,7 +131639,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131776,8 +131776,8 @@
     },
     {
       "declaredOn": "ItemUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131801,7 +131801,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -131813,7 +131813,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132172,8 +132172,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132185,7 +132185,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132556,8 +132556,8 @@
     },
     {
       "declaredOn": "PartUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132622,8 +132622,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132647,7 +132647,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132694,8 +132694,8 @@
     },
     {
       "declaredOn": "ViewUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -132707,7 +132707,7 @@
     {
       "declaredOn": "ViewUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -132719,7 +132719,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132773,7 +132773,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132785,7 +132785,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132815,7 +132815,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132827,7 +132827,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -132839,7 +132839,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132851,7 +132851,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132863,7 +132863,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132875,7 +132875,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132887,7 +132887,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132899,7 +132899,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -132911,7 +132911,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133001,7 +133001,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133013,7 +133013,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133049,7 +133049,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133613,7 +133613,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133655,7 +133655,7 @@
     {
       "declaredOn": "Function",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -133679,7 +133679,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133691,7 +133691,7 @@
     {
       "declaredOn": "Behavior",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": false,
@@ -133703,7 +133703,7 @@
     {
       "declaredOn": "RequirementDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "1..1",
       "ordered": false,
@@ -133751,7 +133751,7 @@
     {
       "declaredOn": "Definition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133787,7 +133787,7 @@
     {
       "declaredOn": "ViewpointDefinition",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointDefinition",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133799,7 +133799,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133828,8 +133828,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133852,8 +133852,8 @@
     },
     {
       "declaredOn": "ConstraintUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -133888,8 +133888,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133913,7 +133913,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133925,7 +133925,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133961,7 +133961,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133985,7 +133985,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -133997,7 +133997,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134021,7 +134021,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134033,7 +134033,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134044,8 +134044,8 @@
     },
     {
       "declaredOn": "Expression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -134057,7 +134057,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134068,8 +134068,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -134081,7 +134081,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134093,7 +134093,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134105,7 +134105,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134267,7 +134267,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134279,7 +134279,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134638,8 +134638,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -134651,7 +134651,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135023,7 +135023,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135040,8 +135040,8 @@
     },
     {
       "declaredOn": "BooleanExpression",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -135082,8 +135082,8 @@
     },
     {
       "declaredOn": "RequirementUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -135095,7 +135095,7 @@
     {
       "declaredOn": "Expression",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -135119,7 +135119,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135131,7 +135131,7 @@
     {
       "declaredOn": "RequirementUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "1..1",
       "ordered": false,
@@ -135166,8 +135166,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135191,7 +135191,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135226,8 +135226,8 @@
     },
     {
       "declaredOn": "ViewpointUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -135239,7 +135239,7 @@
     {
       "declaredOn": "ViewpointUsage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "ViewpointUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135250,8 +135250,8 @@
     },
     {
       "declaredOn": "ActionUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135268,8 +135268,8 @@
     },
     {
       "declaredOn": "Step",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135328,8 +135328,8 @@
     },
     {
       "declaredOn": "Usage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135353,7 +135353,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135365,7 +135365,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135401,7 +135401,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135425,7 +135425,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135437,7 +135437,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135461,7 +135461,7 @@
     {
       "declaredOn": "Feature",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135473,7 +135473,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135484,8 +135484,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..1",
       "ordered": false,
@@ -135497,7 +135497,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135509,7 +135509,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135521,7 +135521,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135671,7 +135671,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -135683,7 +135683,7 @@
     {
       "declaredOn": "Namespace",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -136042,8 +136042,8 @@
     },
     {
       "declaredOn": "OccurrenceUsage",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -136055,7 +136055,7 @@
     {
       "declaredOn": "Type",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -136427,7 +136427,7 @@
     {
       "declaredOn": "Step",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -136480,8 +136480,8 @@
     },
     {
       "declaredOn": "Feature",
-      "fidelity": "exact",
-      "fidelityUnderClosure": "exact",
+      "fidelity": "passthrough",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
@@ -136517,7 +136517,7 @@
     {
       "declaredOn": "Usage",
       "fidelity": "passthrough",
-      "fidelityUnderClosure": "exact",
+      "fidelityUnderClosure": "passthrough",
       "metaclass": "WhileLoopActionUsage",
       "multiplicity": "0..*",
       "ordered": true,
diff --git a/spec-refs/derived-properties.json b/spec-refs/derived-properties.json
index d18d566..06a38f0 100644
--- a/spec-refs/derived-properties.json
+++ b/spec-refs/derived-properties.json
@@ -78,7 +78,7 @@
       "types"
      ],
      "corpus_elements": 1124,
-     "corpus_nonempty": 273,
+     "corpus_nonempty": 275,
      "class": "structural"
     }
    ],
@@ -86,7 +86,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 1124,
-   "corpus_nonempty": 273
+   "corpus_nonempty": 275
   },
   {
    "name": "actorParameter",
@@ -295,8 +295,8 @@
       "annotations",
       "owningNamespace"
      ],
-     "corpus_elements": 632,
-     "corpus_nonempty": 632,
+     "corpus_elements": 587,
+     "corpus_nonempty": 587,
      "class": "structural"
     }
    ],
@@ -305,8 +305,8 @@
    "rules": {
     "AnnotatingElement": "annotatedElement = if annotation->notEmpty() then annotation.annotatedElement else Sequence{owningNamespace} endif"
    },
-   "corpus_elements": 632,
-   "corpus_nonempty": 632
+   "corpus_elements": 587,
+   "corpus_nonempty": 587
   },
   {
    "name": "annotatingElement",
@@ -365,7 +365,7 @@
       "ownedAnnotatingRelationshps",
       "owningAnnotatingRelationship"
      ],
-     "corpus_elements": 632,
+     "corpus_elements": 587,
      "corpus_nonempty": 16,
      "class": "structural"
     }
@@ -375,7 +375,7 @@
    "rules": {
     "AnnotatingElement": "annotation =      if owningAnnotatingRelationship = null then ownedAnnotatingRelationship     else owningAnnotatingRelationship->prepend(owningAnnotatingRelationship)     endif"
    },
-   "corpus_elements": 632,
+   "corpus_elements": 587,
    "corpus_nonempty": 16
   },
   {
@@ -465,7 +465,7 @@
       "Associations",
       "Connector"
      ],
-     "corpus_elements": 689,
+     "corpus_elements": 2361,
      "corpus_nonempty": 63,
      "class": "structural"
     }
@@ -473,7 +473,7 @@
    "concrete_carriers": 12,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 689,
+   "corpus_elements": 2361,
    "corpus_nonempty": 63
   },
   {
@@ -585,7 +585,7 @@
       "DataTypes"
      ],
      "corpus_elements": 869,
-     "corpus_nonempty": 778,
+     "corpus_nonempty": 775,
      "class": "structural"
     }
    ],
@@ -593,7 +593,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 869,
-   "corpus_nonempty": 778
+   "corpus_nonempty": 775
   },
   {
    "name": "behavior",
@@ -615,7 +615,7 @@
       "Step"
      ],
      "corpus_elements": 6120,
-     "corpus_nonempty": 400,
+     "corpus_nonempty": 845,
      "class": "structural"
     }
    ],
@@ -625,7 +625,7 @@
     "Step": "behavior = type->selectByKind(Behavior)"
    },
    "corpus_elements": 6120,
-   "corpus_nonempty": 400
+   "corpus_nonempty": 845
   },
   {
    "name": "bodyAction",
@@ -749,7 +749,7 @@
       "type"
      ],
      "corpus_elements": 96,
-     "corpus_nonempty": 68,
+     "corpus_nonempty": 70,
      "class": "structural"
     }
    ],
@@ -757,7 +757,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 96,
-   "corpus_nonempty": 68
+   "corpus_nonempty": 70
   },
   {
    "name": "caseDefinition",
@@ -804,7 +804,7 @@
       "chainingFeatures",
       "ownedFeatureChainings"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 588,
      "class": "structural"
     }
@@ -814,7 +814,7 @@
    "rules": {
     "Feature": "chainingFeature = ownedFeatureChaining.chainingFeature"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 588
   },
   {
@@ -1012,16 +1012,16 @@
       "connectorEnds",
       "endFeatures"
      ],
-     "corpus_elements": 689,
-     "corpus_nonempty": 670,
+     "corpus_elements": 2361,
+     "corpus_nonempty": 2342,
      "class": "inheritance-aware"
     }
    ],
    "concrete_carriers": 12,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 689,
-   "corpus_nonempty": 670
+   "corpus_elements": 2361,
+   "corpus_nonempty": 2342
   },
   {
    "name": "constraintDefinition",
@@ -1045,7 +1045,7 @@
       "Predicates"
      ],
      "corpus_elements": 291,
-     "corpus_nonempty": 127,
+     "corpus_nonempty": 132,
      "class": "structural"
     }
    ],
@@ -1053,7 +1053,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 291,
-   "corpus_nonempty": 127
+   "corpus_nonempty": 132
   },
   {
    "name": "crossFeature",
@@ -1077,7 +1077,7 @@
       "ownedCrossSubsetting",
       "owningType"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 2,
      "class": "structural"
     }
@@ -1087,7 +1087,7 @@
    "rules": {
     "Feature": "crossFeature =     if ownedCrossSubsetting = null then null     else          let chainingFeatures: Sequence(Feature) =              ownedCrossSubsetting.crossedFeature.chainingFeature in         if chainingFeatures->size() < 2 then null         else chainingFeatures->at(2)     endif"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 2
   },
   {
@@ -1141,8 +1141,8 @@
       "featuringType",
       "relatedFeatures"
      ],
-     "corpus_elements": 689,
-     "corpus_nonempty": 475,
+     "corpus_elements": 2361,
+     "corpus_nonempty": 1200,
      "class": "inheritance-aware"
     }
    ],
@@ -1151,8 +1151,8 @@
    "rules": {
     "Connector": "let commonFeaturingTypes : OrderedSet(Type) =      relatedFeature->closure(featuringType)->select(t |          relatedFeature->forAll(f | f.isFeaturedWithin(t))     ) in let nearestCommonFeaturingTypes : OrderedSet(Type) =     commonFeaturingTypes->reject(t1 |          commonFeaturingTypes->exists(t2 |              t2 <> t1 and t2->closure(featuringType)->contains(t1)     )) in if nearestCommonFeaturingTypes->isEmpty() then null else nearestCommonFeaturingTypes->first() endif"
    },
-   "corpus_elements": 689,
-   "corpus_nonempty": 475
+   "corpus_elements": 2361,
+   "corpus_nonempty": 1200
   },
   {
    "name": "definition",
@@ -1175,7 +1175,7 @@
       "Usage"
      ],
      "corpus_elements": 8045,
-     "corpus_nonempty": 4244,
+     "corpus_nonempty": 4476,
      "class": "structural"
     }
    ],
@@ -1183,7 +1183,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 8045,
-   "corpus_nonempty": 4244
+   "corpus_nonempty": 4476
   },
   {
    "name": "differencingType",
@@ -1205,7 +1205,7 @@
       "Types",
       "differencingTypes"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -1215,7 +1215,7 @@
    "rules": {
     "Type": "differencingType = ownedDifferencing.differencingType"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -1238,8 +1238,8 @@
       "direction",
       "features"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 2635,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 4307,
      "class": "inheritance-aware"
     }
    ],
@@ -1248,8 +1248,8 @@
    "rules": {
     "Type": "directedFeature = feature->select(f | directionOf(f) <> null)"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 2635
+   "corpus_elements": 24993,
+   "corpus_nonempty": 4307
   },
   {
    "name": "directedUsage",
@@ -1373,7 +1373,7 @@
      "redefines": [],
      "doc": "The Documentation owned by this Element.",
      "doc_refs": [],
-     "corpus_elements": 52148,
+     "corpus_elements": 91191,
      "corpus_nonempty": 156,
      "class": "structural"
     }
@@ -1383,7 +1383,7 @@
    "rules": {
     "Element": "documentation = ownedElement->selectByKind(Documentation)"
    },
-   "corpus_elements": 52148,
+   "corpus_elements": 91191,
    "corpus_nonempty": 156
   },
   {
@@ -1503,8 +1503,8 @@
       "Type",
       "features"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 716,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 2388,
      "class": "inheritance-aware"
     }
    ],
@@ -1513,8 +1513,8 @@
    "rules": {
     "Type": "endFeature = feature->select(isEnd)"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 716
+   "corpus_elements": 24993,
+   "corpus_nonempty": 2388
   },
   {
    "name": "endOwningType",
@@ -1538,16 +1538,16 @@
       "Type",
       "ownedMemberFeature"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 1420,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 4764,
      "class": "structural"
     }
    ],
    "concrete_carriers": 79,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 16951,
-   "corpus_nonempty": 1420
+   "corpus_elements": 23639,
+   "corpus_nonempty": 4764
   },
   {
    "name": "entryAction",
@@ -1796,7 +1796,7 @@
       "viewConditions"
      ],
      "corpus_elements": 12,
-     "corpus_nonempty": 5,
+     "corpus_nonempty": 8,
      "class": "inheritance-aware"
     }
    ],
@@ -1806,7 +1806,7 @@
     "ViewUsage": "exposedElement = ownedImport->selectByKind(Expose).     importedMemberships(Set{}).memberElement->     select(elm | includeAsExposed(elm))->     asOrderedSet()"
    },
    "corpus_elements": 12,
-   "corpus_nonempty": 5
+   "corpus_nonempty": 8
   },
   {
    "name": "expression",
@@ -1860,8 +1860,8 @@
       "featureMemberships",
       "ownedMemberFeatures"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 4942,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 8286,
      "class": "inheritance-aware"
     }
    ],
@@ -1870,8 +1870,8 @@
    "rules": {
     "Type": "feature = featureMembership.ownedMemberFeature"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 4942
+   "corpus_elements": 24993,
+   "corpus_nonempty": 8286
   },
   {
    "name": "featureChained",
@@ -1926,8 +1926,8 @@
       "inheritedMemberships",
       "ownedFeatureMemberships"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 4942,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 8286,
      "class": "inheritance-aware"
     }
    ],
@@ -1936,8 +1936,8 @@
    "rules": {
     "Type": "featureMembership = ownedFeatureMembership->union( inheritedMembership->selectByKind(FeatureMembership))"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 4942
+   "corpus_elements": 24993,
+   "corpus_nonempty": 8286
   },
   {
    "name": "featureTarget",
@@ -1956,7 +1956,7 @@
       "Feature",
       "chainingFeatures"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 588,
      "class": "structural"
     }
@@ -1966,7 +1966,7 @@
    "rules": {
     "Feature": "featureTarget = if chainingFeature->isEmpty() then self else chainingFeature->last() endif"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 588
   },
   {
@@ -2015,7 +2015,7 @@
       "featuringTypes",
       "typeFeaturings"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 0,
      "class": "closure"
     }
@@ -2025,7 +2025,7 @@
    "rules": {
     "Feature": "featuringType =     let featuringTypes : OrderedSet(Type) =          featuring.type->asOrderedSet() in     if chainingFeature->isEmpty() then featuringTypes     else         featuringTypes->             union(chainingFeature->first().featuringType)->             asOrderedSet()     endif"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 0
   },
   {
@@ -2221,7 +2221,7 @@
       "Function"
      ],
      "corpus_elements": 5092,
-     "corpus_nonempty": 195,
+     "corpus_nonempty": 640,
      "class": "structural"
     }
    ],
@@ -2229,7 +2229,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 5092,
-   "corpus_nonempty": 195
+   "corpus_nonempty": 640
   },
   {
    "name": "guardExpression",
@@ -2383,7 +2383,7 @@
       "Namespace",
       "ownedImports"
      ],
-     "corpus_elements": 19037,
+     "corpus_elements": 25725,
      "corpus_nonempty": 0,
      "class": "closure"
     }
@@ -2393,7 +2393,7 @@
    "rules": {
     "Namespace": "importedMembership = importedMemberships(Set{})"
    },
-   "corpus_elements": 19037,
+   "corpus_elements": 25725,
    "corpus_nonempty": 0
   },
   {
@@ -2499,7 +2499,7 @@
       "inheritedMemberships",
       "memberFeatures"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "closure"
     }
@@ -2509,7 +2509,7 @@
    "rules": {
     "Type": "inheritedFeature = inheritedMemberships-> selectByKind(FeatureMembership).memberFeature"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -2534,7 +2534,7 @@
       "Type",
       "memberships"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "closure"
     }
@@ -2544,7 +2544,7 @@
    "rules": {
     "Type": "inheritedMembership = inheritedMemberships(Set{}, Set{}, false)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -2570,7 +2570,7 @@
       "in",
       "inout"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 2414,
      "class": "inheritance-aware"
     }
@@ -2580,7 +2580,7 @@
    "rules": {
     "Type": "input = feature->select(f |      let direction: FeatureDirectionKind = directionOf(f) in     direction = FeatureDirectionKind::_'in' or     direction = FeatureDirectionKind::inout)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 2414
   },
   {
@@ -2733,7 +2733,7 @@
       "intersectingTypes",
       "ownedIntersectings"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -2743,7 +2743,7 @@
    "rules": {
     "Type": "intersectingType = ownedIntersecting.intersectingType"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -2763,7 +2763,7 @@
       "Type",
       "ownedConjugator"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 91,
      "class": "structural"
     }
@@ -2771,7 +2771,7 @@
    "concrete_carriers": 117,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 91
   },
   {
@@ -2788,8 +2788,8 @@
      "redefines": [],
      "doc": "Whether this Element is contained in the ownership tree of a library model.",
      "doc_refs": [],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 1093,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 1376,
      "class": "structural"
     }
    ],
@@ -2798,8 +2798,8 @@
    "rules": {
     "Element": "isLibraryElement = libraryNamespace() <> null "
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 1093
+   "corpus_elements": 91191,
+   "corpus_nonempty": 1376
   },
   {
    "name": "isModelLevelEvaluable",
@@ -2818,7 +2818,7 @@
       "Expression"
      ],
      "corpus_elements": 5092,
-     "corpus_nonempty": 2441,
+     "corpus_nonempty": 2184,
      "class": "structural"
     },
     {
@@ -2849,7 +2849,7 @@
     "Expression": "isModelLevelEvaluable = modelLevelEvaluable(Set(Element){})"
    },
    "corpus_elements": 5219,
-   "corpus_nonempty": 2441
+   "corpus_nonempty": 2184
   },
   {
    "name": "isReference",
@@ -2951,7 +2951,7 @@
       "definitions"
      ],
      "corpus_elements": 1605,
-     "corpus_nonempty": 1125,
+     "corpus_nonempty": 1167,
      "class": "structural"
     }
    ],
@@ -2961,7 +2961,7 @@
     "ItemUsage": "itemDefinition = occurrenceDefinition->selectByKind(Structure)"
    },
    "corpus_elements": 1605,
-   "corpus_nonempty": 1125
+   "corpus_nonempty": 1167
   },
   {
    "name": "loopVariable",
@@ -3079,8 +3079,8 @@
       "memberElements",
       "memberships"
      ],
-     "corpus_elements": 19037,
-     "corpus_nonempty": 12491,
+     "corpus_elements": 25725,
+     "corpus_nonempty": 14163,
      "class": "inheritance-aware"
     }
    ],
@@ -3089,8 +3089,8 @@
    "rules": {
     "Namespace": "member = membership.memberElement"
    },
-   "corpus_elements": 19037,
-   "corpus_nonempty": 12491
+   "corpus_elements": 25725,
+   "corpus_nonempty": 14163
   },
   {
    "name": "memberElementId",
@@ -3109,8 +3109,8 @@
       "elementId",
       "memberElement"
      ],
-     "corpus_elements": 21066,
-     "corpus_nonempty": 21066,
+     "corpus_elements": 27709,
+     "corpus_nonempty": 27709,
      "class": "structural"
     }
    ],
@@ -3119,8 +3119,8 @@
    "rules": {
     "Membership": "memberElementId = memberElement.elementId"
    },
-   "corpus_elements": 21066,
-   "corpus_nonempty": 21066
+   "corpus_elements": 27709,
+   "corpus_nonempty": 27709
   },
   {
    "name": "membership",
@@ -3141,16 +3141,16 @@
       "importedMemberships",
       "ownedMemberships"
      ],
-     "corpus_elements": 19037,
-     "corpus_nonempty": 12491,
+     "corpus_elements": 25725,
+     "corpus_nonempty": 14163,
      "class": "inheritance-aware"
     }
    ],
    "concrete_carriers": 120,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 19037,
-   "corpus_nonempty": 12491
+   "corpus_elements": 25725,
+   "corpus_nonempty": 14163
   },
   {
    "name": "membershipOwningNamespace",
@@ -3176,16 +3176,16 @@
       "member",
       "memberElement"
      ],
-     "corpus_elements": 21066,
-     "corpus_nonempty": 21066,
+     "corpus_elements": 27709,
+     "corpus_nonempty": 27709,
      "class": "structural"
     }
    ],
    "concrete_carriers": 20,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 21066,
-   "corpus_nonempty": 21066
+   "corpus_elements": 27709,
+   "corpus_nonempty": 27709
   },
   {
    "name": "metaclass",
@@ -3272,7 +3272,7 @@
       "Type",
       "ownedMember"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 576,
      "class": "structural"
     }
@@ -3282,7 +3282,7 @@
    "rules": {
     "Type": "multiplicity =      let ownedMultiplicities: Sequence(Multiplicity) =         ownedMember->selectByKind(Multiplicity) in     if ownedMultiplicities->isEmpty() then null     else ownedMultiplicities->first()     endif"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 576
   },
   {
@@ -3305,8 +3305,8 @@
       "name",
       "owningNamespace"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 9724,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 14342,
      "class": "structural"
     }
    ],
@@ -3315,8 +3315,8 @@
    "rules": {
     "Element": "name = effectiveName()"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 9724
+   "corpus_elements": 91191,
+   "corpus_nonempty": 14342
   },
   {
    "name": "nestedAction",
@@ -3653,7 +3653,7 @@
   {
    "name": "nestedFlow",
    "class": "structural",
-   "status": "absent",
+   "status": "derived",
    "declaring": [
     {
      "metaclass": "Usage",
@@ -3670,7 +3670,7 @@
       "nestedUsages"
      ],
      "corpus_elements": 8045,
-     "corpus_nonempty": 0,
+     "corpus_nonempty": 47,
      "class": "structural"
     }
    ],
@@ -3680,7 +3680,7 @@
     "Usage": "nestedFlow = nestedUsage->selectByKind(FlowConnectionUsage)"
    },
    "corpus_elements": 8045,
-   "corpus_nonempty": 0
+   "corpus_nonempty": 47
   },
   {
    "name": "nestedInterface",
@@ -3703,7 +3703,7 @@
       "nestedUsages"
      ],
      "corpus_elements": 8045,
-     "corpus_nonempty": 1290,
+     "corpus_nonempty": 17,
      "class": "structural"
     }
    ],
@@ -3713,7 +3713,7 @@
     "Usage": "nestedInterface = nestedUsage->selectByKind(ReferenceUsage)"
    },
    "corpus_elements": 8045,
-   "corpus_nonempty": 1290
+   "corpus_nonempty": 17
   },
   {
    "name": "nestedItem",
@@ -4283,7 +4283,7 @@
       "OccurrenceUsage"
      ],
      "corpus_elements": 3627,
-     "corpus_nonempty": 1918,
+     "corpus_nonempty": 1973,
      "class": "structural"
     }
    ],
@@ -4291,7 +4291,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 3627,
-   "corpus_nonempty": 1918
+   "corpus_nonempty": 1973
   },
   {
    "name": "originalPortDefinition",
@@ -4347,8 +4347,8 @@
       "inout",
       "out"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 584,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 2256,
      "class": "inheritance-aware"
     }
    ],
@@ -4357,8 +4357,8 @@
    "rules": {
     "Type": "output = feature->select(f |      let direction: FeatureDirectionKind = directionOf(f) in     direction = FeatureDirectionKind::out or     direction = FeatureDirectionKind::inout)"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 584
+   "corpus_elements": 24993,
+   "corpus_nonempty": 2256
   },
   {
    "name": "ownedAction",
@@ -4544,7 +4544,7 @@
       "annotatingElement",
       "ownedRelationships"
      ],
-     "corpus_elements": 632,
+     "corpus_elements": 587,
      "corpus_nonempty": 16,
      "class": "structural"
     }
@@ -4554,7 +4554,7 @@
    "rules": {
     "AnnotatingElement": "ownedAnnotatingRelationship = ownedRelationship->     selectByKind(Annotation)->     select(a | a.annotatedElement <> self)"
    },
-   "corpus_elements": 632,
+   "corpus_elements": 587,
    "corpus_nonempty": 16
   },
   {
@@ -4579,7 +4579,7 @@
       "annotatedElement",
       "ownedRelationships"
      ],
-     "corpus_elements": 52148,
+     "corpus_elements": 91191,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -4589,7 +4589,7 @@
    "rules": {
     "Element": "ownedAnnotation = ownedRelationship-> selectByKind(Annotation)-> select(a | a.annotatedElement = self)"
    },
-   "corpus_elements": 52148,
+   "corpus_elements": 91191,
    "corpus_nonempty": 0
   },
   {
@@ -4763,7 +4763,7 @@
       "Type",
       "originalType"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 91,
      "class": "structural"
     }
@@ -4773,7 +4773,7 @@
    "rules": {
     "Type": "ownedConjugator =     let ownedConjugators: Sequence(Conjugator) =          ownedRelationship->selectByKind(Conjugation) in     if ownedConjugators->isEmpty() then null      else ownedConjugators->at(1) endif"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 91
   },
   {
@@ -4885,7 +4885,7 @@
       "crossingFeature",
       "ownedSubsetting"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 2,
      "class": "structural"
     }
@@ -4895,7 +4895,7 @@
    "rules": {
     "Feature": "ownedCrossSubsetting =     let crossSubsettings: Sequence(CrossSubsetting) =          ownedSubsetting->selectByKind(CrossSubsetting) in     if crossSubsettings->isEmpty() then null     else crossSubsettings->first()     endif"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 2
   },
   {
@@ -4920,7 +4920,7 @@
       "ownedRelationships",
       "typeDifferenced"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -4930,7 +4930,7 @@
    "rules": {
     "Type": "ownedDifferencing = ownedRelationship->selectByKind(Differencing)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -4955,7 +4955,7 @@
       "ownedRelationships",
       "typeDisjoined"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -4965,7 +4965,7 @@
    "rules": {
     "Type": "ownedDisjoining = ownedRelationship->selectByKind(Disjoining)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -4982,8 +4982,8 @@
      "redefines": [],
      "doc": "The Elements owned by this Element, derived as the ownedRelatedElements of the ownedRelationships of this Element.",
      "doc_refs": [],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 11182,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 14481,
      "class": "structural"
     }
    ],
@@ -4992,8 +4992,8 @@
    "rules": {
     "Element": "ownedElement = ownedRelationship.ownedRelatedElement"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 11182
+   "corpus_elements": 91191,
+   "corpus_nonempty": 14481
   },
   {
    "name": "ownedEndFeature",
@@ -5016,8 +5016,8 @@
       "endFeatures",
       "ownedFeatures"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 716,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 2388,
      "class": "structural"
     }
    ],
@@ -5026,8 +5026,8 @@
    "rules": {
     "Type": "ownedEndFeature = ownedFeature->select(isEnd)"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 716
+   "corpus_elements": 24993,
+   "corpus_nonempty": 2388
   },
   {
    "name": "ownedEnumeration",
@@ -5082,8 +5082,8 @@
       "ownedFeatureMemberships",
       "ownedMemberFeatures"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 4942,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 8286,
      "class": "structural"
     }
    ],
@@ -5092,8 +5092,8 @@
    "rules": {
     "Type": "ownedFeature = ownedFeatureMembership.ownedMemberFeature"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 4942
+   "corpus_elements": 24993,
+   "corpus_nonempty": 8286
   },
   {
    "name": "ownedFeatureChaining",
@@ -5117,7 +5117,7 @@
       "featureChained",
       "ownedRelationships"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 588,
      "class": "structural"
     }
@@ -5127,7 +5127,7 @@
    "rules": {
     "Feature": "ownedFeatureChaining = ownedRelationship->selectByKind(FeatureChaining)"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 588
   },
   {
@@ -5152,7 +5152,7 @@
       "featureInverted",
       "ownedRelationships"
      ],
-     "corpus_elements": 16951,
+     "corpus_elements": 23639,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -5162,7 +5162,7 @@
    "rules": {
     "Feature": "ownedFeatureInverting = ownedRelationship->selectByKind(FeatureInverting)-> select(fi | fi.featureInverted = self)"
    },
-   "corpus_elements": 16951,
+   "corpus_elements": 23639,
    "corpus_nonempty": 0
   },
   {
@@ -5189,8 +5189,8 @@
       "ownedMemberships",
       "owningType"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 4942,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 8286,
      "class": "structural"
     }
    ],
@@ -5199,13 +5199,13 @@
    "rules": {
     "Type": "ownedFeatureMembership = ownedRelationship->selectByKind(FeatureMembership)"
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 4942
+   "corpus_elements": 24993,
+   "corpus_nonempty": 8286
   },
   {
    "name": "ownedFlow",
    "class": "structural",
-   "status": "absent",
+   "status": "derived",
    "declaring": [
     {
      "metaclass": "Definition",
@@ -5223,7 +5223,7 @@
       "ownedUsages"
      ],
      "corpus_elements": 1354,
-     "corpus_nonempty": 0,
+     "corpus_nonempty": 20,
      "class": "structural"
     }
    ],
@@ -5233,7 +5233,7 @@
     "Definition": "ownedFlow = ownedUsage->selectByKind(FlowConnectionUsage)"
    },
    "corpus_elements": 1354,
-   "corpus_nonempty": 0
+   "corpus_nonempty": 20
   },
   {
    "name": "ownedImport",
@@ -5257,7 +5257,7 @@
       "importOwningNamespace",
       "ownedRelationships"
      ],
-     "corpus_elements": 19037,
+     "corpus_elements": 25725,
      "corpus_nonempty": 279,
      "class": "structural"
     }
@@ -5267,7 +5267,7 @@
    "rules": {
     "Namespace": "ownedImport = ownedRelationship->selectByKind(Import)"
    },
-   "corpus_elements": 19037,
+   "corpus_elements": 25725,
    "corpus_nonempty": 279
   },
   {
@@ -5291,7 +5291,7 @@
       "ownedUsages"
      ],
      "corpus_elements": 1354,
-     "corpus_nonempty": 265,
+     "corpus_nonempty": 2,
      "class": "structural"
     }
    ],
@@ -5301,7 +5301,7 @@
     "Definition": "ownedInterface = ownedUsage->selectByKind(ReferenceUsage)"
    },
    "corpus_elements": 1354,
-   "corpus_nonempty": 265
+   "corpus_nonempty": 2
   },
   {
    "name": "ownedIntersecting",
@@ -5325,7 +5325,7 @@
       "ownedRelationships",
       "typeIntersected"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -5335,7 +5335,7 @@
    "rules": {
     "Type": "ownedRelationship->selectByKind(Intersecting)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -5392,8 +5392,8 @@
       "ownedMemberElements",
       "ownedMemberships"
      ],
-     "corpus_elements": 19037,
-     "corpus_nonempty": 10764,
+     "corpus_elements": 25725,
+     "corpus_nonempty": 14108,
      "class": "structural"
     }
    ],
@@ -5402,8 +5402,8 @@
    "rules": {
     "Namespace": "ownedMember = ownedMembership->selectByKind(OwningMembership).ownedMemberElement"
    },
-   "corpus_elements": 19037,
-   "corpus_nonempty": 10764
+   "corpus_elements": 25725,
+   "corpus_nonempty": 14108
   },
   {
    "name": "ownedMemberElement",
@@ -5428,16 +5428,16 @@
       "membershipOwningNamespace",
       "ownedMember"
      ],
-     "corpus_elements": 18728,
-     "corpus_nonempty": 18728,
+     "corpus_elements": 25371,
+     "corpus_nonempty": 25371,
      "class": "structural"
     }
    ],
    "concrete_carriers": 19,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 18728,
-   "corpus_nonempty": 18728
+   "corpus_elements": 25371,
+   "corpus_nonempty": 25371
   },
   {
    "name": "ownedMemberElementId",
@@ -5458,16 +5458,16 @@
       "elementId",
       "ownedMemberElement"
      ],
-     "corpus_elements": 18728,
-     "corpus_nonempty": 18728,
+     "corpus_elements": 25371,
+     "corpus_nonempty": 25371,
      "class": "structural"
     }
    ],
    "concrete_carriers": 19,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 18728,
-   "corpus_nonempty": 18728
+   "corpus_elements": 25371,
+   "corpus_nonempty": 25371
   },
   {
    "name": "ownedMemberFeature",
@@ -5490,8 +5490,8 @@
       "ownedFeature",
       "owningType"
      ],
-     "corpus_elements": 10203,
-     "corpus_nonempty": 10203,
+     "corpus_elements": 15219,
+     "corpus_nonempty": 15219,
      "class": "structural"
     },
     {
@@ -5505,16 +5505,16 @@
      ],
      "doc": "",
      "doc_refs": [],
-     "corpus_elements": 1420,
-     "corpus_nonempty": 1420,
+     "corpus_elements": 4764,
+     "corpus_nonempty": 4764,
      "class": "structural"
     }
    ],
    "concrete_carriers": 15,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 10203,
-   "corpus_nonempty": 10203
+   "corpus_elements": 15219,
+   "corpus_nonempty": 15219
   },
   {
    "name": "ownedMemberName",
@@ -5535,8 +5535,8 @@
       "name",
       "ownedMemberElement"
      ],
-     "corpus_elements": 18728,
-     "corpus_nonempty": 9230,
+     "corpus_elements": 25371,
+     "corpus_nonempty": 14342,
      "class": "structural"
     }
    ],
@@ -5545,8 +5545,8 @@
    "rules": {
     "OwningMembership": "ownedMemberName = ownedMemberElement.name"
    },
-   "corpus_elements": 18728,
-   "corpus_nonempty": 9230
+   "corpus_elements": 25371,
+   "corpus_nonempty": 14342
   },
   {
    "name": "ownedMemberParameter",
@@ -5568,16 +5568,16 @@
       "ParameterMembership",
       "parameter"
      ],
-     "corpus_elements": 3432,
-     "corpus_nonempty": 3432,
+     "corpus_elements": 5104,
+     "corpus_nonempty": 5104,
      "class": "structural"
     }
    ],
    "concrete_carriers": 5,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 3432,
-   "corpus_nonempty": 3432
+   "corpus_elements": 5104,
+   "corpus_nonempty": 5104
   },
   {
    "name": "ownedMemberShortName",
@@ -5598,8 +5598,8 @@
       "ownedMemberElement",
       "shortName"
      ],
-     "corpus_elements": 18728,
-     "corpus_nonempty": 75,
+     "corpus_elements": 25371,
+     "corpus_nonempty": 74,
      "class": "structural"
     }
    ],
@@ -5608,8 +5608,8 @@
    "rules": {
     "OwningMembership": "ownedMemberShortName = ownedMemberElement.shortName"
    },
-   "corpus_elements": 18728,
-   "corpus_nonempty": 75
+   "corpus_elements": 25371,
+   "corpus_nonempty": 74
   },
   {
    "name": "ownedMembership",
@@ -5634,8 +5634,8 @@
       "membershipOwningNamespace",
       "ownedRelationships"
      ],
-     "corpus_elements": 19037,
-     "corpus_nonempty": 12491,
+     "corpus_elements": 25725,
+     "corpus_nonempty": 14163,
      "class": "structural"
     }
    ],
@@ -5644,8 +5644,8 @@
    "rules": {
     "Namespace": "ownedMembership = ownedRelationship->selectByKind(Membership)"
    },
-   "corpus_elements": 19037,
-   "corpus_nonempty": 12491
+   "corpus_elements": 25725,
+   "corpus_nonempty": 14163
   },
   {
    "name": "ownedMetadata",
@@ -5861,8 +5861,8 @@
       "ownedSubsettings",
       "redefiningFeature"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 1294,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 5554,
      "class": "structural"
     }
    ],
@@ -5871,8 +5871,8 @@
    "rules": {
     "Feature": "ownedRedefinition = ownedSubsetting->selectByKind(Redefinition)"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 1294
+   "corpus_elements": 23639,
+   "corpus_nonempty": 5554
   },
   {
    "name": "ownedReference",
@@ -5928,8 +5928,8 @@
       "ownedSubsetting",
       "referencingFeature"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 1164,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 4876,
      "class": "structural"
     }
    ],
@@ -5938,8 +5938,8 @@
    "rules": {
     "Feature": "ownedReferenceSubsetting =     let referenceSubsettings : OrderedSet(ReferenceSubsetting) =         ownedSubsetting->selectByKind(ReferenceSubsetting) in     if referenceSubsettings->isEmpty() then null     else referenceSubsettings->first() endif"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 1164
+   "corpus_elements": 23639,
+   "corpus_nonempty": 4876
   },
   {
    "name": "ownedRendering",
@@ -6097,8 +6097,8 @@
       "ownedRelationships",
       "specific"
      ],
-     "corpus_elements": 18305,
-     "corpus_nonempty": 7923,
+     "corpus_elements": 24993,
+     "corpus_nonempty": 22536,
      "class": "structural"
     }
    ],
@@ -6107,8 +6107,8 @@
    "rules": {
     "Type": "ownedSpecialization = ownedRelationship->selectByKind(Specialization)-> select(s | s.special = self) "
    },
-   "corpus_elements": 18305,
-   "corpus_nonempty": 7923
+   "corpus_elements": 24993,
+   "corpus_nonempty": 22536
   },
   {
    "name": "ownedStakeholderParameter",
@@ -6258,8 +6258,8 @@
       "ownedSpecializations",
       "subsettingFeature"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 5513,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 21386,
      "class": "structural"
     }
    ],
@@ -6268,8 +6268,8 @@
    "rules": {
     "Feature": "ownedSubsetting = ownedSpecialization->selectByKind(Subsetting)"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 5513
+   "corpus_elements": 23639,
+   "corpus_nonempty": 21386
   },
   {
    "name": "ownedTransition",
@@ -6307,7 +6307,7 @@
   {
    "name": "ownedTypeFeaturing",
    "class": "structural",
-   "status": "absent",
+   "status": "derived",
    "declaring": [
     {
      "metaclass": "Feature",
@@ -6326,8 +6326,8 @@
       "featureOfType",
       "ownedRelationships"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 0,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 5016,
      "class": "structural"
     }
    ],
@@ -6336,8 +6336,8 @@
    "rules": {
     "Feature": "ownedTypeFeaturing = ownedRelationship->selectByKind(TypeFeaturing)-> select(tf | tf.featureOfType = self)"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 0
+   "corpus_elements": 23639,
+   "corpus_nonempty": 5016
   },
   {
    "name": "ownedTyping",
@@ -6361,8 +6361,8 @@
       "ownedSpecializations",
       "typedFeature"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 2780,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 3218,
      "class": "structural"
     }
    ],
@@ -6371,8 +6371,8 @@
    "rules": {
     "Feature": "ownedTyping = ownedGeneralization->selectByKind(FeatureTyping)"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 2780
+   "corpus_elements": 23639,
+   "corpus_nonempty": 3218
   },
   {
    "name": "ownedUnioning",
@@ -6396,7 +6396,7 @@
       "ownedRelationships",
       "typeUnioned"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -6406,7 +6406,7 @@
    "rules": {
     "Type": "ownedUnioning = ownedRelationship->selectByKind(Unioning)"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
@@ -6623,8 +6623,8 @@
       "owningRelatedElement",
       "owningRelationship"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 19249,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 25892,
      "class": "structural"
     }
    ],
@@ -6633,8 +6633,8 @@
    "rules": {
     "Element": "owner = owningRelationship.owningRelatedElement"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 19249
+   "corpus_elements": 91191,
+   "corpus_nonempty": 25892
   },
   {
    "name": "owningAnnotatedElement",
@@ -6721,7 +6721,7 @@
       "Annotation",
       "owningRelationship"
      ],
-     "corpus_elements": 632,
+     "corpus_elements": 587,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -6729,7 +6729,7 @@
    "concrete_carriers": 6,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 632,
+   "corpus_elements": 587,
    "corpus_nonempty": 0
   },
   {
@@ -6752,16 +6752,16 @@
       "Subclassification",
       "subclassifier"
      ],
-     "corpus_elements": 1151,
-     "corpus_nonempty": 1151,
+     "corpus_elements": 1183,
+     "corpus_nonempty": 1183,
      "class": "structural"
     }
    ],
    "concrete_carriers": 1,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 1151,
-   "corpus_nonempty": 1151
+   "corpus_elements": 1183,
+   "corpus_nonempty": 1183
   },
   {
    "name": "owningDefinition",
@@ -6836,8 +6836,8 @@
       "owningRelatedElement",
       "subsettingFeature"
      ],
-     "corpus_elements": 5637,
-     "corpus_nonempty": 5637,
+     "corpus_elements": 25908,
+     "corpus_nonempty": 25908,
      "class": "structural"
     },
     {
@@ -6857,16 +6857,16 @@
       "owningRelatedElement",
       "typedFeature"
      ],
-     "corpus_elements": 2787,
-     "corpus_nonempty": 2787,
+     "corpus_elements": 3225,
+     "corpus_nonempty": 3225,
      "class": "structural"
     }
    ],
    "concrete_carriers": 7,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 8424,
-   "corpus_nonempty": 8424
+   "corpus_elements": 29133,
+   "corpus_nonempty": 29133
   },
   {
    "name": "owningFeatureMembership",
@@ -6889,21 +6889,21 @@
       "ownedMemberFeature",
       "owningType"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 10203,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 15219,
      "class": "structural"
     }
    ],
    "concrete_carriers": 79,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 16951,
-   "corpus_nonempty": 10203
+   "corpus_elements": 23639,
+   "corpus_nonempty": 15219
   },
   {
    "name": "owningFeatureOfType",
    "class": "structural",
-   "status": "unexercised",
+   "status": "derived",
    "declaring": [
     {
      "metaclass": "TypeFeaturing",
@@ -6921,16 +6921,16 @@
       "featureOfType",
       "owningRelatedElement"
      ],
-     "corpus_elements": 0,
-     "corpus_nonempty": 0,
+     "corpus_elements": 5016,
+     "corpus_nonempty": 5016,
      "class": "structural"
     }
    ],
    "concrete_carriers": 1,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 0,
-   "corpus_nonempty": 0
+   "corpus_elements": 5016,
+   "corpus_nonempty": 5016
   },
   {
    "name": "owningMembership",
@@ -6954,16 +6954,16 @@
       "Relationship",
       "owningRelationship"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 18728,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 25371,
      "class": "structural"
     }
    ],
    "concrete_carriers": 167,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 52148,
-   "corpus_nonempty": 18728
+   "corpus_elements": 91191,
+   "corpus_nonempty": 25371
   },
   {
    "name": "owningNamespace",
@@ -6986,8 +6986,8 @@
       "membershipOwningNamespace",
       "owningMembership"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 18728,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 25371,
      "class": "structural"
     }
    ],
@@ -6996,8 +6996,8 @@
    "rules": {
     "Element": "owningNamespace = if owningMembership = null then null else owningMembership.membershipOwningNamespace endif"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 18728
+   "corpus_elements": 91191,
+   "corpus_nonempty": 25371
   },
   {
    "name": "owningType",
@@ -7039,8 +7039,8 @@
       "FeatureMembership",
       "Type"
      ],
-     "corpus_elements": 10203,
-     "corpus_nonempty": 10203,
+     "corpus_elements": 15219,
+     "corpus_nonempty": 15219,
      "class": "structural"
     },
     {
@@ -7080,8 +7080,8 @@
       "owningRelatedElement",
       "specific"
      ],
-     "corpus_elements": 9575,
-     "corpus_nonempty": 9575,
+     "corpus_elements": 30316,
+     "corpus_nonempty": 30316,
      "class": "structural"
     },
     {
@@ -7102,16 +7102,16 @@
       "owningFeatureMembership",
       "owningType"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 10203,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 15219,
      "class": "structural"
     }
    ],
    "concrete_carriers": 105,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 36820,
-   "corpus_nonempty": 30072
+   "corpus_elements": 69265,
+   "corpus_nonempty": 60845
   },
   {
    "name": "owningUsage",
@@ -7181,7 +7181,7 @@
       "parameters"
      ],
      "corpus_elements": 6120,
-     "corpus_nonempty": 2160,
+     "corpus_nonempty": 3832,
      "class": "inheritance-aware"
     }
    ],
@@ -7189,7 +7189,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 6379,
-   "corpus_nonempty": 2320
+   "corpus_nonempty": 3992
   },
   {
    "name": "partDefinition",
@@ -7210,7 +7210,7 @@
       "itemDefinitions"
      ],
      "corpus_elements": 1236,
-     "corpus_nonempty": 798,
+     "corpus_nonempty": 804,
      "class": "structural"
     }
    ],
@@ -7220,7 +7220,7 @@
     "PartUsage": "itemDefinition->selectByKind(PartDefinition)"
    },
    "corpus_elements": 1236,
-   "corpus_nonempty": 798
+   "corpus_nonempty": 804
   },
   {
    "name": "payloadArgument",
@@ -7423,7 +7423,7 @@
       "originalPortDefinition"
      ],
      "corpus_elements": 48,
-     "corpus_nonempty": 0,
+     "corpus_nonempty": 48,
      "class": "structural"
     },
     {
@@ -7441,7 +7441,7 @@
       "occurrenceDefinitions"
      ],
      "corpus_elements": 365,
-     "corpus_nonempty": 305,
+     "corpus_nonempty": 311,
      "class": "structural"
     }
    ],
@@ -7451,7 +7451,7 @@
     "ConjugatedPortTyping": "portDefinition = conjugatedPortDefinition.originalPortDefinition"
    },
    "corpus_elements": 413,
-   "corpus_nonempty": 305
+   "corpus_nonempty": 359
   },
   {
    "name": "predicate",
@@ -7470,7 +7470,7 @@
      "doc": "The Predicate that types the Expression.",
      "doc_refs": [],
      "corpus_elements": 291,
-     "corpus_nonempty": 127,
+     "corpus_nonempty": 132,
      "class": "structural"
     }
    ],
@@ -7478,7 +7478,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 291,
-   "corpus_nonempty": 127
+   "corpus_nonempty": 132
   },
   {
    "name": "qualifiedName",
@@ -7501,8 +7501,8 @@
       "owningNamespace",
       "qualifiedName"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 7351,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 7313,
      "class": "structural"
     }
    ],
@@ -7511,8 +7511,8 @@
    "rules": {
     "Element": "qualifiedName =     if owningNamespace = null then null     else if name <> null and          owningNamespace.ownedMember->         select(m | m.name = name).indexOf(self) <> 1 then null     else if owningNamespace.owner = null then escapedName()     else if owningNamespace.qualifiedName = null or              escapedName() = null then null     else owningNamespace.qualifiedName + '::' + escapedName()     endif endif endif endif"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 7351
+   "corpus_elements": 91191,
+   "corpus_nonempty": 7313
   },
   {
    "name": "receiverArgument",
@@ -7715,16 +7715,16 @@
       "ReferenceSubsetting",
       "subsettingFeature"
      ],
-     "corpus_elements": 1164,
-     "corpus_nonempty": 1164,
+     "corpus_elements": 4876,
+     "corpus_nonempty": 4876,
      "class": "structural"
     }
    ],
    "concrete_carriers": 1,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 1164,
-   "corpus_nonempty": 1164
+   "corpus_elements": 4876,
+   "corpus_nonempty": 4876
   },
   {
    "name": "referent",
@@ -7795,8 +7795,8 @@
       "source",
       "target"
      ],
-     "corpus_elements": 33397,
-     "corpus_nonempty": 32658,
+     "corpus_elements": 67469,
+     "corpus_nonempty": 67399,
      "class": "structural"
     }
    ],
@@ -7805,8 +7805,8 @@
    "rules": {
     "Relationship": "relatedElement = source->union(target)"
    },
-   "corpus_elements": 33397,
-   "corpus_nonempty": 32658
+   "corpus_elements": 67469,
+   "corpus_nonempty": 67399
   },
   {
    "name": "relatedFeature",
@@ -7829,8 +7829,8 @@
       "Relationship",
       "connectorEnds"
      ],
-     "corpus_elements": 689,
-     "corpus_nonempty": 531,
+     "corpus_elements": 2361,
+     "corpus_nonempty": 2341,
      "class": "inheritance-aware"
     }
    ],
@@ -7839,8 +7839,8 @@
    "rules": {
     "Connector": "relatedFeature = connectorEnd.ownedReferenceSubsetting-> select(s | s <> null).subsettedFeature"
    },
-   "corpus_elements": 689,
-   "corpus_nonempty": 531
+   "corpus_elements": 2361,
+   "corpus_nonempty": 2341
   },
   {
    "name": "relatedType",
@@ -7962,16 +7962,16 @@
       "Element",
       "TextualRepresentation"
      ],
-     "corpus_elements": 91,
-     "corpus_nonempty": 91,
+     "corpus_elements": 46,
+     "corpus_nonempty": 46,
      "class": "structural"
     }
    ],
    "concrete_carriers": 1,
    "also_owned_elsewhere": false,
    "rules": {},
-   "corpus_elements": 91,
-   "corpus_nonempty": 91
+   "corpus_elements": 46,
+   "corpus_nonempty": 46
   },
   {
    "name": "requiredConstraint",
@@ -8053,7 +8053,7 @@
       "definition"
      ],
      "corpus_elements": 171,
-     "corpus_nonempty": 88,
+     "corpus_nonempty": 93,
      "class": "structural"
     }
    ],
@@ -8061,7 +8061,7 @@
    "also_owned_elsewhere": false,
    "rules": {},
    "corpus_elements": 171,
-   "corpus_nonempty": 88
+   "corpus_nonempty": 93
   },
   {
    "name": "result",
@@ -8088,7 +8088,7 @@
       "result"
      ],
      "corpus_elements": 5092,
-     "corpus_nonempty": 110,
+     "corpus_nonempty": 2674,
      "class": "inheritance-aware"
     },
     {
@@ -8115,7 +8115,7 @@
     "Function": "result =     let resultParams : Sequence(Feature) =         featureMemberships->             selectByKind(ReturnParameterMembership).             ownedMemberParameter in     if resultParams->notEmpty() then resultParams->first()     else null     endif"
    },
    "corpus_elements": 5219,
-   "corpus_nonempty": 157
+   "corpus_nonempty": 2721
   },
   {
    "name": "resultExpression",
@@ -8380,8 +8380,8 @@
       "owningNamespace",
       "shortName"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 77,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 74,
      "class": "structural"
     }
    ],
@@ -8390,8 +8390,8 @@
    "rules": {
     "Element": "shortName = effectiveShortName()"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 77
+   "corpus_elements": 91191,
+   "corpus_nonempty": 74
   },
   {
    "name": "source",
@@ -8446,8 +8446,8 @@
       "Connector",
       "relatedFeature"
      ],
-     "corpus_elements": 689,
-     "corpus_nonempty": 531,
+     "corpus_elements": 2361,
+     "corpus_nonempty": 2269,
      "class": "inheritance-aware"
     }
    ],
@@ -8456,8 +8456,8 @@
    "rules": {
     "Connector": "sourceFeature = if relatedFeature->isEmpty() then null else relatedFeature->first() endif"
    },
-   "corpus_elements": 689,
-   "corpus_nonempty": 531
+   "corpus_elements": 2361,
+   "corpus_nonempty": 2269
   },
   {
    "name": "sourceOutputFeature",
@@ -8909,8 +8909,8 @@
       "relatedFeatures",
       "sourceFeature"
      ],
-     "corpus_elements": 689,
-     "corpus_nonempty": 367,
+     "corpus_elements": 2361,
+     "corpus_nonempty": 2341,
      "class": "inheritance-aware"
     }
    ],
@@ -8920,8 +8920,8 @@
     "FeatureChainExpression": "targetFeature =     let nonParameterMemberships : Sequence(Membership) = ownedMembership->         reject(oclIsKindOf(ParameterMembership)) in     if nonParameterMemberships->isEmpty() or        not nonParameterMemberships->first().memberElement.oclIsKindOf(Feature)     then null     else nonParameterMemberships->first().memberElement.oclAsType(Feature)     endif",
     "Connector": "targetFeature =     if relatedFeature->size() < 2 then OrderedSet{}     else          relatedFeature->             subSequence(2, relatedFeature->size())->             asOrderedSet()     endif"
    },
-   "corpus_elements": 1127,
-   "corpus_nonempty": 805
+   "corpus_elements": 2799,
+   "corpus_nonempty": 2779
   },
   {
    "name": "targetInputFeature",
@@ -9091,8 +9091,8 @@
       "Element",
       "TextualRepresentations"
      ],
-     "corpus_elements": 52148,
-     "corpus_nonempty": 91,
+     "corpus_elements": 91191,
+     "corpus_nonempty": 46,
      "class": "structural"
     }
    ],
@@ -9101,8 +9101,8 @@
    "rules": {
     "Element": "textualRepresentation = ownedElement->selectByKind(TextualRepresentation)"
    },
-   "corpus_elements": 52148,
-   "corpus_nonempty": 91
+   "corpus_elements": 91191,
+   "corpus_nonempty": 46
   },
   {
    "name": "thenAction",
@@ -9220,8 +9220,8 @@
       "types",
       "typings"
      ],
-     "corpus_elements": 16951,
-     "corpus_nonempty": 4906,
+     "corpus_elements": 23639,
+     "corpus_nonempty": 10387,
      "class": "structural"
     }
    ],
@@ -9230,8 +9230,8 @@
    "rules": {
     "Feature": "type =      let types : OrderedSet(Types) = OrderedSet{self}->         -- Note: The closure operation automatically handles circular relationships.         closure(typingFeatures()).typing.type->asOrderedSet() in     types->reject(t1 | types->exist(t2 | t2 <> t1 and t2.specializes(t1)))"
    },
-   "corpus_elements": 16951,
-   "corpus_nonempty": 4906
+   "corpus_elements": 23639,
+   "corpus_nonempty": 10387
   },
   {
    "name": "typeDifferenced",
@@ -9351,7 +9351,7 @@
       "unioningType",
       "unioningTypes"
      ],
-     "corpus_elements": 18305,
+     "corpus_elements": 24993,
      "corpus_nonempty": 0,
      "class": "structural"
     }
@@ -9361,7 +9361,7 @@
    "rules": {
     "Type": "unioningType = ownedUnioning.unioningType"
    },
-   "corpus_elements": 18305,
+   "corpus_elements": 24993,
    "corpus_nonempty": 0
   },
   {
diff --git a/spec-refs/derived-properties.md b/spec-refs/derived-properties.md
index 5a32674..a4e4583 100644
--- a/spec-refs/derived-properties.md
+++ b/spec-refs/derived-properties.md
@@ -6,10 +6,10 @@ Generated by `tools/derived_census.py` from `spec-refs/{KerML,SysML}.xmi` (20250
 
 | Class | Total | derived | unexercised | absent |
 |---|---|---|---|---|
-| structural | 222 | 197 | 6 | 19 |
+| structural | 222 | 201 | 5 | 16 |
 | inheritance-aware | 53 | 50 | 0 | 3 |
 | closure | 4 | 0 | 0 | 4 |
-| **all** | 279 | 247 | 6 | 26 |
+| **all** | 279 | 251 | 5 | 23 |
 
 A *closure* is one of the four inheritance/import closures; an *inheritance-aware* property is one whose derivation rule (or, for a property without an OCL rule, the property it redefines, or its normative documentation's direct closure reference) transitively reads a closure, so its passthrough-level value is an owned-only approximation until the closure policy is on; everything else is *structural*. Hand adjudications: `expression` → inheritance-aware. A name's class is the strongest over its declarations; names whose declarations disagree: `action`, `targetFeature`, `verifiedRequirement`.
 
@@ -24,98 +24,98 @@ Names that are derived on one metaclass and owned on another (corpus fill counts
 | Name | Class | Status | Declared by | Carriers | Type | Corpus non-empty / elements |
 |---|---|---|---|---|---|---|
 | `action` | inheritance-aware | derived | StateSubactionMembership, ActionDefinition | 9 | ActionUsage | 88 / 257 |
-| `actionDefinition` | structural | derived | ActionUsage | 24 | Behavior | 273 / 1124 |
+| `actionDefinition` | structural | derived | ActionUsage | 24 | Behavior | 275 / 1124 |
 | `actorParameter` | inheritance-aware | derived | RequirementUsage, RequirementDefinition, CaseUsage, CaseDefinition | 16 | PartUsage | 22 / 303 |
 | `allocation` | inheritance-aware | absent | AllocationDefinition | 1 | AllocationUsage | 0 / 5 |
 | `allocationDefinition` | structural | derived | AllocationUsage | 1 | AllocationDefinition | 5 / 18 |
 | `analysisCaseDefinition` | structural | derived | AnalysisCaseUsage | 1 | AnalysisCaseDefinition | 24 / 26 |
-| `annotatedElement` | structural | derived | AnnotatingElement | 6 | Element | 632 / 632 |
+| `annotatedElement` | structural | derived | AnnotatingElement | 6 | Element | 587 / 587 |
 | `annotatingElement` | structural | derived | Annotation | 1 | AnnotatingElement | 19 / 19 |
-| `annotation` | structural | derived | AnnotatingElement | 6 | Annotation | 16 / 632 |
+| `annotation` | structural | derived | AnnotatingElement | 6 | Annotation | 16 / 587 |
 | `argument` | inheritance-aware | derived | InstantiationExpression | 8 | Expression | 1585 / 1605 |
 | `assertedConstraint` | structural | derived | AssertConstraintUsage | 2 | ConstraintUsage | 22 / 69 |
-| `association` | structural | derived | Connector | 12 | Association | 63 / 689 |
+| `association` | structural | derived | Connector | 12 | Association | 63 / 2361 |
 | `associationEnd` | inheritance-aware | derived | Association | 7 | Feature | 46 / 50 |
 | `assumedConstraint` | structural | derived | RequirementUsage, RequirementDefinition | 7 | ConstraintUsage | 19 / 208 |
-| `attributeDefinition` | structural | derived | AttributeUsage | 2 | DataType | 778 / 869 |
-| `behavior` | structural | derived | Step | 53 | Behavior | 400 / 6120 |
+| `attributeDefinition` | structural | derived | AttributeUsage | 2 | DataType | 775 / 869 |
+| `behavior` | structural | derived | Step | 53 | Behavior | 845 / 6120 |
 | `bodyAction` | structural | derived | LoopActionUsage | 2 | ActionUsage | 5 / 8 |
 | `bound` | structural | derived | MultiplicityRange | 1 | Expression | 576 / 576 |
 | `calculation` | inheritance-aware | derived | CalculationDefinition | 5 | CalculationUsage | 6 / 69 |
-| `calculationDefinition` | structural | derived | CalculationUsage | 6 | Function | 68 / 96 |
+| `calculationDefinition` | structural | derived | CalculationUsage | 6 | Function | 70 / 96 |
 | `caseDefinition` | structural | derived | CaseUsage | 5 | CaseDefinition | 44 / 65 |
-| `chainingFeature` | structural | derived | Feature | 79 | Feature | 588 / 16951 |
+| `chainingFeature` | structural | derived | Feature | 79 | Feature | 588 / 23639 |
 | `concernDefinition` | structural | derived | ConcernUsage | 1 | ConcernDefinition | 3 / 11 |
 | `condition` | structural | derived | ElementFilterMembership | 1 | Expression | 26 / 26 |
 | `conjugatedPortDefinition` | structural | derived | PortConjugation, PortDefinition | 3 | ConjugatedPortDefinition | 182 / 273 |
 | `connectionDefinition` | structural | derived | ConnectionUsage | 3 | AssociationStructure | 52 / 127 |
 | `connectionEnd` | inheritance-aware | derived | ConnectionDefinition | 3 | Usage | 45 / 48 |
-| `connectorEnd` | inheritance-aware | derived | Connector | 12 | Feature | 670 / 689 |
-| `constraintDefinition` | structural | derived | ConstraintUsage | 6 | Predicate | 127 / 291 |
-| `crossFeature` | structural | derived | Feature | 79 | Feature | 2 / 16951 |
+| `connectorEnd` | inheritance-aware | derived | Connector | 12 | Feature | 2342 / 2361 |
+| `constraintDefinition` | structural | derived | ConstraintUsage | 6 | Predicate | 132 / 291 |
+| `crossFeature` | structural | derived | Feature | 79 | Feature | 2 / 23639 |
 | `crossingFeature` | structural | derived | CrossSubsetting | 1 | Feature | 2 / 2 |
-| `defaultFeaturingType` | inheritance-aware | derived | Connector | 12 | Type | 475 / 689 |
-| `definition` | structural | derived | Usage | 47 | Classifier | 4244 / 8045 |
-| `differencingType` | structural | absent | Type | 117 | Type | 0 / 18305 |
-| `directedFeature` | inheritance-aware | derived | Type | 117 | Feature | 2635 / 18305 |
+| `defaultFeaturingType` | inheritance-aware | derived | Connector | 12 | Type | 1200 / 2361 |
+| `definition` | structural | derived | Usage | 47 | Classifier | 4476 / 8045 |
+| `differencingType` | structural | absent | Type | 117 | Type | 0 / 24993 |
+| `directedFeature` | inheritance-aware | derived | Type | 117 | Feature | 4307 / 24993 |
 | `directedUsage` | inheritance-aware | derived | Usage, Definition | 73 | Usage | 758 / 9399 |
 | `doAction` | structural | derived | StateUsage, StateDefinition | 3 | ActionUsage | 18 / 177 |
-| `documentation` | structural | derived | Element | 167 | Documentation | 156 / 52148 |
+| `documentation` | structural | derived | Element | 167 | Documentation | 156 / 91191 |
 | `documentedElement` | structural | derived | Documentation | 1 | Element | 157 / 157 |
 | `effectAction` | structural | derived | TransitionUsage | 1 | ActionUsage | 20 / 111 |
 | `elseAction` | structural | derived | IfActionUsage | 1 | ActionUsage | 2 / 4 |
-| `endFeature` | inheritance-aware | derived | Type | 117 | Feature | 716 / 18305 |
-| `endOwningType` | structural | derived | Feature | 79 | Type | 1420 / 16951 |
+| `endFeature` | inheritance-aware | derived | Type | 117 | Feature | 2388 / 24993 |
+| `endOwningType` | structural | derived | Feature | 79 | Type | 4764 / 23639 |
 | `entryAction` | structural | derived | StateUsage, StateDefinition | 3 | ActionUsage | 31 / 177 |
 | `enumeratedValue` | structural | derived | EnumerationDefinition | 1 | EnumerationUsage | 18 / 19 |
 | `enumerationDefinition` | structural | derived | EnumerationUsage | 1 | EnumerationDefinition | 54 / 55 |
 | `eventOccurrence` | structural | derived | EventOccurrenceUsage | 4 | OccurrenceUsage | 184 / 324 |
 | `exhibitedState` | structural | derived | ExhibitStateUsage | 1 | StateUsage | 10 / 29 |
 | `exitAction` | structural | derived | StateUsage, StateDefinition | 3 | ActionUsage | 7 / 177 |
-| `exposedElement` | inheritance-aware | derived | ViewUsage | 1 | Element | 5 / 12 |
+| `exposedElement` | inheritance-aware | derived | ViewUsage | 1 | Element | 8 / 12 |
 | `expression` | inheritance-aware | derived | Function | 11 | Expression | 56 / 127 |
-| `feature` | inheritance-aware | derived | Type | 117 | Feature | 4942 / 18305 |
+| `feature` | inheritance-aware | derived | Type | 117 | Feature | 8286 / 24993 |
 | `featureChained` | structural | derived | FeatureChaining | 1 | Feature | 1331 / 1331 |
-| `featureMembership` | inheritance-aware | derived | Type | 117 | FeatureMembership | 4942 / 18305 |
-| `featureTarget` | structural | derived | Feature | 79 | Feature | 588 / 16951 |
+| `featureMembership` | inheritance-aware | derived | Type | 117 | FeatureMembership | 8286 / 24993 |
+| `featureTarget` | structural | derived | Feature | 79 | Feature | 588 / 23639 |
 | `featureWithValue` | structural | derived | FeatureValue | 1 | Feature | 3825 / 3825 |
-| `featuringType` | closure | absent | Feature | 79 | Type | 0 / 16951 |
+| `featuringType` | closure | absent | Feature | 79 | Type | 0 / 23639 |
 | `filterCondition` | structural | derived | Package | 2 | Expression | 20 / 481 |
 | `flowDefinition` | structural | derived | FlowUsage | 2 | Interaction | 8 / 142 |
 | `flowEnd` | inheritance-aware | derived | Flow, FlowDefinition | 5 | FlowEnd, Usage | 122 / 144 |
 | `framedConcern` | inheritance-aware | derived | RequirementUsage, RequirementDefinition | 7 | ConcernUsage | 5 / 208 |
-| `function` | structural | derived | Expression | 32 | Function | 195 / 5092 |
+| `function` | structural | derived | Expression | 32 | Function | 640 / 5092 |
 | `guardExpression` | structural | derived | TransitionUsage | 1 | Expression | 21 / 111 |
 | `ifArgument` | structural | derived | IfActionUsage | 1 | Expression | 4 / 4 |
 | `importOwningNamespace` | structural | derived | Import | 4 | Namespace | 566 / 566 |
 | `importedElement` | structural | derived | Import | 4 | Element | 566 / 566 |
-| `importedMembership` | closure | absent | Namespace | 120 | Membership | 0 / 19037 |
+| `importedMembership` | closure | absent | Namespace | 120 | Membership | 0 / 25725 |
 | `includedUseCase` | structural | derived | UseCaseUsage, UseCaseDefinition | 3 | UseCaseUsage | 7 / 40 |
 | `individualDefinition` | structural | derived | OccurrenceUsage | 41 | OccurrenceDefinition | 61 / 3627 |
-| `inheritedFeature` | closure | absent | Type | 117 | Feature | 0 / 18305 |
-| `inheritedMembership` | closure | absent | Type | 117 | Membership | 0 / 18305 |
-| `input` | inheritance-aware | derived | Type | 117 | Feature | 2414 / 18305 |
+| `inheritedFeature` | closure | absent | Type | 117 | Feature | 0 / 24993 |
+| `inheritedMembership` | closure | absent | Type | 117 | Membership | 0 / 24993 |
+| `input` | inheritance-aware | derived | Type | 117 | Feature | 2414 / 24993 |
 | `instantiatedType` | structural | derived | InstantiationExpression | 8 | Type | 1605 / 1605 |
 | `interaction` | structural | derived | Flow | 4 | Interaction | 8 / 142 |
 | `interfaceDefinition` | structural | derived | InterfaceUsage | 1 | InterfaceDefinition | 28 / 37 |
 | `interfaceEnd` | inheritance-aware | derived | InterfaceDefinition | 1 | PortUsage | 17 / 17 |
-| `intersectingType` | structural | absent | Type | 117 | Type | 0 / 18305 |
-| `isConjugated` | structural | derived | Type | 117 | Boolean | 91 / 18305 |
-| `isLibraryElement` | structural | derived | Element | 167 | Boolean | 1093 / 52148 |
-| `isModelLevelEvaluable` | structural | derived | Expression, Function | 43 | Boolean | 2441 / 5219 |
+| `intersectingType` | structural | absent | Type | 117 | Type | 0 / 24993 |
+| `isConjugated` | structural | derived | Type | 117 | Boolean | 91 / 24993 |
+| `isLibraryElement` | structural | derived | Element | 167 | Boolean | 1376 / 91191 |
+| `isModelLevelEvaluable` | structural | derived | Expression, Function | 43 | Boolean | 2184 / 5219 |
 | `isReference` | structural | derived | EventOccurrenceUsage, Usage, ReferenceUsage, AttributeUsage | 47 | Boolean | 5766 / 8045 |
-| `itemDefinition` | structural | derived | ItemUsage | 8 | Structure | 1125 / 1605 |
+| `itemDefinition` | structural | derived | ItemUsage | 8 | Structure | 1167 / 1605 |
 | `loopVariable` | structural | derived | ForLoopActionUsage | 1 | ReferenceUsage | 3 / 3 |
 | `lowerBound` | structural | derived | MultiplicityRange | 1 | Expression | 116 / 576 |
 | `mayTimeVary` | structural | derived | Usage | 47 | Boolean | 1212 / 8045 |
-| `member` | inheritance-aware | derived | Namespace | 120 | Element | 12491 / 19037 |
-| `memberElementId` | structural | derived | Membership | 20 | String | 21066 / 21066 |
-| `membership` | inheritance-aware | derived | Namespace | 120 | Membership | 12491 / 19037 |
-| `membershipOwningNamespace` | structural | derived | Membership | 20 | Namespace | 21066 / 21066 |
+| `member` | inheritance-aware | derived | Namespace | 120 | Element | 14163 / 25725 |
+| `memberElementId` | structural | derived | Membership | 20 | String | 27709 / 27709 |
+| `membership` | inheritance-aware | derived | Namespace | 120 | Membership | 14163 / 25725 |
+| `membershipOwningNamespace` | structural | derived | Membership | 20 | Namespace | 27709 / 27709 |
 | `metaclass` | structural | derived | MetadataFeature | 2 | Metaclass | 179 / 179 |
 | `metadataDefinition` | structural | derived | MetadataUsage | 1 | Metaclass | 179 / 179 |
-| `multiplicity` | structural | derived | Type | 117 | Multiplicity | 576 / 18305 |
-| `name` | structural | derived | Element | 167 | String | 9724 / 52148 |
+| `multiplicity` | structural | derived | Type | 117 | Multiplicity | 576 / 24993 |
+| `name` | structural | derived | Element | 167 | String | 14342 / 91191 |
 | `nestedAction` | structural | derived | Usage | 47 | ActionUsage | 379 / 8045 |
 | `nestedAllocation` | structural | derived | Usage | 47 | AllocationUsage | 9 / 8045 |
 | `nestedAnalysisCase` | structural | derived | Usage | 47 | AnalysisCaseUsage | 7 / 8045 |
@@ -126,8 +126,8 @@ Names that are derived on one metaclass and owned on another (corpus fill counts
 | `nestedConnection` | structural | derived | Usage | 47 | ConnectorAsUsage | 169 / 8045 |
 | `nestedConstraint` | structural | derived | Usage | 47 | ConstraintUsage | 113 / 8045 |
 | `nestedEnumeration` | structural | absent | Usage | 47 | EnumerationUsage | 0 / 8045 |
-| `nestedFlow` | structural | absent | Usage | 47 | FlowUsage | 0 / 8045 |
-| `nestedInterface` | structural | derived | Usage | 47 | InterfaceUsage | 1290 / 8045 |
+| `nestedFlow` | structural | derived | Usage | 47 | FlowUsage | 47 / 8045 |
+| `nestedInterface` | structural | derived | Usage | 47 | InterfaceUsage | 17 / 8045 |
 | `nestedItem` | structural | derived | Usage | 47 | ItemUsage | 407 / 8045 |
 | `nestedMetadata` | structural | absent | Usage | 47 | MetadataUsage | 0 / 8045 |
 | `nestedOccurrence` | structural | derived | Usage | 47 | OccurrenceUsage | 1004 / 8045 |
@@ -144,122 +144,122 @@ Names that are derived on one metaclass and owned on another (corpus fill counts
 | `nestedView` | structural | derived | Usage | 47 | ViewUsage | 3 / 8045 |
 | `nestedViewpoint` | structural | absent | Usage | 47 | ViewpointUsage | 0 / 8045 |
 | `objectiveRequirement` | inheritance-aware | derived | CaseUsage, CaseDefinition | 9 | RequirementUsage | 26 / 95 |
-| `occurrenceDefinition` | structural | derived | OccurrenceUsage | 41 | Class | 1918 / 3627 |
+| `occurrenceDefinition` | structural | derived | OccurrenceUsage | 41 | Class | 1973 / 3627 |
 | `originalPortDefinition` | structural | derived | ConjugatedPortDefinition | 1 | PortDefinition | 91 / 91 |
-| `output` | inheritance-aware | derived | Type | 117 | Feature | 584 / 18305 |
+| `output` | inheritance-aware | derived | Type | 117 | Feature | 2256 / 24993 |
 | `ownedAction` | structural | derived | Definition | 26 | ActionUsage | 73 / 1354 |
 | `ownedActorParameter` | structural | derived | ActorMembership | 1 | PartUsage | 42 / 42 |
 | `ownedAllocation` | structural | absent | Definition | 26 | AllocationUsage | 0 / 1354 |
 | `ownedAnalysisCase` | structural | derived | Definition | 26 | AnalysisCaseUsage | 2 / 1354 |
 | `ownedAnnotatingElement` | structural | unexercised | Annotation | 1 | AnnotatingElement | 0 / 19 |
-| `ownedAnnotatingRelationship` | structural | derived | AnnotatingElement | 6 | Annotation | 16 / 632 |
-| `ownedAnnotation` | structural | unexercised | Element | 167 | Annotation | 0 / 52148 |
+| `ownedAnnotatingRelationship` | structural | derived | AnnotatingElement | 6 | Annotation | 16 / 587 |
+| `ownedAnnotation` | structural | unexercised | Element | 167 | Annotation | 0 / 91191 |
 | `ownedAttribute` | structural | derived | Definition | 26 | AttributeUsage | 219 / 1354 |
 | `ownedCalculation` | structural | derived | Definition | 26 | CalculationUsage | 7 / 1354 |
 | `ownedCase` | structural | derived | Definition | 26 | CaseUsage | 5 / 1354 |
 | `ownedConcern` | structural | derived | FramedConcernMembership, Definition | 27 | ConcernUsage | 8 / 1360 |
-| `ownedConjugator` | structural | derived | Type | 117 | Conjugation | 91 / 18305 |
+| `ownedConjugator` | structural | derived | Type | 117 | Conjugation | 91 / 24993 |
 | `ownedConnection` | structural | derived | Definition | 26 | ConnectorAsUsage | 42 / 1354 |
 | `ownedConstraint` | structural | derived | RequirementConstraintMembership, Definition | 29 | ConstraintUsage | 127 / 1420 |
-| `ownedCrossSubsetting` | structural | derived | Feature | 79 | CrossSubsetting | 2 / 16951 |
-| `ownedDifferencing` | structural | absent | Type | 117 | Differencing | 0 / 18305 |
-| `ownedDisjoining` | structural | unexercised | Type | 117 | Disjoining | 0 / 18305 |
-| `ownedElement` | structural | derived | Element | 167 | Element | 11182 / 52148 |
-| `ownedEndFeature` | structural | derived | Type | 117 | Feature | 716 / 18305 |
+| `ownedCrossSubsetting` | structural | derived | Feature | 79 | CrossSubsetting | 2 / 23639 |
+| `ownedDifferencing` | structural | absent | Type | 117 | Differencing | 0 / 24993 |
+| `ownedDisjoining` | structural | unexercised | Type | 117 | Disjoining | 0 / 24993 |
+| `ownedElement` | structural | derived | Element | 167 | Element | 14481 / 91191 |
+| `ownedEndFeature` | structural | derived | Type | 117 | Feature | 2388 / 24993 |
 | `ownedEnumeration` | structural | absent | Definition | 26 | EnumerationUsage | 0 / 1354 |
-| `ownedFeature` | structural | derived | Type | 117 | Feature | 4942 / 18305 |
-| `ownedFeatureChaining` | structural | derived | Feature | 79 | FeatureChaining | 588 / 16951 |
-| `ownedFeatureInverting` | structural | absent | Feature | 79 | FeatureInverting | 0 / 16951 |
-| `ownedFeatureMembership` | structural | derived | Type | 117 | FeatureMembership | 4942 / 18305 |
-| `ownedFlow` | structural | absent | Definition | 26 | FlowUsage | 0 / 1354 |
-| `ownedImport` | structural | derived | Namespace | 120 | Import | 279 / 19037 |
-| `ownedInterface` | structural | derived | Definition | 26 | InterfaceUsage | 265 / 1354 |
-| `ownedIntersecting` | structural | absent | Type | 117 | Intersecting | 0 / 18305 |
+| `ownedFeature` | structural | derived | Type | 117 | Feature | 8286 / 24993 |
+| `ownedFeatureChaining` | structural | derived | Feature | 79 | FeatureChaining | 588 / 23639 |
+| `ownedFeatureInverting` | structural | absent | Feature | 79 | FeatureInverting | 0 / 23639 |
+| `ownedFeatureMembership` | structural | derived | Type | 117 | FeatureMembership | 8286 / 24993 |
+| `ownedFlow` | structural | derived | Definition | 26 | FlowUsage | 20 / 1354 |
+| `ownedImport` | structural | derived | Namespace | 120 | Import | 279 / 25725 |
+| `ownedInterface` | structural | derived | Definition | 26 | InterfaceUsage | 2 / 1354 |
+| `ownedIntersecting` | structural | absent | Type | 117 | Intersecting | 0 / 24993 |
 | `ownedItem` | structural | derived | Definition | 26 | ItemUsage | 151 / 1354 |
-| `ownedMember` | structural | derived | Namespace | 120 | Element | 10764 / 19037 |
-| `ownedMemberElement` | structural | derived | OwningMembership | 19 | Element | 18728 / 18728 |
-| `ownedMemberElementId` | structural | derived | OwningMembership | 19 | String | 18728 / 18728 |
-| `ownedMemberFeature` | structural | derived | FeatureMembership, EndFeatureMembership | 15 | Feature | 10203 / 10203 |
-| `ownedMemberName` | structural | derived | OwningMembership | 19 | String | 9230 / 18728 |
-| `ownedMemberParameter` | structural | derived | ParameterMembership | 5 | Feature | 3432 / 3432 |
-| `ownedMemberShortName` | structural | derived | OwningMembership | 19 | String | 75 / 18728 |
-| `ownedMembership` | structural | derived | Namespace | 120 | Membership | 12491 / 19037 |
+| `ownedMember` | structural | derived | Namespace | 120 | Element | 14108 / 25725 |
+| `ownedMemberElement` | structural | derived | OwningMembership | 19 | Element | 25371 / 25371 |
+| `ownedMemberElementId` | structural | derived | OwningMembership | 19 | String | 25371 / 25371 |
+| `ownedMemberFeature` | structural | derived | FeatureMembership, EndFeatureMembership | 15 | Feature | 15219 / 15219 |
+| `ownedMemberName` | structural | derived | OwningMembership | 19 | String | 14342 / 25371 |
+| `ownedMemberParameter` | structural | derived | ParameterMembership | 5 | Feature | 5104 / 5104 |
+| `ownedMemberShortName` | structural | derived | OwningMembership | 19 | String | 74 / 25371 |
+| `ownedMembership` | structural | derived | Namespace | 120 | Membership | 14163 / 25725 |
 | `ownedMetadata` | structural | absent | Definition | 26 | MetadataUsage | 0 / 1354 |
 | `ownedObjectiveRequirement` | structural | derived | ObjectiveMembership | 1 | RequirementUsage | 26 / 26 |
 | `ownedOccurrence` | structural | derived | Definition | 26 | OccurrenceUsage | 301 / 1354 |
 | `ownedPart` | structural | derived | Definition | 26 | PartUsage | 107 / 1354 |
 | `ownedPort` | structural | derived | Definition | 26 | PortUsage | 76 / 1354 |
 | `ownedPortConjugator` | structural | derived | ConjugatedPortDefinition | 1 | PortConjugation | 91 / 91 |
-| `ownedRedefinition` | structural | derived | Feature | 79 | Redefinition | 1294 / 16951 |
+| `ownedRedefinition` | structural | derived | Feature | 79 | Redefinition | 5554 / 23639 |
 | `ownedReference` | structural | derived | Definition | 26 | ReferenceUsage | 265 / 1354 |
-| `ownedReferenceSubsetting` | structural | derived | Feature | 79 | ReferenceSubsetting | 1164 / 16951 |
+| `ownedReferenceSubsetting` | structural | derived | Feature | 79 | ReferenceSubsetting | 4876 / 23639 |
 | `ownedRendering` | structural | derived | Definition, ViewRenderingMembership | 27 | RenderingUsage | 14 / 1365 |
 | `ownedRequirement` | structural | derived | Definition, RequirementVerificationMembership | 27 | RequirementUsage | 29 / 1360 |
 | `ownedResultExpression` | structural | derived | ResultExpressionMembership | 1 | Expression | 105 / 105 |
-| `ownedSpecialization` | structural | derived | Type | 117 | Specialization | 7923 / 18305 |
+| `ownedSpecialization` | structural | derived | Type | 117 | Specialization | 22536 / 24993 |
 | `ownedStakeholderParameter` | structural | derived | StakeholderMembership | 1 | PartUsage | 7 / 7 |
 | `ownedState` | structural | derived | Definition | 26 | StateUsage | 19 / 1354 |
 | `ownedSubclassification` | structural | derived | Classifier | 37 | Subclassification | 1150 / 1354 |
 | `ownedSubjectParameter` | structural | derived | SubjectMembership | 1 | Usage | 122 / 122 |
-| `ownedSubsetting` | structural | derived | Feature | 79 | Subsetting | 5513 / 16951 |
+| `ownedSubsetting` | structural | derived | Feature | 79 | Subsetting | 21386 / 23639 |
 | `ownedTransition` | structural | derived | Definition | 26 | TransitionUsage | 6 / 1354 |
-| `ownedTypeFeaturing` | structural | absent | Feature | 79 | TypeFeaturing | 0 / 16951 |
-| `ownedTyping` | structural | derived | Feature | 79 | FeatureTyping | 2780 / 16951 |
-| `ownedUnioning` | structural | absent | Type | 117 | Unioning | 0 / 18305 |
+| `ownedTypeFeaturing` | structural | derived | Feature | 79 | TypeFeaturing | 5016 / 23639 |
+| `ownedTyping` | structural | derived | Feature | 79 | FeatureTyping | 3218 / 23639 |
+| `ownedUnioning` | structural | absent | Type | 117 | Unioning | 0 / 24993 |
 | `ownedUsage` | structural | derived | Definition | 26 | Usage | 660 / 1354 |
 | `ownedUseCase` | structural | derived | Definition | 26 | UseCaseUsage | 2 / 1354 |
 | `ownedVariantUsage` | structural | derived | VariantMembership | 1 | Usage | 107 / 107 |
 | `ownedVerificationCase` | structural | derived | Definition | 26 | VerificationCaseUsage | 1 / 1354 |
 | `ownedView` | structural | derived | Definition | 26 | ViewUsage | 1 / 1354 |
 | `ownedViewpoint` | structural | derived | Definition | 26 | ViewpointUsage | 1 / 1354 |
-| `owner` | structural | derived | Element | 167 | Element | 19249 / 52148 |
+| `owner` | structural | derived | Element | 167 | Element | 25892 / 91191 |
 | `owningAnnotatedElement` | structural | unexercised | Annotation | 1 | Element | 0 / 19 |
 | `owningAnnotatingElement` | structural | derived | Annotation | 1 | AnnotatingElement | 19 / 19 |
-| `owningAnnotatingRelationship` | structural | unexercised | AnnotatingElement | 6 | Annotation | 0 / 632 |
-| `owningClassifier` | structural | derived | Subclassification | 1 | Classifier | 1151 / 1151 |
+| `owningAnnotatingRelationship` | structural | unexercised | AnnotatingElement | 6 | Annotation | 0 / 587 |
+| `owningClassifier` | structural | derived | Subclassification | 1 | Classifier | 1183 / 1183 |
 | `owningDefinition` | structural | derived | Usage | 47 | Definition | 1703 / 8045 |
-| `owningFeature` | structural | derived | FeatureInverting, Subsetting, FeatureTyping | 7 | Feature | 8424 / 8424 |
-| `owningFeatureMembership` | structural | derived | Feature | 79 | FeatureMembership | 10203 / 16951 |
-| `owningFeatureOfType` | structural | unexercised | TypeFeaturing | 1 | Feature | 0 / 0 |
-| `owningMembership` | structural | derived | Element | 167 | OwningMembership | 18728 / 52148 |
-| `owningNamespace` | structural | derived | Element | 167 | Namespace | 18728 / 52148 |
-| `owningType` | structural | derived | Disjoining, FeatureMembership, Conjugation, Specialization, Feature | 105 | Type | 30072 / 36820 |
+| `owningFeature` | structural | derived | FeatureInverting, Subsetting, FeatureTyping | 7 | Feature | 29133 / 29133 |
+| `owningFeatureMembership` | structural | derived | Feature | 79 | FeatureMembership | 15219 / 23639 |
+| `owningFeatureOfType` | structural | derived | TypeFeaturing | 1 | Feature | 5016 / 5016 |
+| `owningMembership` | structural | derived | Element | 167 | OwningMembership | 25371 / 91191 |
+| `owningNamespace` | structural | derived | Element | 167 | Namespace | 25371 / 91191 |
+| `owningType` | structural | derived | Disjoining, FeatureMembership, Conjugation, Specialization, Feature | 105 | Type | 60845 / 69265 |
 | `owningUsage` | structural | derived | Usage | 47 | Usage | 5043 / 8045 |
-| `parameter` | inheritance-aware | derived | Behavior, Step | 69 | Feature | 2320 / 6379 |
-| `partDefinition` | structural | derived | PartUsage | 6 | PartDefinition | 798 / 1236 |
+| `parameter` | inheritance-aware | derived | Behavior, Step | 69 | Feature | 3992 / 6379 |
+| `partDefinition` | structural | derived | PartUsage | 6 | PartDefinition | 804 / 1236 |
 | `payloadArgument` | inheritance-aware | derived | AcceptActionUsage, SendActionUsage | 2 | Expression | 53 / 140 |
 | `payloadFeature` | structural | derived | Flow | 4 | PayloadFeature | 48 / 142 |
 | `payloadParameter` | inheritance-aware | derived | AcceptActionUsage | 1 | ReferenceUsage | 103 / 103 |
 | `payloadType` | structural | derived | Flow | 4 | Classifier | 48 / 142 |
 | `performedAction` | structural | derived | PerformActionUsage | 3 | ActionUsage | 113 / 195 |
-| `portDefinition` | structural | derived | ConjugatedPortTyping, PortUsage | 2 | PortDefinition | 305 / 413 |
-| `predicate` | structural | derived | BooleanExpression | 8 | Predicate | 127 / 291 |
-| `qualifiedName` | structural | derived | Element | 167 | String | 7351 / 52148 |
+| `portDefinition` | structural | derived | ConjugatedPortTyping, PortUsage | 2 | PortDefinition | 359 / 413 |
+| `predicate` | structural | derived | BooleanExpression | 8 | Predicate | 132 / 291 |
+| `qualifiedName` | structural | derived | Element | 167 | String | 7313 / 91191 |
 | `receiverArgument` | inheritance-aware | derived | AcceptActionUsage, SendActionUsage | 2 | Expression | 45 / 140 |
 | `referencedConcern` | structural | derived | FramedConcernMembership | 1 | ConcernUsage | 6 / 6 |
 | `referencedConstraint` | structural | derived | RequirementConstraintMembership | 3 | ConstraintUsage | 66 / 66 |
 | `referencedElement` | structural | derived | MetadataAccessExpression | 1 | Element | 27 / 27 |
 | `referencedRendering` | structural | derived | ViewRenderingMembership | 1 | RenderingUsage | 11 / 11 |
-| `referencingFeature` | structural | derived | ReferenceSubsetting | 1 | Feature | 1164 / 1164 |
+| `referencingFeature` | structural | derived | ReferenceSubsetting | 1 | Feature | 4876 / 4876 |
 | `referent` | structural | derived | FeatureReferenceExpression, AssignmentActionUsage | 2 | Feature | 1685 / 1749 |
-| `relatedElement` | structural | derived | Relationship | 62 | Element | 32658 / 33397 |
-| `relatedFeature` | inheritance-aware | derived | Connector | 12 | Feature | 531 / 689 |
+| `relatedElement` | structural | derived | Relationship | 62 | Element | 67399 / 67469 |
+| `relatedFeature` | inheritance-aware | derived | Connector | 12 | Feature | 2341 / 2361 |
 | `relatedType` | inheritance-aware | derived | Association | 7 | Type | 44 / 50 |
 | `rendering` | inheritance-aware | absent | RenderingDefinition | 1 | RenderingUsage | 0 / 1 |
 | `renderingDefinition` | structural | derived | RenderingUsage | 1 | RenderingDefinition | 13 / 14 |
-| `representedElement` | structural | derived | TextualRepresentation | 1 | Element | 91 / 91 |
+| `representedElement` | structural | derived | TextualRepresentation | 1 | Element | 46 / 46 |
 | `requiredConstraint` | structural | derived | RequirementUsage, RequirementDefinition | 7 | ConstraintUsage | 39 / 208 |
-| `requirementDefinition` | structural | derived | RequirementUsage | 4 | RequirementDefinition | 88 / 171 |
-| `result` | inheritance-aware | derived | Expression, Function | 43 | Feature | 157 / 5219 |
+| `requirementDefinition` | structural | derived | RequirementUsage | 4 | RequirementDefinition | 93 / 171 |
+| `result` | inheritance-aware | derived | Expression, Function | 43 | Feature | 2721 / 5219 |
 | `resultExpression` | structural | derived | AnalysisCaseUsage, AnalysisCaseDefinition | 2 | Expression | 2 / 40 |
 | `satisfiedRequirement` | structural | derived | SatisfyRequirementUsage | 1 | RequirementUsage | 18 / 22 |
 | `satisfiedViewpoint` | structural | derived | ViewUsage, ViewDefinition | 2 | ViewpointUsage | 1 / 22 |
 | `satisfyingFeature` | inheritance-aware | derived | SatisfyRequirementUsage | 1 | Feature | 19 / 22 |
 | `senderArgument` | inheritance-aware | derived | SendActionUsage | 1 | Expression | 14 / 37 |
 | `seqArgument` | inheritance-aware | derived | ForLoopActionUsage | 1 | Expression | 3 / 3 |
-| `shortName` | structural | derived | Element | 167 | String | 77 / 52148 |
+| `shortName` | structural | derived | Element | 167 | String | 74 / 91191 |
 | `source` | structural | derived | TransitionUsage | 1 | ActionUsage | 52 / 111 |
-| `sourceFeature` | inheritance-aware | derived | Connector | 12 | Feature | 531 / 689 |
+| `sourceFeature` | inheritance-aware | derived | Connector | 12 | Feature | 2269 / 2361 |
 | `sourceOutputFeature` | inheritance-aware | derived | Flow | 4 | Feature | 122 / 142 |
 | `sourceType` | inheritance-aware | derived | Association | 7 | Type | 44 / 50 |
 | `stakeholderParameter` | inheritance-aware | derived | RequirementUsage, RequirementDefinition | 7 | PartUsage | 6 / 208 |
@@ -270,20 +270,20 @@ Names that are derived on one metaclass and owned on another (corpus fill counts
 | `succession` | structural | derived | TransitionUsage | 1 | Succession | 111 / 111 |
 | `target` | structural | derived | TransitionUsage | 1 | ActionUsage | 111 / 111 |
 | `targetArgument` | inheritance-aware | derived | AssignmentActionUsage | 1 | Expression | 27 / 27 |
-| `targetFeature` | inheritance-aware | derived | FeatureChainExpression, Connector | 13 | Feature | 805 / 1127 |
+| `targetFeature` | inheritance-aware | derived | FeatureChainExpression, Connector | 13 | Feature | 2779 / 2799 |
 | `targetInputFeature` | inheritance-aware | derived | Flow | 4 | Feature | 122 / 142 |
 | `targetType` | inheritance-aware | derived | Association | 7 | Type | 44 / 50 |
 | `terminatedOccurrenceArgument` | inheritance-aware | derived | TerminateActionUsage | 1 | Expression | 3 / 6 |
 | `text` | structural | derived | RequirementUsage, RequirementDefinition | 7 | String | 59 / 208 |
-| `textualRepresentation` | structural | derived | Element | 167 | TextualRepresentation | 91 / 52148 |
+| `textualRepresentation` | structural | derived | Element | 167 | TextualRepresentation | 46 / 91191 |
 | `thenAction` | structural | derived | IfActionUsage | 1 | ActionUsage | 4 / 4 |
 | `transitionFeature` | structural | derived | TransitionFeatureMembership | 1 | Step | 121 / 121 |
 | `triggerAction` | structural | derived | TransitionUsage | 1 | AcceptActionUsage | 80 / 111 |
-| `type` | structural | derived | Feature | 79 | Type | 4906 / 16951 |
+| `type` | structural | derived | Feature | 79 | Type | 10387 / 23639 |
 | `typeDifferenced` | structural | absent | Differencing | 1 | Type | 0 / 0 |
 | `typeIntersected` | structural | absent | Intersecting | 1 | Type | 0 / 0 |
 | `typeUnioned` | structural | absent | Unioning | 1 | Type | 0 / 0 |
-| `unioningType` | structural | absent | Type | 117 | Type | 0 / 18305 |
+| `unioningType` | structural | absent | Type | 117 | Type | 0 / 24993 |
 | `untilArgument` | structural | derived | WhileLoopActionUsage | 1 | Expression | 1 / 5 |
 | `upperBound` | structural | derived | MultiplicityRange | 1 | Expression | 576 / 576 |
 | `usage` | inheritance-aware | derived | Usage, Definition | 73 | Usage | 2867 / 9399 |
diff --git a/tools/derived_census.py b/tools/derived_census.py
index e4e9cb8..421f660 100644
--- a/tools/derived_census.py
+++ b/tools/derived_census.py
@@ -341,7 +341,18 @@ def concrete_carriers(classes, prop_names):
     return carriers, derived_on, dual
 
 
-def write_compositions(records):
+# Published 20250201 constraint bodies conflict with their property types.
+# Keep these adjudications keyed to the exact rule tuple: a changed source rule
+# must be reviewed again instead of receiving an unconditional name override.
+COMPOSITION_ERRATA = {
+    ("ownedFlow", "ownedUsage", "FlowConnectionUsage"): "FlowUsage",
+    ("nestedFlow", "nestedUsage", "FlowConnectionUsage"): "FlowUsage",
+    ("ownedInterface", "ownedUsage", "ReferenceUsage"): "InterfaceUsage",
+    ("nestedInterface", "nestedUsage", "ReferenceUsage"): "InterfaceUsage",
+}
+
+
+def composition_rows(records, ancestors_of):
     """The kind-filtered compositions: every derived property whose OCL
     rule is `name = base->selectByKind(Kind)` (or `selectAsKind`), plus
     the rule-less `*Definition` back-references, which the normative
@@ -352,15 +363,24 @@ def write_compositions(records):
     # side (a few rules spell the expression alone).
     pat = re.compile(r"^\s*(?:(\w+)\s*=\s*)?(\w+)\s*->\s*select(?:By|As)Kind\(\s*(\w+)\s*\)\s*$")
     rows = {}
+    required_types = defaultdict(set)
     for r in records:
         name = r["name"]
         single = all(d["multiplicity"].endswith("..1") for d in r["declaring"])
-        for body in r["rules"].values():
+        for owner, body in r["rules"].items():
             m = pat.match(body.replace("\n", " "))
             lhs = LHS_ALIASES.get(m.group(1), m.group(1)) if m else None
             if m and lhs in (None, name):
                 base = BASE_ALIASES.get(m.group(2), m.group(2))
-                rows.setdefault(name, (base, m.group(3), single))
+                kind = COMPOSITION_ERRATA.get((name, base, m.group(3)), m.group(3))
+                candidate = (base, kind, single)
+                if name in rows and rows[name] != candidate:
+                    raise ValueError(f"conflicting composition rules for {name}: {rows[name]} / {candidate}")
+                rows[name] = candidate
+                for decl in r["declaring"]:
+                    declaring = decl["metaclass"]
+                    if declaring == owner or declaring in ancestors_of.get(owner, ()) or owner in ancestors_of.get(declaring, ()):
+                        required_types[name].add(decl["type"])
         # A `*Definition` back-reference declared on a usage without a rule
         # on that usage (per declaration: `PortUsage::portDefinition` has
         # no rule although `ConjugatedPortTyping::portDefinition` does).
@@ -374,6 +394,20 @@ def write_compositions(records):
                 kinds = sorted({d["type"] for d in decls})
                 if len(kinds) == 1:
                     rows.setdefault(name, ("definition", kinds[0], single))
+                    required_types[name].update(kinds)
+    for name, (_, kind, _) in rows.items():
+        if kind not in ancestors_of:
+            raise ValueError(f"unknown selected metaclass {kind} for {name}")
+        if not required_types[name]:
+            raise ValueError(f"no applicable result declaration for {name}")
+        for required in required_types[name]:
+            if kind != required and required not in ancestors_of[kind]:
+                raise ValueError(f"{name}: selected {kind} does not conform to {required}")
+    return rows
+
+
+def write_compositions(records, ancestors_of):
+    rows = composition_rows(records, ancestors_of)
     lines = [
         "//! Generated from `spec-refs/{KerML,SysML}.xmi` (normative metamodel",
         "//! 20250201) by `tools/derived_census.py` — do not edit.",
@@ -497,7 +531,7 @@ def main():
         )
 
     write_rust_table(classes, prop_names, set(derived), dual)
-    n_comp = write_compositions(records)
+    n_comp = write_compositions(records, ancestors_of)
     OUT_JSON.write_text(json.dumps({"source": "spec-refs/{KerML,SysML}.xmi 20250201", "generator": "tools/derived_census.py", "properties": records}, indent=1) + "\n")
 
     by_class = defaultdict(list)
diff --git a/tools/operation_catalog.py b/tools/operation_catalog.py
new file mode 100644
index 0000000..4017f20
--- /dev/null
+++ b/tools/operation_catalog.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Generate an operation declaration inventory, without inferring XMI signatures."""
+import json
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+NS = "{http://www.omg.org/spec/XMI/20161101}"
+OUT = ROOT / "crates/sysmlv2-model/src/operation_catalog.rs"
+
+
+def ref(e):
+    return e.get(NS + "idref", e.get("href", "").split("#")[-1])
+
+
+def generate():
+    roots = [ET.parse(ROOT / f"spec-refs/{name}.xmi").getroot() for name in ("KerML", "SysML")]
+    ids = {e.get(NS + "id"): e for root in roots for e in root.iter() if e.get(NS + "id")}
+    operations = sorted((op.get(NS + "id"), c, op) for c in ids.values()
+                        if c.get(NS + "type") == "uml:Class" for op in c.findall("ownedOperation"))
+    lines = [
+        '//! Generated by `tools/operation_catalog.py` from the normative 20250201 XMI.',
+        '//! Declaration metadata only; no executable support is implied.',
+        '',
+        '#[derive(Debug)]',
+        'pub struct ParameterSpec {',
+        "    pub id: &'static str,",
+        "    pub name: &'static str,",
+        "    pub target: &'static str,",
+        '    /// The explicit XMI direction, or None if omitted. No return role is inferred.',
+        "    pub direction: Option<&'static str>,",
+        '    pub lower: usize,',
+        '    pub upper: Option<usize>,',
+        '    pub ordered: bool,',
+        '    pub unique: bool,',
+        '}',
+        '',
+        '#[derive(Debug)]',
+        'pub struct OperationSpec {',
+        "    pub id: &'static str,",
+        "    pub declaring_metaclass: &'static str,",
+        "    pub name: &'static str,",
+        "    pub redefines: &'static [&'static str],",
+        '    /// Source declaration order, including unnamed parameters.',
+        "    pub parameters: &'static [ParameterSpec],",
+        '}',
+        '',
+        '#[rustfmt::skip]',
+        'pub static OPERATIONS: &[OperationSpec] = &[',
+    ]
+    for oid, owner, op in operations:
+        redefines = [ref(r) for r in op.findall('redefinedOperation')]
+        lines.append('    OperationSpec { id: %s, declaring_metaclass: %s, name: %s, redefines: &%s, parameters: &[' % (
+            json.dumps(oid), json.dumps(owner.get('name')), json.dumps(op.get('name')), json.dumps(redefines)))
+        for p in op.findall('ownedParameter'):
+            target = ref(p.find('type')) if p.find('type') is not None else p.get('type', '')
+            if target in ids:
+                target = ids[target].get('name')
+            lo, hi = p.find('lowerValue'), p.find('upperValue')
+            lower = int(lo.get('value', '0')) if lo is not None else 1
+            upper = hi.get('value', '0') if hi is not None else '1'
+            direction = f"Some({json.dumps(p.get('direction'))})" if 'direction' in p.attrib else 'None'
+            lines.append('        ParameterSpec { id: %s, name: %s, target: %s, direction: %s, lower: %s, upper: %s, ordered: %s, unique: %s },' % (
+                json.dumps(p.get(NS + 'id')), json.dumps(p.get('name', '')), json.dumps(target), direction,
+                lower, 'None' if upper in ('-1', '*') else f'Some({upper})',
+                str(p.get('isOrdered', 'false') == 'true').lower(), str(p.get('isUnique', 'true') == 'true').lower()))
+        lines.append('    ] },')
+    lines += ['];', '']
+    return '\n'.join(lines)
+
+
+if __name__ == '__main__':
+    content = generate()
+    if '--check' in sys.argv:
+        if OUT.read_text() != content:
+            raise SystemExit('operation catalog is stale; run python3 tools/operation_catalog.py')
+    else:
+        OUT.write_text(content)
diff --git a/tools/semantic_catalog.py b/tools/semantic_catalog.py
new file mode 100644
index 0000000..14cfc25
--- /dev/null
+++ b/tools/semantic_catalog.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Generate semantic property dispatch from the normative KerML/SysML XMI.
+
+Redefinitions retain the inherited spelling as an alias of the most specific
+property. Runtime lookup uses sorted tables, without loading XML or scanning
+the entire metamodel. Run with --check to verify committed output.
+"""
+import json
+import sys
+import xml.etree.ElementTree as ET
+from functools import lru_cache
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+NS = "{http://www.omg.org/spec/XMI/20161101}"
+OUT = ROOT / "crates/sysmlv2-model/src/semantic_catalog.rs"
+
+
+def ref(e):
+    return e.get(NS + "idref", e.get("href", "").split("#")[-1])
+
+
+def generate():
+    roots = [ET.parse(ROOT / f"spec-refs/{name}.xmi").getroot() for name in ("KerML", "SysML")]
+    ids = {e.get(NS + "id"): e for r in roots for e in r.iter() if e.get(NS + "id")}
+    classes = {i: e for i, e in ids.items() if e.get(NS + "type") == "uml:Class"}
+    props = {p.get(NS + "id"): (i, p) for i, c in classes.items() for p in c.findall("ownedAttribute")}
+    keys = sorted(props)
+    indices = {p: i for i, p in enumerate(keys)}
+
+    @lru_cache(None)
+    def ancestors(i):
+        return frozenset([i]).union(*(ancestors(ref(g)) for g in classes[i].findall("generalization/general")))
+
+    @lru_cache(None)
+    def redefines(i):
+        return frozenset([i]).union(*(redefines(ref(r)) for r in props[i][1].findall("redefinedProperty")))
+
+    def default(p):
+        d = p.find("defaultValue")
+        if d is None:
+            return "None"
+        kind = d.get(NS + "type", "")
+        value = d.get("value")
+        if kind == "uml:LiteralBoolean":
+            v = value == "true"
+        elif kind in ("uml:LiteralInteger", "uml:LiteralUnlimitedNatural"):
+            v = int(value or 0)
+        elif kind == "uml:LiteralString":
+            v = value or ""
+        elif kind == "uml:InstanceValue" and d.find("instance") is not None:
+            v = ids[ref(d.find("instance"))].get("name")
+        else:
+            raise ValueError(f"unsupported default: {ET.tostring(d)}")
+        return f"Some({json.dumps(json.dumps(v, separators=(',', ':')))})"
+
+    lines = [
+        '//! Generated by `tools/semantic_catalog.py` from the normative 20250201 XMI.',
+        '//! Do not edit; regenerate or use `--check`.',
+        '',
+        '#[derive(Debug)]',
+        'pub struct PropertySpec {',
+        "    pub id: &'static str,",
+        "    pub declaring_metaclass: &'static str,",
+        "    pub name: &'static str,",
+        "    pub target: &'static str,",
+        '    pub derived: bool,',
+        '    pub lower: usize,',
+        '    pub unique: bool,',
+        '    pub ordered: bool,',
+        "    pub enum_values: &'static [&'static str],",
+        '    pub upper: Option<usize>,',
+        "    pub default_json: Option<&'static str>,",
+        "    pub storage_names: &'static [&'static str],",
+        '}',
+        '',
+        '#[rustfmt::skip]',
+        'pub static PROPERTIES: &[PropertySpec] = &[',
+    ]
+    for i in keys:
+        owner, p = props[i]
+        target = ref(p.find("type")) if p.find("type") is not None else p.get("type", "")
+        enum_values = [e.get("name") for e in ids[target].findall("ownedLiteral")] if target in ids else []
+        target = ids[target].get("name") if target in ids else target
+        lo, hi = p.find("lowerValue"), p.find("upperValue")
+        lower = int(lo.get("value", "0")) if lo is not None else 1
+        upper = hi.get("value", "0") if hi is not None else "1"
+        names = [p.get("name")] + sorted({props[x][1].get("name") for x in redefines(i)} - {p.get("name")})
+        lines.append('    PropertySpec { id: %s, declaring_metaclass: %s, name: %s, target: %s, derived: %s, lower: %s, upper: %s, default_json: %s, storage_names: &%s, unique: %s, ordered: %s, enum_values: &%s },' % (
+            json.dumps(i), json.dumps(classes[owner].get("name")), json.dumps(p.get("name")), json.dumps(target), str(p.get("isDerived") == "true").lower(), lower,
+            "None" if upper in ("-1", "*") else f"Some({upper})", default(p), json.dumps(names), str(p.get("isUnique", "true") == "true").lower(), str(p.get("isOrdered", "false") == "true").lower(), json.dumps(enum_values)))
+    # A row's key is its requested declaration's own name, so rows hold
+    # indices only: a string reference per row would be most of the table's
+    # bytes, repeating what PROPERTIES already holds.
+    lines += ['];', '',
+              '/// One visible property of a metaclass: the `PROPERTIES` index of the',
+              '/// declaration its name resolves to, then of the most specific',
+              '/// redefinition (`u16::MAX` when redefinitions are incomparable). Rows',
+              '/// sort by the requested declaration\'s name, which is their lookup key.',
+              'pub type PropertyRow = (u16, u16);',
+              "pub type ClassProperties = (&'static str, &'static [PropertyRow]);", '#[rustfmt::skip]', 'pub static CLASSES: &[ClassProperties] = &[']
+    for cid, c in sorted(classes.items(), key=lambda x: x[1].get("name")):
+        inherited = {p for p, (owner, _) in props.items() if owner in ancestors(cid)}
+        rows = {}
+        for pid in sorted(inherited):
+            name = props[pid][1].get("name")
+            candidates = {p for p in inherited if pid in redefines(p)}
+            nearest = [p for p in candidates if not any(p != q and (p in redefines(q) or props[p][0] != props[q][0] and props[p][0] in ancestors(props[q][0])) for q in candidates)]
+            # If a name appears independently through multiple inheritance,
+            # a declaration on a subclass wins; incomparable declarations must
+            # agree rather than silently choosing one by file order.
+            winner = nearest[0] if len(nearest) == 1 else None
+            if name in rows:
+                old, _ = rows[name]
+                if props[old][0] in ancestors(props[pid][0]):
+                    rows[name] = (pid, winner)
+                elif props[pid][0] not in ancestors(props[old][0]):
+                    raise ValueError(f"ambiguous inherited property: {c.get('name')}.{name}")
+            else:
+                rows[name] = (pid, winner)
+        lines.append(f'    ({json.dumps(c.get("name"))}, &[')
+        for name, (p, w) in sorted(rows.items()):
+            assert props[p][1].get("name") == name, (c.get("name"), name)
+            lines.append(f'        ({indices[p]}, {indices[w] if w else 65535}), // {name}')
+        lines.append('    ]),')
+    lines += ['];', '', '#[rustfmt::skip]', 'pub fn properties(metaclass: &str) -> Option<&\'static [PropertyRow]> {',
+              '    CLASSES.binary_search_by_key(&metaclass, |(name, _)| *name).ok().map(|i| CLASSES[i].1)', '}', '',
+              '#[rustfmt::skip]', 'pub fn property(metaclass: &str, name: &str) -> Option<(&\'static PropertySpec, Option<&\'static PropertySpec>)> {',
+              '    let props = properties(metaclass)?;',
+              '    props.binary_search_by_key(&name, |&(requested, _)| PROPERTIES[requested as usize].name).ok().map(|i| (&PROPERTIES[props[i].0 as usize], PROPERTIES.get(props[i].1 as usize)))', '}', '']
+    return '\n'.join(lines)
+
+
+if __name__ == '__main__':
+    content = generate()
+    if '--check' in sys.argv:
+        if OUT.read_text() != content:
+            raise SystemExit('semantic catalog is stale; run python3 tools/semantic_catalog.py')
+    else:
+        OUT.write_text(content)
diff --git a/tools/test_derived_compositions.py b/tools/test_derived_compositions.py
new file mode 100644
index 0000000..34b8485
--- /dev/null
+++ b/tools/test_derived_compositions.py
@@ -0,0 +1,31 @@
+"""Generation must reject ill-typed, missing and conflicting kind filters."""
+import unittest
+import derived_census as d
+
+
+class Compositions(unittest.TestCase):
+    def record(self, kind, rules=None):
+        return dict(name="items", declaring=[dict(metaclass="Owner", type="Feature", multiplicity="0..*")], rules=rules or {"Owner": f"items = ownedFeature->selectByKind({kind})"})
+
+    def test_type_validation(self):
+        ancestors = {"Feature": set(), "PartUsage": {"Feature"}, "Package": set(), "Owner": set()}
+        self.assertEqual(d.composition_rows([self.record("PartUsage")], ancestors)["items"][1], "PartUsage")
+        for kind in ["Missing", "Package"]:
+            with self.assertRaises(ValueError):
+                d.composition_rows([self.record(kind)], ancestors)
+        with self.assertRaises(ValueError):
+            d.composition_rows([self.record("PartUsage", {"Owner": "items = ownedFeature->selectByKind(PartUsage)", "Other": "items = other->selectByKind(PartUsage)"})], ancestors)
+
+    def test_normative_corrections(self):
+        classes, props = {}, {}
+        for source in d.SOURCES:
+            classes.update(d.load(source, props))
+        rows = d.composition_rows([dict(name=name, **record) for name, record in d.read_xmi().items()], d.ancestors(classes))
+        for name in ["ownedFlow", "nestedFlow"]:
+            self.assertEqual(rows[name][1], "FlowUsage")
+        for name in ["ownedInterface", "nestedInterface"]:
+            self.assertEqual(rows[name][1], "InterfaceUsage")
+
+
+if __name__ == "__main__":
+    unittest.main()